1/*  Part of SWI-Prolog
    2
    3    Author:        Jan Wielemaker
    4    E-mail:        J.Wielemaker@vu.nl
    5    WWW:           http://www.swi-prolog.org
    6    Copyright (c)  2012-2023, VU University Amsterdam
    7                              CWI, Amsterdam
    8                              SWI-Prolog Solutions b.v.
    9    All rights reserved.
   10
   11    Redistribution and use in source and binary forms, with or without
   12    modification, are permitted provided that the following conditions
   13    are met:
   14
   15    1. Redistributions of source code must retain the above copyright
   16       notice, this list of conditions and the following disclaimer.
   17
   18    2. Redistributions in binary form must reproduce the above copyright
   19       notice, this list of conditions and the following disclaimer in
   20       the documentation and/or other materials provided with the
   21       distribution.
   22
   23    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   24    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   25    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
   26    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
   27    COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
   28    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
   29    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
   30    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
   31    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   32    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
   33    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   34    POSSIBILITY OF SUCH DAMAGE.
   35*/
   36
   37:- module(prolog_pack,
   38          [ pack_list_installed/0,
   39            pack_info/1,                % +Name
   40            pack_list/1,                % +Keyword
   41            pack_list/2,                % +Query, +Options
   42            pack_search/1,              % +Keyword
   43            pack_install/1,             % +Name
   44            pack_install/2,             % +Name, +Options
   45            pack_install_local/3,       % :Spec, +Dir, +Options
   46            pack_upgrade/1,             % +Name
   47            pack_rebuild/1,             % +Name
   48            pack_rebuild/0,             % All packages
   49            pack_remove/1,              % +Name
   50            pack_property/2,            % ?Name, ?Property
   51            pack_attach/2,              % +Dir, +Options
   52
   53            pack_url_file/2             % +URL, -File
   54          ]).   55:- use_module(library(apply)).   56:- use_module(library(error)).   57:- use_module(library(option)).   58:- use_module(library(readutil)).   59:- use_module(library(lists)).   60:- use_module(library(filesex)).   61:- use_module(library(xpath)).   62:- use_module(library(settings)).   63:- use_module(library(uri)).   64:- use_module(library(dcg/basics)).   65:- use_module(library(http/http_open)).   66:- use_module(library(http/json)).   67:- use_module(library(http/http_client), []).   % plugin for POST support
   68:- use_module(library(prolog_config)).   69:- use_module(library(debug), [assertion/1]).   70:- use_module(library(pairs), [group_pairs_by_key/2]).   71% Stuff we may not have and may not need
   72:- autoload(library(git)).   73:- autoload(library(sgml)).   74:- autoload(library(sha)).   75:- autoload(library(build/tools)).   76
   77:- meta_predicate
   78    pack_install_local(2, +, +).

  117:- multifile
  118    environment/2.                          % Name, Value
  119
  120:- dynamic
  121    pack_requires/2,                        % Pack, Requirement
  122    pack_provides_db/2.                     % Pack, Provided
  123
  124
  125                 /*******************************
  126                 *          CONSTANTS           *
  127                 *******************************/
  128
  129:- setting(server, atom, 'https://www.swi-prolog.org/pack/',
  130           'Server to exchange pack information').  131
  132
  133                 /*******************************
  134                 *         PACKAGE INFO         *
  135                 *******************************/

 current_pack(?Pack) is nondet

 current_pack(?Pack, ?Dir) is nondet

True if Pack is a currently installed pack.

  142current_pack(Pack) :-
  143    current_pack(Pack, _).
  144
  145current_pack(Pack, Dir) :-
  146    '$pack':pack(Pack, Dir).

 pack_list_installed is det

List currently installed packages. This calls

?- pack_list('', [server(false)]).

See also

- pack_list/2.

  156pack_list_installed :-
  157    pack_list('', [server(false)]).

 pack_info(+Pack)

Print more detailed information about Pack.

  163pack_info(Name) :-
  164    pack_info(info, Name).
  165
  166pack_info(Level, Name) :-
  167    must_be(atom, Name),
  168    findall(Info, pack_info(Name, Level, Info), Infos0),
  169    (   Infos0 == []
  170    ->  print_message(warning, pack(no_pack_installed(Name))),
  171        fail
  172    ;   true
  173    ),
  174    update_dependency_db(Name, Infos0),
  175    findall(Def,  pack_default(Level, Infos, Def), Defs),
  176    append(Infos0, Defs, Infos1),
  177    sort(Infos1, Infos),
  178    show_info(Name, Infos, [info(Level)]).
  179
  180
  181show_info(_Name, _Properties, Options) :-
  182    option(silent(true), Options),
  183    !.
  184show_info(Name, Properties, Options) :-
  185    option(info(list), Options),
  186    !,
  187    memberchk(title(Title), Properties),
  188    memberchk(version(Version), Properties),
  189    format('i ~w@~w ~28|- ~w~n', [Name, Version, Title]).
  190show_info(Name, Properties, _) :-
  191    !,
  192    print_property_value('Package'-'~w', [Name]),
  193    findall(Term, pack_level_info(info, Term, _, _), Terms),
  194    maplist(print_property(Properties), Terms).
  195
  196print_property(_, nl) :-
  197    !,
  198    format('~n').
  199print_property(Properties, Term) :-
  200    findall(Term, member(Term, Properties), Terms),
  201    Terms \== [],
  202    !,
  203    pack_level_info(_, Term, LabelFmt, _Def),
  204    (   LabelFmt = Label-FmtElem
  205    ->  true
  206    ;   Label = LabelFmt,
  207        FmtElem = '~w'
  208    ),
  209    multi_valued(Terms, FmtElem, FmtList, Values),
  210    atomic_list_concat(FmtList, ', ', Fmt),
  211    print_property_value(Label-Fmt, Values).
  212print_property(_, _).
  213
  214multi_valued([H], LabelFmt, [LabelFmt], Values) :-
  215    !,
  216    H =.. [_|Values].
  217multi_valued([H|T], LabelFmt, [LabelFmt|LT], Values) :-
  218    H =.. [_|VH],
  219    append(VH, MoreValues, Values),
  220    multi_valued(T, LabelFmt, LT, MoreValues).
  221
  222
  223pvalue_column(24).
  224print_property_value(Prop-Fmt, Values) :-
  225    !,
  226    pvalue_column(C),
  227    atomic_list_concat(['~w:~t~*|', Fmt, '~n'], Format),
  228    format(Format, [Prop,C|Values]).
  229
  230pack_info(Name, Level, Info) :-
  231    '$pack':pack(Name, BaseDir),
  232    pack_dir_info(BaseDir, Level, Info).
  233
  234pack_dir_info(BaseDir, Level, Info) :-
  235    (   Info = directory(BaseDir)
  236    ;   pack_info_term(BaseDir, Info)
  237    ),
  238    pack_level_info(Level, Info, _Format, _Default).
  239
  240:- public pack_level_info/4.                    % used by web-server
  241
  242pack_level_info(_,    title(_),         'Title',                   '<no title>').
  243pack_level_info(_,    version(_),       'Installed version',       '<unknown>').
  244pack_level_info(info, directory(_),     'Installed in directory',  -).
  245pack_level_info(info, author(_, _),     'Author'-'~w <~w>',        -).
  246pack_level_info(info, maintainer(_, _), 'Maintainer'-'~w <~w>',    -).
  247pack_level_info(info, packager(_, _),   'Packager'-'~w <~w>',      -).
  248pack_level_info(info, home(_),          'Home page',               -).
  249pack_level_info(info, download(_),      'Download URL',            -).
  250pack_level_info(_,    provides(_),      'Provides',                -).
  251pack_level_info(_,    requires(_),      'Requires',                -).
  252pack_level_info(_,    conflicts(_),     'Conflicts with',          -).
  253pack_level_info(_,    replaces(_),      'Replaces packages',       -).
  254pack_level_info(info, library(_),	'Provided libraries',      -).
  255
  256pack_default(Level, Infos, Def) :-
  257    pack_level_info(Level, ITerm, _Format, Def),
  258    Def \== (-),
  259    \+ memberchk(ITerm, Infos).

 pack_info_term(+PackDir, ?Info) is nondet

True when Info is meta-data for the package PackName.

  265pack_info_term(BaseDir, Info) :-
  266    directory_file_path(BaseDir, 'pack.pl', InfoFile),
  267    catch(
  268        setup_call_cleanup(
  269            open(InfoFile, read, In),
  270            term_in_stream(In, Info),
  271            close(In)),
  272        error(existence_error(source_sink, InfoFile), _),
  273        ( print_message(error, pack(no_meta_data(BaseDir))),
  274          fail
  275        )).
  276pack_info_term(BaseDir, library(Lib)) :-
  277    atom_concat(BaseDir, '/prolog/', LibDir),
  278    atom_concat(LibDir, '*.pl', Pattern),
  279    expand_file_name(Pattern, Files),
  280    maplist(atom_concat(LibDir), Plain, Files),
  281    convlist(base_name, Plain, Libs),
  282    member(Lib, Libs).
  283
  284base_name(File, Base) :-
  285    file_name_extension(Base, pl, File).
  286
  287term_in_stream(In, Term) :-
  288    repeat,
  289        read_term(In, Term0, []),
  290        (   Term0 == end_of_file
  291        ->  !, fail
  292        ;   Term = Term0,
  293            valid_info_term(Term0)
  294        ).
  295
  296valid_info_term(Term) :-
  297    Term =.. [Name|Args],
  298    same_length(Args, Types),
  299    Decl =.. [Name|Types],
  300    (   pack_info_term(Decl)
  301    ->  maplist(valid_info_arg, Types, Args)
  302    ;   print_message(warning, pack(invalid_info(Term))),
  303        fail
  304    ).
  305
  306valid_info_arg(Type, Arg) :-
  307    must_be(Type, Arg).

 pack_info_term(?Term) is nondet

True when Term describes name and arguments of a valid package info term.

  314pack_info_term(name(atom)).                     % Synopsis
  315pack_info_term(title(atom)).
  316pack_info_term(keywords(list(atom))).
  317pack_info_term(description(list(atom))).
  318pack_info_term(version(version)).
  319pack_info_term(author(atom, email_or_url_or_empty)).     % Persons
  320pack_info_term(maintainer(atom, email_or_url)).
  321pack_info_term(packager(atom, email_or_url)).
  322pack_info_term(pack_version(nonneg)).           % Package convention version
  323pack_info_term(home(atom)).                     % Home page
  324pack_info_term(download(atom)).                 % Source
  325pack_info_term(provides(atom)).                 % Dependencies
  326pack_info_term(requires(dependency)).
  327pack_info_term(conflicts(dependency)).          % Conflicts with package
  328pack_info_term(replaces(atom)).                 % Replaces another package
  329pack_info_term(autoload(boolean)).              % Default installation options
  330
  331:- multifile
  332    error:has_type/2.  333
  334error:has_type(version, Version) :-
  335    atom(Version),
  336    version_data(Version, _Data).
  337error:has_type(email_or_url, Address) :-
  338    atom(Address),
  339    (   sub_atom(Address, _, _, _, @)
  340    ->  true
  341    ;   uri_is_global(Address)
  342    ).
  343error:has_type(email_or_url_or_empty, Address) :-
  344    (   Address == ''
  345    ->  true
  346    ;   error:has_type(email_or_url, Address)
  347    ).
  348error:has_type(dependency, Value) :-
  349    is_dependency(Value, _Token, _Version).
  350
  351version_data(Version, version(Data)) :-
  352    atomic_list_concat(Parts, '.', Version),
  353    maplist(atom_number, Parts, Data).
  354
  355is_dependency(Token, Token, *) :-
  356    atom(Token).
  357is_dependency(Term, Token, VersionCmp) :-
  358    Term =.. [Op,Token,Version],
  359    cmp(Op, _),
  360    version_data(Version, _),
  361    VersionCmp =.. [Op,Version].
  362
  363cmp(<,  @<).
  364cmp(=<, @=<).
  365cmp(==, ==).
  366cmp(>=, @>=).
  367cmp(>,  @>).
  368
  369
  370                 /*******************************
  371                 *            SEARCH            *
  372                 *******************************/

 pack_list(+Query) is det

 pack_list(+Query, +Options) is det

 pack_search(+Query) is det

Query package server and installed packages and display results. Query is matches case-insensitively against the name and title of known and installed packages. For each matching package, a single line is displayed that provides:

• Installation status
  • p: package, not installed
  • i: installed package; up-to-date with public version
  • U: installed package; can be upgraded
  • A: installed package; newer than publically available
  • l: installed package; not on server
• Name@Version
• Name@Version(ServerVersion)
• Title

Options processed:

installed(true)

Only list packages that are locally installed. Contacts the server to compare our local version to the latest available version.

outdated(true)

Only list packages that need to be updated. This option implies installed(true).

server((Server|false))

If false, do not contact the server. This implies installed(true). Otherwise, use the given pack server.

Hint: ?- pack_list(''). lists all packages.

The predicates pack_list/1 and pack_search/1 are synonyms. Both contact the package server at https://www.swi-prolog.org to find available packages.

See also

- pack_list_installed/0 to list installed packages without contacting the server.

  415pack_list(Query) :-
  416    pack_list(Query, []).
  417
  418pack_search(Query) :-
  419    pack_list(Query, []).
  420
  421pack_list(Query, Options) :-
  422    (   option(installed(true), Options)
  423    ;   option(outdated(true), Options)
  424    ;   option(server(false), Options)
  425    ),
  426    !,
  427    local_search(Query, Local),
  428    maplist(arg(1), Local, Packs),
  429    (   option(server(false), Options)
  430    ->  Hits = []
  431    ;   query_pack_server(info(Packs), true(Hits), [])
  432    ),
  433    list_hits(Hits, Local, Options).
  434pack_list(Query, _Options) :-
  435    query_pack_server(search(Query), Result, []),
  436    (   Result == false
  437    ->  (   local_search(Query, Packs),
  438            Packs \== []
  439        ->  forall(member(pack(Pack, Stat, Title, Version, _), Packs),
  440                   format('~w ~w@~w ~28|- ~w~n',
  441                          [Stat, Pack, Version, Title]))
  442        ;   print_message(warning, pack(search_no_matches(Query)))
  443        )
  444    ;   Result = true(Hits),       % Hits = list(pack(Name, p, Title, Version, URL))
  445        local_search(Query, Local),
  446        list_hits(Hits, Local, [])
  447    ).
  448
  449list_hits(Hits, Local, Options) :-
  450    append(Hits, Local, All),
  451    sort(All, Sorted),
  452    join_status(Sorted, Packs0),
  453    include(filtered(Options), Packs0, Packs),
  454    maplist(list_hit(Options), Packs).
  455
  456filtered(Options, pack(_,Tag,_,_,_)) :-
  457    option(outdated(true), Options),
  458    !,
  459    Tag == 'U'.
  460filtered(_, _).
  461
  462list_hit(_Options, pack(Pack, Tag, Title, Version, _URL)) =>
  463    list_tag(Tag),
  464    ansi_format(code, '~w', [Pack]),
  465    format('@'),
  466    list_version(Tag, Version),
  467    format('~35|- ', []),
  468    ansi_format(comment, '~w~n', [Title]).
  469
  470list_tag(Tag) :-
  471    tag_color(Tag, Color),
  472    ansi_format(Color, '~w ', [Tag]).
  473
  474list_version(Tag, VersionI-VersionS) =>
  475    tag_color(Tag, Color),
  476    ansi_format(Color, '~w', [VersionI]),
  477    ansi_format(bold, '(~w)', [VersionS]).
  478list_version(_Tag, Version) =>
  479    ansi_format([], '~w', [Version]).
  480
  481tag_color('U', warning) :- !.
  482tag_color('A', comment) :- !.
  483tag_color(_, []).

 join_status(+PacksIn, -PacksOut) is det

Combine local and remote information to assess the status of each package. PacksOut is a list of pack(Name, Status, Version, URL). If the versions do not match, Version is VersionInstalled-VersionRemote and similar for thee URL.

  492join_status([], []).
  493join_status([ pack(Pack, i, Title, Version, URL),
  494              pack(Pack, p, Title, Version, _)
  495            | T0
  496            ],
  497            [ pack(Pack, i, Title, Version, URL)
  498            | T
  499            ]) :-
  500    !,
  501    join_status(T0, T).
  502join_status([ pack(Pack, i, Title, VersionI, URLI),
  503              pack(Pack, p, _,     VersionS, URLS)
  504            | T0
  505            ],
  506            [ pack(Pack, Tag, Title, VersionI-VersionS, URLI-URLS)
  507            | T
  508            ]) :-
  509    !,
  510    version_data(VersionI, VDI),
  511    version_data(VersionS, VDS),
  512    (   VDI @< VDS
  513    ->  Tag = 'U'
  514    ;   Tag = 'A'
  515    ),
  516    join_status(T0, T).
  517join_status([ pack(Pack, i, Title, VersionI, URL)
  518            | T0
  519            ],
  520            [ pack(Pack, l, Title, VersionI, URL)
  521            | T
  522            ]) :-
  523    !,
  524    join_status(T0, T).
  525join_status([H|T0], [H|T]) :-
  526    join_status(T0, T).

 local_search(+Query, -Packs:list(atom)) is det

Search locally installed packs.

  532local_search(Query, Packs) :-
  533    findall(Pack, matching_installed_pack(Query, Pack), Packs).
  534
  535matching_installed_pack(Query, pack(Pack, i, Title, Version, URL)) :-
  536    current_pack(Pack),
  537    findall(Term,
  538            ( pack_info(Pack, _, Term),
  539              search_info(Term)
  540            ), Info),
  541    (   sub_atom_icasechk(Pack, _, Query)
  542    ->  true
  543    ;   memberchk(title(Title), Info),
  544        sub_atom_icasechk(Title, _, Query)
  545    ),
  546    option(title(Title), Info, '<no title>'),
  547    option(version(Version), Info, '<no version>'),
  548    option(download(URL), Info, '<no download url>').
  549
  550search_info(title(_)).
  551search_info(version(_)).
  552search_info(download(_)).
  553
  554
  555                 /*******************************
  556                 *            INSTALL           *
  557                 *******************************/

 pack_install(+Spec:atom) is det

Install a package. Spec is one of

• A package name. This queries the package repository at http://www.swi-prolog.org
• Archive file name
• HTTP URL of an archive file name. This URL may contain a star (*) for the version. In this case pack_install asks for the directory content and selects the latest version.
• GIT URL (not well supported yet)
• A local directory name given as file:// URL
• '.', in which case a relative symlink is created to the current directory (all other options for Spec make a copy of the files).

After resolving the type of package, pack_install/2 is used to do the actual installation.

  578pack_install(Spec) :-
  579    pack_default_options(Spec, Pack, [], Options),
  580    pack_install(Pack, [pack(Pack)|Options]).

 pack_default_options(+Spec, -Pack, +OptionsIn, -Options) is det

Establish the pack name (Pack) and install options from a specification and options (OptionsIn) provided by the user.

  587pack_default_options(_Spec, Pack, OptsIn, Options) :-
  588    option(already_installed(pack(Pack,_Version)), OptsIn),
  589    !,
  590    Options = OptsIn.
  591pack_default_options(_Spec, Pack, OptsIn, Options) :-
  592    option(url(URL), OptsIn),
  593    !,
  594    (   option(git(_), OptsIn)
  595    ->  Options = OptsIn
  596    ;   git_url(URL, Pack)
  597    ->  Options = [git(true)|OptsIn]
  598    ;   Options = OptsIn
  599    ),
  600    (   nonvar(Pack)
  601    ->  true
  602    ;   option(pack(Pack), Options)
  603    ->  true
  604    ;   pack_version_file(Pack, _Version, URL)
  605    ).
  606pack_default_options(Archive, Pack, _, Options) :-      % Install from archive
  607    must_be(atom, Archive),
  608    \+ uri_is_global(Archive),
  609    expand_file_name(Archive, [File]),
  610    exists_file(File),
  611    !,
  612    pack_version_file(Pack, Version, File),
  613    uri_file_name(FileURL, File),
  614    Options = [url(FileURL), version(Version)].
  615pack_default_options(URL, Pack, _, Options) :-
  616    git_url(URL, Pack),
  617    !,
  618    Options = [git(true), url(URL)].
  619pack_default_options(FileURL, Pack, _, Options) :-      % Install from directory
  620    uri_file_name(FileURL, Dir),
  621    exists_directory(Dir),
  622    pack_info_term(Dir, name(Pack)),
  623    !,
  624    (   pack_info_term(Dir, version(Version))
  625    ->  uri_file_name(DirURL, Dir),
  626        Options = [url(DirURL), version(Version)]
  627    ;   throw(error(existence_error(key, version, Dir),_))
  628    ).
  629pack_default_options('.', Pack, _, Options) :-          % Install from CWD
  630    pack_info_term('.', name(Pack)),
  631    !,
  632    working_directory(Dir, Dir),
  633    (   pack_info_term(Dir, version(Version))
  634    ->  uri_file_name(DirURL, Dir),
  635        Options = [url(DirURL), version(Version) | Options1],
  636        (   current_prolog_flag(windows, true)
  637        ->  Options1 = []
  638        ;   Options1 = [link(true), rebuild(make)]
  639        )
  640    ;   throw(error(existence_error(key, version, Dir),_))
  641    ).
  642pack_default_options(URL, Pack, _, Options) :-          % Install from URL
  643    pack_version_file(Pack, Version, URL),
  644    download_url(URL),
  645    !,
  646    available_download_versions(URL, [URLVersion-LatestURL|_]),
  647    Options = [url(LatestURL)|VersionOptions],
  648    version_options(Version, URLVersion, VersionOptions).
  649pack_default_options(Pack, Pack, OptsIn, Options) :-    % Install from name
  650    \+ uri_is_global(Pack),                             % ignore URLs
  651    query_pack_server(locate(Pack), Reply, OptsIn),
  652    (   Reply = true(Results)
  653    ->  pack_select_candidate(Pack, Results, OptsIn, Options)
  654    ;   print_message(warning, pack(no_match(Pack))),
  655        fail
  656    ).
  657
  658version_options(Version, Version, [version(Version)]) :- !.
  659version_options(Version, _, [version(Version)]) :-
  660    Version = version(List),
  661    maplist(integer, List),
  662    !.
  663version_options(_, _, []).

 pack_select_candidate(+Pack, +AvailableVersions, +OptionsIn, -Options)

Select from available packages.

  669pack_select_candidate(Pack, [AtomVersion-_|_], Options,
  670                      [already_installed(pack(Pack, Installed))|Options]) :-
  671    current_pack(Pack),
  672    pack_info(Pack, _, version(InstalledAtom)),
  673    atom_version(InstalledAtom, Installed),
  674    atom_version(AtomVersion, Version),
  675    Installed @>= Version,
  676    in_explicit_pack_dir(Pack, Options),
  677    !.
  678pack_select_candidate(_Pack, Available, Options, OptsOut) :-
  679    option(url(URL), Options),
  680    memberchk(_Version-URLs, Available),
  681    memberchk(URL, URLs),
  682    !,
  683    (   git_url(URL, _)
  684    ->  Extra = [git(true)]
  685    ;   Extra = []
  686    ),
  687    OptsOut = [url(URL), inquiry(true) | Extra].
  688pack_select_candidate(Pack, [Version-[URL]|_], Options,
  689                      [url(URL), git(true), inquiry(true)]) :-
  690    git_url(URL, _Pack),
  691    !,
  692    confirm(install_from(Pack, Version, git(URL)), yes, Options).
  693pack_select_candidate(Pack, [Version-[URL]|More], Options,
  694                      [url(URL), inquiry(true) | Upgrade]) :-
  695    (   More == []
  696    ->  !
  697    ;   true
  698    ),
  699    confirm(install_from(Pack, Version, URL), yes, Options),
  700    !,
  701    add_upgrade(Pack, Upgrade).
  702pack_select_candidate(Pack, [Version-URLs|_], Options,
  703                      [url(URL), inquiry(true)|Rest]) :-
  704    maplist(url_menu_item, URLs, Tagged),
  705    append(Tagged, [cancel=cancel], Menu),
  706    Menu = [Default=_|_],
  707    menu(pack(select_install_from(Pack, Version)),
  708         Menu, Default, Choice, Options),
  709    (   Choice == cancel
  710    ->  fail
  711    ;   Choice = git(URL)
  712    ->  Rest = [git(true)|Upgrade]
  713    ;   Choice = URL,
  714        Rest = Upgrade
  715    ),
  716    add_upgrade(Pack, Upgrade).
  717
  718add_upgrade(Pack, Options) :-
  719    current_pack(Pack),
  720    !,
  721    Options = [upgrade(true)].
  722add_upgrade(_, []).
  723
  724url_menu_item(URL, git(URL)=install_from(git(URL))) :-
  725    git_url(URL, _),
  726    !.
  727url_menu_item(URL, URL=install_from(URL)).

 in_explicit_pack_dir(+Pack, +Options) is semidet

True when Pack is installed in the explicit target directory.

  733in_explicit_pack_dir(Pack, Options) :-
  734    option(package_directory(Root), Options),
  735    current_pack(Pack, PackDir),
  736    file_directory_name(PackDir, Parent),
  737    same_file(Parent, Root).

 pack_install(+Name, +Options) is det

Install package Name. Processes the options below. Default options as would be used by pack_install/1 are used to complete the provided Options.

url(+URL)

Source for downloading the package

package_directory(+Dir)

Directory into which to install the package.

global(+Boolean)

If true, install in the XDG common application data path, making the pack accessible to everyone. If false, install in the XDG user application data path, making the pack accessible for the current user only. If the option is absent, use the first existing and writable directory. If that doesn't exist find locations where it can be created and prompt the user to do so.

insecure(+Boolean)

When true (default false), do not perform any checks on SSL certificates when downloading using https.

interactive(+Boolean)

Use default answer without asking the user if there is a default action.

silent(+Boolean)

If true (default false), suppress informational progress messages.

upgrade(+Boolean)

If true (default false), upgrade package if it is already installed.

rebuild(Condition)

Rebuild the foreign components. Condition is one of if_absent (default, do nothing if the directory with foreign resources exists), make (run make) or true (run `make distclean` followed by the default configure and build steps).

test(Boolean)

If true (default), run the pack tests.

git(+Boolean)

If true (default false unless URL ends with =.git=), assume the URL is a GIT repository.

link(+Boolean)

Can be used if the installation source is a local directory and the file system supports symbolic links. In this case the system adds the current directory to the pack registration using a symbolic link and performs the local installation steps.

Non-interactive installation can be established using the option interactive(false). It is adviced to install from a particular trusted URL instead of the plain pack name for unattented operation.

  790pack_install(Spec, Options) :-
  791    pack_default_options(Spec, Pack, Options, DefOptions),
  792    (   option(already_installed(Installed), DefOptions)
  793    ->  print_message(informational, pack(already_installed(Installed)))
  794    ;   merge_options(Options, DefOptions, PackOptions),
  795        update_dependency_db,
  796        pack_install_dir(PackDir, PackOptions),
  797        pack_install(Pack, PackDir, PackOptions),
  798        pack_make_available(Pack, PackDir, PackOptions)
  799    ).
  800
  801pack_install_dir(PackDir, Options) :-
  802    option(package_directory(PackDir), Options),
  803    !.
  804pack_install_dir(PackDir, Options) :-
  805    base_alias(Alias, Options),
  806    absolute_file_name(Alias, PackDir,
  807                       [ file_type(directory),
  808                         access(write),
  809                         file_errors(fail)
  810                       ]),
  811    !.
  812pack_install_dir(PackDir, Options) :-
  813    pack_create_install_dir(PackDir, Options).
  814
  815base_alias(Alias, Options) :-
  816    option(global(true), Options),
  817    !,
  818    Alias = common_app_data(pack).
  819base_alias(Alias, Options) :-
  820    option(global(false), Options),
  821    !,
  822    Alias = user_app_data(pack).
  823base_alias(Alias, _Options) :-
  824    Alias = pack('.').
  825
  826pack_create_install_dir(PackDir, Options) :-
  827    base_alias(Alias, Options),
  828    findall(Candidate = create_dir(Candidate),
  829            ( absolute_file_name(Alias, Candidate, [solutions(all)]),
  830              \+ exists_file(Candidate),
  831              \+ exists_directory(Candidate),
  832              file_directory_name(Candidate, Super),
  833              (   exists_directory(Super)
  834              ->  access_file(Super, write)
  835              ;   true
  836              )
  837            ),
  838            Candidates0),
  839    list_to_set(Candidates0, Candidates),   % keep order
  840    pack_create_install_dir(Candidates, PackDir, Options).
  841
  842pack_create_install_dir(Candidates, PackDir, Options) :-
  843    Candidates = [Default=_|_],
  844    !,
  845    append(Candidates, [cancel=cancel], Menu),
  846    menu(pack(create_pack_dir), Menu, Default, Selected, Options),
  847    Selected \== cancel,
  848    (   catch(make_directory_path(Selected), E,
  849              (print_message(warning, E), fail))
  850    ->  PackDir = Selected
  851    ;   delete(Candidates, PackDir=create_dir(PackDir), Remaining),
  852        pack_create_install_dir(Remaining, PackDir, Options)
  853    ).
  854pack_create_install_dir(_, _, _) :-
  855    print_message(error, pack(cannot_create_dir(pack(.)))),
  856    fail.

 pack_install(+Pack, +PackDir, +Options)

Install package Pack into PackDir. Options:

url(URL)

Install from the given URL, URL is either a file://, a git URL or a download URL.

upgrade(Boolean)

If Pack is already installed and Boolean is true, update the package to the latest version. If Boolean is false print an error and fail.

  871pack_install(Name, _, Options) :-
  872    current_pack(Name, Dir),
  873    option(upgrade(false), Options, false),
  874    \+ pack_is_in_local_dir(Name, Dir, Options),
  875    (   option(package_directory(_), Options)
  876    ->  in_explicit_pack_dir(Name, Options)
  877    ;   true
  878    ),
  879    print_message(error, pack(already_installed(Name))),
  880    pack_info(Name),
  881    print_message(information, pack(remove_with(Name))),
  882    !,
  883    fail.
  884pack_install(Name, PackDir, Options) :-
  885    option(url(URL), Options),
  886    uri_file_name(URL, Source),
  887    !,
  888    pack_install_from_local(Source, PackDir, Name, Options).
  889pack_install(Name, PackDir, Options) :-
  890    option(url(URL), Options),
  891    uri_components(URL, Components),
  892    uri_data(scheme, Components, Scheme),
  893    pack_install_from_url(Scheme, URL, PackDir, Name, Options).

 pack_install_from_local(+Source, +PackTopDir, +Name, +Options)

Install a package from a local media.

To be done

- Provide an option to install directories using a link (or file-links).

  902pack_install_from_local(Source, PackTopDir, Name, Options) :-
  903    exists_directory(Source),
  904    !,
  905    directory_file_path(PackTopDir, Name, PackDir),
  906    (   option(link(true), Options)
  907    ->  (   same_file(Source, PackDir)
  908        ->  true
  909        ;   atom_concat(PackTopDir, '/', PackTopDirS),
  910            relative_file_name(Source, PackTopDirS, RelPath),
  911            link_file(RelPath, PackDir, symbolic),
  912            assertion(same_file(Source, PackDir))
  913        )
  914    ;   prepare_pack_dir(PackDir, Options),
  915        copy_directory(Source, PackDir)
  916    ),
  917    pack_post_install(Name, PackDir, Options).
  918pack_install_from_local(Source, PackTopDir, Name, Options) :-
  919    exists_file(Source),
  920    directory_file_path(PackTopDir, Name, PackDir),
  921    prepare_pack_dir(PackDir, Options),
  922    pack_unpack(Source, PackDir, Name, Options),
  923    pack_post_install(Name, PackDir, Options).
  924
  925pack_is_in_local_dir(_Pack, PackDir, Options) :-
  926    option(url(DirURL), Options),
  927    uri_file_name(DirURL, Dir),
  928    same_file(PackDir, Dir).

 pack_unpack(+SourceFile, +PackDir, +Pack, +Options)

Unpack an archive to the given package dir.

  935:- if(exists_source(library(archive))).  936pack_unpack(Source, PackDir, Pack, Options) :-
  937    ensure_loaded_archive,
  938    pack_archive_info(Source, Pack, _Info, StripOptions),
  939    prepare_pack_dir(PackDir, Options),
  940    archive_extract(Source, PackDir,
  941                    [ exclude(['._*'])          % MacOS resource forks
  942                    | StripOptions
  943                    ]).
  944:- else.  945pack_unpack(_,_,_,_) :-
  946    existence_error(library, archive).
  947:- endif.

 pack_install_local(:Spec, +Dir, +Options) is det

Install a number of packages in a local directory. This predicate supports installing packages local to an application rather than globally.

  955pack_install_local(_:Pairs, Dir, Options), is_list(Pairs) =>
  956    ensure_directory(Dir),
  957    pairs_keys(Pairs, Packs),
  958    query_pack_server(info(Packs), true(Hits), []),
  959    local_packs(Dir, Existing),
  960    maplist(pack_install_local_(Hits, Existing,
  961                                [ package_directory(Dir)|Options
  962                                ]),
  963            Pairs).
  964pack_install_local(M:Gen, Dir, Options), callable(Gen) =>
  965    findall(Pack-Options, call(M:Gen, Pack, Options), Pairs),
  966    pack_install_local(Pairs, Dir, Options).
  967pack_install_local(Spec, _, _) =>
  968    type_error(pairs_or_callable, Spec).

 pack_install_local_(+Latest, +Installed, +Options, +PackAndOptions) is det

  973pack_install_local_(_Latest, Installed, _Options, Pack-PackOptions) :-
  974    option(version(ReqVersion), PackOptions),
  975    memberchk(pack(Pack, i, _Title, Version, _URL), Installed),
  976    catch(require_version(pack(Pack), Version, ReqVersion),
  977          error(version_error(pack(Pack), Version, ReqVersion),_),
  978          fail),
  979    !.                                          % matching version
  980pack_install_local_(Latest, Installed, Options, Pack-PackOptions) :-
  981    memberchk(pack(Pack, p, _TitleS, VersionS, _URLS), Latest),
  982    memberchk(pack(Pack, i, _TitleI, VersionI, _URLI), Installed),
  983    !,
  984    version_data(VersionI, VDI),
  985    version_data(VersionS, VDS),
  986    (   VDI @< VDS
  987    ->  merge_options([upgrade(true)|PackOptions], Options, InstallOptions),
  988        pack_install(Pack, InstallOptions)
  989    ;   true                                    % up-to-date
  990    ).
  991pack_install_local_(Latest, _Installed, Options, Pack-PackOptions) :-
  992    memberchk(pack(Pack, p, _Title, _Version, _URL), Latest),
  993    !,
  994    merge_options([upgrade(true)|PackOptions], Options, InstallOptions),
  995    pack_install(Pack, InstallOptions).         % not installed
  996pack_install_local_(_Latest, _Installed, _Options, Pack-_PackOptions) :-
  997    print_message(error, pack(no_match(Pack))). % not known

 local_packs(+Dir, -Packs) is det

True when Packs is a list of package search term results for packs installed in Dir.

 1004local_packs(Dir, Packs) :-
 1005    findall(Pack, pack_in_subdir(Dir, Pack), Packs).
 1006
 1007pack_in_subdir(Dir, pack(Pack, i, Title, Version, URL)) :-
 1008    directory_member(Dir, PackDir,
 1009                     [ file_type(directory),
 1010                       hidden(false)
 1011                     ]),
 1012    directory_file_path(PackDir, 'pack.pl', MetaFile),
 1013    exists_file(MetaFile),
 1014    file_base_name(PackDir, DirName),
 1015    findall(Term,
 1016            ( pack_dir_info(PackDir, _, Term),
 1017              search_info(Term)
 1018            ), Info),
 1019    option(pack(Pack), Info, DirName),
 1020    option(title(Title), Info, '<no title>'),
 1021    option(version(Version), Info, '<no version>'),
 1022    option(download(URL), Info, '<no download url>').
 1023
 1024
 1025                 /*******************************
 1026                 *             INFO             *
 1027                 *******************************/

 pack_archive_info(+Archive, +Pack, -Info, -Strip)

True when Archive archives Pack. Info is unified with the terms from pack.pl in the pack and Strip is the strip-option for archive_extract/3.

Requires library(archive), which is lazily loaded when needed.

Errors

- existence_error(pack_file, 'pack.pl') if the archive doesn't contain pack.pl

- Syntax errors if pack.pl cannot be parsed.

 1041:- if(exists_source(library(archive))). 1042ensure_loaded_archive :-
 1043    current_predicate(archive_open/3),
 1044    !.
 1045ensure_loaded_archive :-
 1046    use_module(library(archive)).
 1047
 1048pack_archive_info(Archive, Pack, [archive_size(Bytes)|Info], Strip) :-
 1049    ensure_loaded_archive,
 1050    size_file(Archive, Bytes),
 1051    setup_call_cleanup(
 1052        archive_open(Archive, Handle, []),
 1053        (   repeat,
 1054            (   archive_next_header(Handle, InfoFile)
 1055            ->  true
 1056            ;   !, fail
 1057            )
 1058        ),
 1059        archive_close(Handle)),
 1060    file_base_name(InfoFile, 'pack.pl'),
 1061    atom_concat(Prefix, 'pack.pl', InfoFile),
 1062    strip_option(Prefix, Pack, Strip),
 1063    setup_call_cleanup(
 1064        archive_open_entry(Handle, Stream),
 1065        read_stream_to_terms(Stream, Info),
 1066        close(Stream)),
 1067    !,
 1068    must_be(ground, Info),
 1069    maplist(valid_info_term, Info).
 1070:- else. 1071pack_archive_info(_, _, _, _) :-
 1072    existence_error(library, archive).
 1073:- endif. 1074pack_archive_info(_, _, _, _) :-
 1075    existence_error(pack_file, 'pack.pl').
 1076
 1077strip_option('', _, []) :- !.
 1078strip_option('./', _, []) :- !.
 1079strip_option(Prefix, Pack, [remove_prefix(Prefix)]) :-
 1080    atom_concat(PrefixDir, /, Prefix),
 1081    file_base_name(PrefixDir, Base),
 1082    (   Base == Pack
 1083    ->  true
 1084    ;   pack_version_file(Pack, _, Base)
 1085    ->  true
 1086    ;   \+ sub_atom(PrefixDir, _, _, _, /)
 1087    ).
 1088
 1089read_stream_to_terms(Stream, Terms) :-
 1090    read(Stream, Term0),
 1091    read_stream_to_terms(Term0, Stream, Terms).
 1092
 1093read_stream_to_terms(end_of_file, _, []) :- !.
 1094read_stream_to_terms(Term0, Stream, [Term0|Terms]) :-
 1095    read(Stream, Term1),
 1096    read_stream_to_terms(Term1, Stream, Terms).

 pack_git_info(+GitDir, -Hash, -Info) is det

Retrieve info from a cloned git repository that is compatible with pack_archive_info/4.

 1104pack_git_info(GitDir, Hash, [git(true), installed_size(Bytes)|Info]) :-
 1105    exists_directory(GitDir),
 1106    !,
 1107    git_ls_tree(Entries, [directory(GitDir)]),
 1108    git_hash(Hash, [directory(GitDir)]),
 1109    maplist(arg(4), Entries, Sizes),
 1110    sum_list(Sizes, Bytes),
 1111    directory_file_path(GitDir, 'pack.pl', InfoFile),
 1112    read_file_to_terms(InfoFile, Info, [encoding(utf8)]),
 1113    must_be(ground, Info),
 1114    maplist(valid_info_term, Info).

 download_file_sanity_check(+Archive, +Pack, +Info) is semidet

Perform basic sanity checks on DownloadFile

 1120download_file_sanity_check(Archive, Pack, Info) :-
 1121    info_field(name(Name), Info),
 1122    info_field(version(VersionAtom), Info),
 1123    atom_version(VersionAtom, Version),
 1124    pack_version_file(PackA, VersionA, Archive),
 1125    must_match([Pack, PackA, Name], name),
 1126    must_match([Version, VersionA], version).
 1127
 1128info_field(Field, Info) :-
 1129    memberchk(Field, Info),
 1130    ground(Field),
 1131    !.
 1132info_field(Field, _Info) :-
 1133    functor(Field, FieldName, _),
 1134    print_message(error, pack(missing(FieldName))),
 1135    fail.
 1136
 1137must_match(Values, _Field) :-
 1138    sort(Values, [_]),
 1139    !.
 1140must_match(Values, Field) :-
 1141    print_message(error, pack(conflict(Field, Values))),
 1142    fail.
 1143
 1144
 1145                 /*******************************
 1146                 *         INSTALLATION         *
 1147                 *******************************/

 prepare_pack_dir(+Dir, +Options)

Prepare for installing the package into Dir. This

• If the directory exist and is empty, done.
• Else if the directory exists, remove the directory and recreate it. Note that if the directory is a symlink this just deletes the link.
• Else create the directory.

 1159prepare_pack_dir(Dir, Options) :-
 1160    exists_directory(Dir),
 1161    !,
 1162    (   empty_directory(Dir)
 1163    ->  true
 1164    ;   (   option(upgrade(true), Options)
 1165        ;   confirm(remove_existing_pack(Dir), yes, Options)
 1166        )
 1167    ->  delete_directory_and_contents(Dir),
 1168        make_directory(Dir)
 1169    ).
 1170prepare_pack_dir(Dir, _) :-
 1171    make_directory(Dir).

 empty_directory(+Directory) is semidet

True if Directory is empty (holds no files or sub-directories).

 1177empty_directory(Dir) :-
 1178    \+ ( directory_files(Dir, Entries),
 1179         member(Entry, Entries),
 1180         \+ special(Entry)
 1181       ).
 1182
 1183special(.).
 1184special(..).

 pack_install_from_url(+Scheme, +URL, +PackDir, +Pack, +Options)

Install a package from a remote source. For git repositories, we simply clone. Archives are downloaded. We currently use the built-in HTTP client. For complete coverage, we should consider using an external (e.g., curl) if available.

 1194pack_install_from_url(_, URL, PackTopDir, Pack, Options) :-
 1195    option(git(true), Options),
 1196    !,
 1197    directory_file_path(PackTopDir, Pack, PackDir),
 1198    prepare_pack_dir(PackDir, Options),
 1199    run_process(path(git), [clone, URL, PackDir], []),
 1200    pack_git_info(PackDir, Hash, Info),
 1201    pack_inquiry(URL, git(Hash), Info, Options),
 1202    show_info(Pack, Info, Options),
 1203    confirm(git_post_install(PackDir, Pack), yes, Options),
 1204    pack_post_install(Pack, PackDir, Options).
 1205pack_install_from_url(Scheme, URL, PackTopDir, Pack, Options) :-
 1206    download_scheme(Scheme),
 1207    directory_file_path(PackTopDir, Pack, PackDir),
 1208    prepare_pack_dir(PackDir, Options),
 1209    pack_download_dir(PackTopDir, DownLoadDir),
 1210    download_file(URL, Pack, DownloadBase, Options),
 1211    directory_file_path(DownLoadDir, DownloadBase, DownloadFile),
 1212    (   option(insecure(true), Options, false)
 1213    ->  TLSOptions = [cert_verify_hook(ssl_verify)]
 1214    ;   TLSOptions = []
 1215    ),
 1216    setup_call_cleanup(
 1217        http_open(URL, In, TLSOptions),
 1218        setup_call_cleanup(
 1219            open(DownloadFile, write, Out, [type(binary)]),
 1220            copy_stream_data(In, Out),
 1221            close(Out)),
 1222        close(In)),
 1223    pack_archive_info(DownloadFile, Pack, Info, _),
 1224    download_file_sanity_check(DownloadFile, Pack, Info),
 1225    pack_inquiry(URL, DownloadFile, Info, Options),
 1226    show_info(Pack, Info, Options),
 1227    confirm(install_downloaded(DownloadFile), yes, Options),
 1228    pack_install_from_local(DownloadFile, PackTopDir, Pack, Options).

 download_file(+URL, +Pack, -File, +Options) is det

 1232download_file(URL, Pack, File, Options) :-
 1233    option(version(Version), Options),
 1234    !,
 1235    atom_version(VersionA, Version),
 1236    file_name_extension(_, Ext, URL),
 1237    format(atom(File), '~w-~w.~w', [Pack, VersionA, Ext]).
 1238download_file(URL, Pack, File, _) :-
 1239    file_base_name(URL,Basename),
 1240    no_int_file_name_extension(Tag,Ext,Basename),
 1241    tag_version(Tag,Version),
 1242    !,
 1243    atom_version(VersionA,Version),
 1244    format(atom(File0), '~w-~w', [Pack, VersionA]),
 1245    file_name_extension(File0, Ext, File).
 1246download_file(URL, _, File, _) :-
 1247    file_base_name(URL, File).

 pack_url_file(+URL, -File) is det

True if File is a unique id for the referenced pack and version. Normally, that is simply the base name, but GitHub archives destroy this picture. Needed by the pack manager.

 1255pack_url_file(URL, FileID) :-
 1256    github_release_url(URL, Pack, Version),
 1257    !,
 1258    download_file(URL, Pack, FileID, [version(Version)]).
 1259pack_url_file(URL, FileID) :-
 1260    file_base_name(URL, FileID).
 1261
 1262
 1263:- public ssl_verify/5. 1264
 1265%   ssl_verify(+SSL, +ProblemCert, +AllCerts, +FirstCert, +Error)
 1266%
 1267%   Currently we accept  all  certificates.   We  organise  our  own
 1268%   security using SHA1 signatures, so  we   do  not  care about the
 1269%   source of the data.
 1270
 1271ssl_verify(_SSL,
 1272           _ProblemCertificate, _AllCertificates, _FirstCertificate,
 1273           _Error).
 1274
 1275pack_download_dir(PackTopDir, DownLoadDir) :-
 1276    directory_file_path(PackTopDir, 'Downloads', DownLoadDir),
 1277    (   exists_directory(DownLoadDir)
 1278    ->  true
 1279    ;   make_directory(DownLoadDir)
 1280    ),
 1281    (   access_file(DownLoadDir, write)
 1282    ->  true
 1283    ;   permission_error(write, directory, DownLoadDir)
 1284    ).

 download_url(+URL) is det

True if URL looks like a URL we can download from.

 1290download_url(URL) :-
 1291    atom(URL),
 1292    uri_components(URL, Components),
 1293    uri_data(scheme, Components, Scheme),
 1294    download_scheme(Scheme).
 1295
 1296download_scheme(http).
 1297download_scheme(https) :-
 1298    catch(use_module(library(http/http_ssl_plugin)),
 1299          E, (print_message(warning, E), fail)).

 pack_post_install(+Pack, +PackDir, +Options) is det

Process post installation work. Steps:

• Create foreign resources
• Register directory as autoload library
• Attach the package

 1309pack_post_install(Pack, PackDir, Options) :-
 1310    post_install_foreign(Pack, PackDir, Options),
 1311    post_install_autoload(PackDir, Options),
 1312    attach_packs(PackDir, [duplicate(warning)]).

 pack_rebuild(+Pack) is det

Rebuild possible foreign components of Pack.

 1318pack_rebuild(Pack) :-
 1319    current_pack(Pack, PackDir),
 1320    !,
 1321    post_install_foreign(Pack, PackDir, [rebuild(true)]).
 1322pack_rebuild(Pack) :-
 1323    unattached_pack(Pack, PackDir),
 1324    !,
 1325    post_install_foreign(Pack, PackDir, [rebuild(true)]).
 1326pack_rebuild(Pack) :-
 1327    existence_error(pack, Pack).
 1328
 1329unattached_pack(Pack, BaseDir) :-
 1330    directory_file_path(Pack, 'pack.pl', PackFile),
 1331    absolute_file_name(pack(PackFile), PackPath,
 1332                       [ access(read),
 1333                         file_errors(fail)
 1334                       ]),
 1335    file_directory_name(PackPath, BaseDir).

 pack_rebuild is det

Rebuild foreign components of all packages.

 1341pack_rebuild :-
 1342    forall(current_pack(Pack),
 1343           ( print_message(informational, pack(rebuild(Pack))),
 1344             pack_rebuild(Pack)
 1345           )).

 post_install_foreign(+Pack, +PackDir, +Options) is det

Install foreign parts of the package.

 1352post_install_foreign(Pack, PackDir, Options) :-
 1353    is_foreign_pack(PackDir, _),
 1354    !,
 1355    (   pack_info_term(PackDir, pack_version(Version))
 1356    ->  true
 1357    ;   Version = 1
 1358    ),
 1359    option(rebuild(Rebuild), Options, if_absent),
 1360    (   Rebuild == if_absent,
 1361        foreign_present(PackDir)
 1362    ->  print_message(informational, pack(kept_foreign(Pack)))
 1363    ;   BuildSteps0 = [[dependencies], [configure], build, [test], install],
 1364        (   Rebuild == true
 1365        ->  BuildSteps1 = [distclean|BuildSteps0]
 1366        ;   BuildSteps1 = BuildSteps0
 1367        ),
 1368        (   option(test(false), Options)
 1369        ->  delete(BuildSteps1, [test], BuildSteps)
 1370        ;   BuildSteps = BuildSteps1
 1371        ),
 1372        build_steps(BuildSteps, PackDir, [pack_version(Version)|Options])
 1373    ).
 1374post_install_foreign(_, _, _).

 foreign_present(+PackDir) is semidet

True if we find one or more modules in the pack lib directory for the current architecture. Does not check that these can be loaded, nor whether all required modules are present.

 1383foreign_present(PackDir) :-
 1384    current_prolog_flag(arch, Arch),
 1385    atomic_list_concat([PackDir, '/lib'], ForeignBaseDir),
 1386    exists_directory(ForeignBaseDir),
 1387    !,
 1388    atomic_list_concat([PackDir, '/lib/', Arch], ForeignDir),
 1389    exists_directory(ForeignDir),
 1390    current_prolog_flag(shared_object_extension, Ext),
 1391    atomic_list_concat([ForeignDir, '/*.', Ext], Pattern),
 1392    expand_file_name(Pattern, Files),
 1393    Files \== [].

 is_foreign_pack(+PackDir, -Type) is nondet

True when PackDir contains files that indicate the need for a specific class of build tools indicated by Type.

 1400is_foreign_pack(PackDir, Type) :-
 1401    foreign_file(File, Type),
 1402    directory_file_path(PackDir, File, Path),
 1403    exists_file(Path).
 1404
 1405foreign_file('CMakeLists.txt', cmake).
 1406foreign_file('configure',      configure).
 1407foreign_file('configure.in',   autoconf).
 1408foreign_file('configure.ac',   autoconf).
 1409foreign_file('Makefile.am',    automake).
 1410foreign_file('Makefile',       make).
 1411foreign_file('makefile',       make).
 1412foreign_file('conanfile.txt',  conan).
 1413foreign_file('conanfile.py',   conan).
 1414
 1415
 1416                 /*******************************
 1417                 *           AUTOLOAD           *
 1418                 *******************************/

 post_install_autoload(+PackDir, +Options)

Create an autoload index if the package demands such.

 1424post_install_autoload(PackDir, Options) :-
 1425    option(autoload(true), Options, true),
 1426    pack_info_term(PackDir, autoload(true)),
 1427    !,
 1428    directory_file_path(PackDir, prolog, PrologLibDir),
 1429    make_library_index(PrologLibDir).
 1430post_install_autoload(_, _).
 1431
 1432
 1433                 /*******************************
 1434                 *            UPGRADE           *
 1435                 *******************************/

 pack_upgrade(+Pack) is semidet

Try to upgrade the package Pack.

To be done

- Update dependencies when updating a pack from git?

 1443pack_upgrade(Pack) :-
 1444    pack_info(Pack, _, directory(Dir)),
 1445    directory_file_path(Dir, '.git', GitDir),
 1446    exists_directory(GitDir),
 1447    !,
 1448    print_message(informational, pack(git_fetch(Dir))),
 1449    git([fetch], [ directory(Dir) ]),
 1450    git_describe(V0, [ directory(Dir) ]),
 1451    git_describe(V1, [ directory(Dir), commit('origin/master') ]),
 1452    (   V0 == V1
 1453    ->  print_message(informational, pack(up_to_date(Pack)))
 1454    ;   confirm(upgrade(Pack, V0, V1), yes, []),
 1455        git([merge, 'origin/master'], [ directory(Dir) ]),
 1456        pack_rebuild(Pack)
 1457    ).
 1458pack_upgrade(Pack) :-
 1459    once(pack_info(Pack, _, version(VersionAtom))),
 1460    atom_version(VersionAtom, Version),
 1461    pack_info(Pack, _, download(URL)),
 1462    (   wildcard_pattern(URL)
 1463    ->  true
 1464    ;   github_url(URL, _User, _Repo)
 1465    ),
 1466    !,
 1467    available_download_versions(URL, [Latest-LatestURL|_Versions]),
 1468    (   Latest @> Version
 1469    ->  confirm(upgrade(Pack, Version, Latest), yes, []),
 1470        pack_install(Pack,
 1471                     [ url(LatestURL),
 1472                       upgrade(true),
 1473                       pack(Pack)
 1474                     ])
 1475    ;   print_message(informational, pack(up_to_date(Pack)))
 1476    ).
 1477pack_upgrade(Pack) :-
 1478    print_message(warning, pack(no_upgrade_info(Pack))).
 1479
 1480
 1481                 /*******************************
 1482                 *            REMOVE            *
 1483                 *******************************/

 pack_remove(+Name) is det

Remove the indicated package.

 1489pack_remove(Pack) :-
 1490    update_dependency_db,
 1491    (   setof(Dep, pack_depends_on(Dep, Pack), Deps)
 1492    ->  confirm_remove(Pack, Deps, Delete),
 1493        forall(member(P, Delete), pack_remove_forced(P))
 1494    ;   pack_remove_forced(Pack)
 1495    ).
 1496
 1497pack_remove_forced(Pack) :-
 1498    catch('$pack_detach'(Pack, BaseDir),
 1499          error(existence_error(pack, Pack), _),
 1500          fail),
 1501    !,
 1502    print_message(informational, pack(remove(BaseDir))),
 1503    delete_directory_and_contents(BaseDir).
 1504pack_remove_forced(Pack) :-
 1505    unattached_pack(Pack, BaseDir),
 1506    !,
 1507    delete_directory_and_contents(BaseDir).
 1508pack_remove_forced(Pack) :-
 1509    print_message(informational, error(existence_error(pack, Pack),_)).
 1510
 1511confirm_remove(Pack, Deps, Delete) :-
 1512    print_message(warning, pack(depends(Pack, Deps))),
 1513    menu(pack(resolve_remove),
 1514         [ [Pack]      = remove_only(Pack),
 1515           [Pack|Deps] = remove_deps(Pack, Deps),
 1516           []          = cancel
 1517         ], [], Delete, []),
 1518    Delete \== [].
 1519
 1520
 1521                 /*******************************
 1522                 *           PROPERTIES         *
 1523                 *******************************/

 pack_property(?Pack, ?Property) is nondet

True when Property is a property of an installed Pack. This interface is intended for programs that wish to interact with the package manager. Defined properties are:

directory(Directory)

Directory into which the package is installed

version(Version)

Installed version

title(Title)

Full title of the package

author(Author)

Registered author

download(URL)

Official download URL

readme(File)

Package README file (if present)

todo(File)

Package TODO file (if present)

 1546pack_property(Pack, Property) :-
 1547    findall(Pack-Property, pack_property_(Pack, Property), List),
 1548    member(Pack-Property, List).            % make det if applicable
 1549
 1550pack_property_(Pack, Property) :-
 1551    pack_info(Pack, _, Property).
 1552pack_property_(Pack, Property) :-
 1553    \+ \+ info_file(Property, _),
 1554    '$pack':pack(Pack, BaseDir),
 1555    access_file(BaseDir, read),
 1556    directory_files(BaseDir, Files),
 1557    member(File, Files),
 1558    info_file(Property, Pattern),
 1559    downcase_atom(File, Pattern),
 1560    directory_file_path(BaseDir, File, InfoFile),
 1561    arg(1, Property, InfoFile).
 1562
 1563info_file(readme(_), 'readme.txt').
 1564info_file(readme(_), 'readme').
 1565info_file(todo(_),   'todo.txt').
 1566info_file(todo(_),   'todo').
 1567
 1568
 1569                 /*******************************
 1570                 *             GIT              *
 1571                 *******************************/

 git_url(+URL, -Pack) is semidet

True if URL describes a git url for Pack

 1577git_url(URL, Pack) :-
 1578    uri_components(URL, Components),
 1579    uri_data(scheme, Components, Scheme),
 1580    nonvar(Scheme),                         % must be full URL
 1581    uri_data(path, Components, Path),
 1582    (   Scheme == git
 1583    ->  true
 1584    ;   git_download_scheme(Scheme),
 1585        file_name_extension(_, git, Path)
 1586    ;   git_download_scheme(Scheme),
 1587        catch(git_ls_remote(URL, _, [refs(['HEAD']), error(_)]), _, fail)
 1588    ->  true
 1589    ),
 1590    file_base_name(Path, PackExt),
 1591    (   file_name_extension(Pack, git, PackExt)
 1592    ->  true
 1593    ;   Pack = PackExt
 1594    ),
 1595    (   safe_pack_name(Pack)
 1596    ->  true
 1597    ;   domain_error(pack_name, Pack)
 1598    ).
 1599
 1600git_download_scheme(http).
 1601git_download_scheme(https).

 safe_pack_name(+Name:atom) is semidet

Verifies that Name is a valid pack name. This avoids trickery with pack file names to make shell commands behave unexpectly.

 1608safe_pack_name(Name) :-
 1609    atom_length(Name, Len),
 1610    Len >= 3,                               % demand at least three length
 1611    atom_codes(Name, Codes),
 1612    maplist(safe_pack_char, Codes),
 1613    !.
 1614
 1615safe_pack_char(C) :- between(0'a, 0'z, C), !.
 1616safe_pack_char(C) :- between(0'A, 0'Z, C), !.
 1617safe_pack_char(C) :- between(0'0, 0'9, C), !.
 1618safe_pack_char(0'_).
 1619
 1620
 1621                 /*******************************
 1622                 *         VERSION LOGIC        *
 1623                 *******************************/

 pack_version_file(-Pack, -Version, +File) is semidet

True if File is the name of a file or URL of a file that contains Pack at Version. File must have an extension and the basename must be of the form <pack>-<n>{.<m>}*. E.g., mypack-1.5.

 1632pack_version_file(Pack, Version, GitHubRelease) :-
 1633    atomic(GitHubRelease),
 1634    github_release_url(GitHubRelease, Pack, Version),
 1635    !.
 1636pack_version_file(Pack, Version, Path) :-
 1637    atomic(Path),
 1638    file_base_name(Path, File),
 1639    no_int_file_name_extension(Base, _Ext, File),
 1640    atom_codes(Base, Codes),
 1641    (   phrase(pack_version(Pack, Version), Codes),
 1642        safe_pack_name(Pack)
 1643    ->  true
 1644    ).
 1645
 1646no_int_file_name_extension(Base, Ext, File) :-
 1647    file_name_extension(Base0, Ext0, File),
 1648    \+ atom_number(Ext0, _),
 1649    !,
 1650    Base = Base0,
 1651    Ext = Ext0.
 1652no_int_file_name_extension(File, '', File).

 github_release_url(+URL, -Pack, -Version) is semidet

True when URL is the URL of a GitHub release. Such releases are accessible as

https:/github.com/<owner>/<pack>/archive/[vV]?<version>.zip'

 1665github_release_url(URL, Pack, Version) :-
 1666    uri_components(URL, Components),
 1667    uri_data(authority, Components, 'github.com'),
 1668    uri_data(scheme, Components, Scheme),
 1669    download_scheme(Scheme),
 1670    uri_data(path, Components, Path),
 1671    github_archive_path(Archive,Pack,File),
 1672    atomic_list_concat(Archive, /, Path),
 1673    file_name_extension(Tag, Ext, File),
 1674    github_archive_extension(Ext),
 1675    tag_version(Tag, Version),
 1676    !.
 1677
 1678github_archive_path(['',_User,Pack,archive,File],Pack,File).
 1679github_archive_path(['',_User,Pack,archive,refs,tags,File],Pack,File).
 1680
 1681github_archive_extension(tgz).
 1682github_archive_extension(zip).
 1683
 1684tag_version(Tag, Version) :-
 1685    version_tag_prefix(Prefix),
 1686    atom_concat(Prefix, AtomVersion, Tag),
 1687    atom_version(AtomVersion, Version).
 1688
 1689version_tag_prefix(v).
 1690version_tag_prefix('V').
 1691version_tag_prefix('').
 1692
 1693
 1694:- public
 1695    atom_version/2. 1696
 1697%   atom_version(?Atom, ?Version)
 1698%
 1699%   Translate   between   atomic   version   representation   and   term
 1700%   representation.  The  term  representation  is  a  list  of  version
 1701%   components as integers and can be compared using `@>`
 1702
 1703atom_version(Atom, version(Parts)) :-
 1704    (   atom(Atom)
 1705    ->  atom_codes(Atom, Codes),
 1706        phrase(version(Parts), Codes)
 1707    ;   atomic_list_concat(Parts, '.', Atom)
 1708    ).
 1709
 1710pack_version(Pack, version(Parts)) -->
 1711    string(Codes), "-",
 1712    version(Parts),
 1713    !,
 1714    { atom_codes(Pack, Codes)
 1715    }.
 1716
 1717version([_|T]) -->
 1718    "*",
 1719    !,
 1720    (   "."
 1721    ->  version(T)
 1722    ;   []
 1723    ).
 1724version([H|T]) -->
 1725    integer(H),
 1726    (   "."
 1727    ->  version(T)
 1728    ;   { T = [] }
 1729    ).
 1730
 1731                 /*******************************
 1732                 *       QUERY CENTRAL DB       *
 1733                 *******************************/