1/*  Part of SWI-Prolog
    2
    3    Author:        Jan Wielemaker
    4    E-mail:        jan@swi-prolog.org
    5    WWW:           https://www.swi-prolog.org
    6    Copyright (c)  2012-2024, 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_remove/2,              % +Name, +Options
   51            pack_publish/2,             % +URL, +Options
   52            pack_property/2             % ?Name, ?Property
   53          ]).   54:- use_module(library(apply)).   55:- use_module(library(error)).   56:- use_module(library(option)).   57:- use_module(library(readutil)).   58:- use_module(library(lists)).   59:- use_module(library(filesex)).   60:- use_module(library(xpath)).   61:- use_module(library(settings)).   62:- use_module(library(uri)).   63:- use_module(library(dcg/basics)).   64:- use_module(library(dcg/high_order)).   65:- use_module(library(http/http_open)).   66:- use_module(library(http/json)).   67:- use_module(library(http/http_client), []).   68:- use_module(library(debug), [assertion/1]).   69:- use_module(library(pairs), [pairs_keys/2]).   70:- autoload(library(git)).   71:- autoload(library(sgml)).   72:- autoload(library(sha)).   73:- autoload(library(build/tools)).   74:- autoload(library(ansi_term), [ansi_format/3]).   75:- autoload(library(pprint), [print_term/2]).   76:- autoload(library(prolog_versions), [require_version/3, cmp_versions/3]).   77:- autoload(library(ugraphs), [vertices_edges_to_ugraph/3, ugraph_layers/2]).   78:- autoload(library(process), [process_which/2]).   79
   80:- meta_predicate
   81    pack_install_local(2, +, +).

swipl pack help

   96                 /*******************************
   97                 *          CONSTANTS           *
   98                 *******************************/
   99
  100:- setting(server, atom, 'https://www.swi-prolog.org/pack/',
  101           'Server to exchange pack information').  102
  103
  104		 /*******************************
  105		 *       LOCAL DECLARATIONS	*
  106		 *******************************/
  107
  108:- op(900, xfx, @).                     % Token@Version
  109
  110:- meta_predicate det_if(0,0).  111
  112                 /*******************************
  113                 *         PACKAGE INFO         *
  114                 *******************************/

 current_pack(?Pack) is nondet

 current_pack(?Pack, ?Dir) is nondet

True if Pack is a currently installed pack.

  121current_pack(Pack) :-
  122    current_pack(Pack, _).
  123
  124current_pack(Pack, Dir) :-
  125    '$pack':pack(Pack, Dir).

 pack_list_installed is det

List currently installed packages and report possible dependency issues.

  132pack_list_installed :-
  133    pack_list('', [installed(true)]),
  134    validate_dependencies.

 pack_info(+Pack)

Print more detailed information about Pack.

  140pack_info(Name) :-
  141    pack_info(info, Name).
  142
  143pack_info(Level, Name) :-
  144    must_be(atom, Name),
  145    findall(Info, pack_info(Name, Level, Info), Infos0),
  146    (   Infos0 == []
  147    ->  print_message(warning, pack(no_pack_installed(Name))),
  148        fail
  149    ;   true
  150    ),
  151    findall(Def,  pack_default(Level, Infos, Def), Defs),
  152    append(Infos0, Defs, Infos1),
  153    sort(Infos1, Infos),
  154    show_info(Name, Infos, [info(Level)]).
  155
  156
  157show_info(_Name, _Properties, Options) :-
  158    option(silent(true), Options),
  159    !.
  160show_info(_Name, _Properties, Options) :-
  161    option(show_info(false), Options),
  162    !.
  163show_info(Name, Properties, Options) :-
  164    option(info(list), Options),
  165    !,
  166    memberchk(title(Title), Properties),
  167    memberchk(version(Version), Properties),
  168    format('i ~w@~w ~28|- ~w~n', [Name, Version, Title]).
  169show_info(Name, Properties, _) :-
  170    !,
  171    print_property_value('Package'-'~w', [Name]),
  172    findall(Term, pack_level_info(info, Term, _, _), Terms),
  173    maplist(print_property(Properties), Terms).
  174
  175print_property(_, nl) :-
  176    !,
  177    format('~n').
  178print_property(Properties, Term) :-
  179    findall(Term, member(Term, Properties), Terms),
  180    Terms \== [],
  181    !,
  182    pack_level_info(_, Term, LabelFmt, _Def),
  183    (   LabelFmt = Label-FmtElem
  184    ->  true
  185    ;   Label = LabelFmt,
  186        FmtElem = '~w'
  187    ),
  188    multi_valued(Terms, FmtElem, FmtList, Values),
  189    atomic_list_concat(FmtList, ', ', Fmt),
  190    print_property_value(Label-Fmt, Values).
  191print_property(_, _).
  192
  193multi_valued([H], LabelFmt, [LabelFmt], Values) :-
  194    !,
  195    H =.. [_|Values].
  196multi_valued([H|T], LabelFmt, [LabelFmt|LT], Values) :-
  197    H =.. [_|VH],
  198    append(VH, MoreValues, Values),
  199    multi_valued(T, LabelFmt, LT, MoreValues).
  200
  201
  202pvalue_column(29).
  203print_property_value(Prop-Fmt, Values) :-
  204    !,
  205    pvalue_column(C),
  206    atomic_list_concat(['~w:~t~*|', Fmt, '~n'], Format),
  207    format(Format, [Prop,C|Values]).
  208
  209pack_info(Name, Level, Info) :-
  210    '$pack':pack(Name, BaseDir),
  211    pack_dir_info(BaseDir, Level, Info).
  212
  213pack_dir_info(BaseDir, Level, Info) :-
  214    (   Info = directory(BaseDir)
  215    ;   pack_info_term(BaseDir, Info)
  216    ),
  217    pack_level_info(Level, Info, _Format, _Default).
  218
  219:- public pack_level_info/4.                    % used by web-server
  220
  221pack_level_info(_,    title(_),         'Title',                   '<no title>').
  222pack_level_info(_,    version(_),       'Installed version',       '<unknown>').
  223pack_level_info(info, automatic(_),	'Automatic (dependency only)', -).
  224pack_level_info(info, directory(_),     'Installed in directory',  -).
  225pack_level_info(info, link(_),		'Installed as link to'-'~w', -).
  226pack_level_info(info, built(_,_),	'Built on'-'~w for SWI-Prolog ~w', -).
  227pack_level_info(info, author(_, _),     'Author'-'~w <~w>',        -).
  228pack_level_info(info, maintainer(_, _), 'Maintainer'-'~w <~w>',    -).
  229pack_level_info(info, packager(_, _),   'Packager'-'~w <~w>',      -).
  230pack_level_info(info, home(_),          'Home page',               -).
  231pack_level_info(info, download(_),      'Download URL',            -).
  232pack_level_info(_,    provides(_),      'Provides',                -).
  233pack_level_info(_,    requires(_),      'Requires',                -).
  234pack_level_info(_,    conflicts(_),     'Conflicts with',          -).
  235pack_level_info(_,    replaces(_),      'Replaces packages',       -).
  236pack_level_info(info, library(_),	'Provided libraries',      -).
  237
  238pack_default(Level, Infos, Def) :-
  239    pack_level_info(Level, ITerm, _Format, Def),
  240    Def \== (-),
  241    \+ memberchk(ITerm, Infos).

 pack_info_term(+PackDir, ?Info) is nondet

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

  247pack_info_term(BaseDir, Info) :-
  248    directory_file_path(BaseDir, 'pack.pl', InfoFile),
  249    catch(
  250        term_in_file(valid_term(pack_info_term), InfoFile, Info),
  251        error(existence_error(source_sink, InfoFile), _),
  252        ( print_message(error, pack(no_meta_data(BaseDir))),
  253          fail
  254        )).
  255pack_info_term(BaseDir, library(Lib)) :-
  256    atom_concat(BaseDir, '/prolog/', LibDir),
  257    atom_concat(LibDir, '*.pl', Pattern),
  258    expand_file_name(Pattern, Files),
  259    maplist(atom_concat(LibDir), Plain, Files),
  260    convlist(base_name, Plain, Libs),
  261    member(Lib, Libs).
  262pack_info_term(BaseDir, automatic(Boolean)) :-
  263    once(pack_status_dir(BaseDir, automatic(Boolean))).
  264pack_info_term(BaseDir, built(Arch, Prolog)) :-
  265    pack_status_dir(BaseDir, built(Arch, Prolog, _How)).
  266pack_info_term(BaseDir, link(Dest)) :-
  267    read_link(BaseDir, _, Dest).
  268
  269base_name(File, Base) :-
  270    file_name_extension(Base, pl, File).

 term_in_file(:Valid, +File, -Term) is nondet

True when Term appears in file and call(Valid, Term) is true.

  276:- meta_predicate
  277    term_in_file(1, +, -).  278
  279term_in_file(Valid, File, Term) :-
  280    exists_file(File),
  281    setup_call_cleanup(
  282        open(File, read, In, [encoding(utf8)]),
  283        term_in_stream(Valid, In, Term),
  284        close(In)).
  285
  286term_in_stream(Valid, In, Term) :-
  287    repeat,
  288        read_term(In, Term0, []),
  289        (   Term0 == end_of_file
  290        ->  !, fail
  291        ;   Term = Term0,
  292            call(Valid, Term0)
  293        ).
  294
  295:- meta_predicate
  296    valid_term(1,+).  297
  298valid_term(Type, Term) :-
  299    Term =.. [Name|Args],
  300    same_length(Args, Types),
  301    Decl =.. [Name|Types],
  302    (   call(Type, Decl)
  303    ->  maplist(valid_info_arg, Types, Args)
  304    ;   print_message(warning, pack(invalid_term(Type, Term))),
  305        fail
  306    ).
  307
  308valid_info_arg(Type, Arg) :-
  309    must_be(Type, Arg).

 pack_info_term(?Term) is nondet

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

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

 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
  • a: as i, but installed only as dependency
  • 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 known 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. Contacting the server can be avoided using the server(false) option.

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

  502join_status([], []).
  503join_status([ pack(Pack, i, Title, Version, URL),
  504              pack(Pack, p, Title, Version, _)
  505            | T0
  506            ],
  507            [ pack(Pack, Tag, Title, Version, URL)
  508            | T
  509            ]) :-
  510    !,
  511    (   pack_status(Pack, automatic(true))
  512    ->  Tag = a
  513    ;   Tag = i
  514    ),
  515    join_status(T0, T).
  516join_status([ pack(Pack, i, Title, VersionI, URLI),
  517              pack(Pack, p, _,     VersionS, URLS)
  518            | T0
  519            ],
  520            [ pack(Pack, Tag, Title, VersionI-VersionS, URLI-URLS)
  521            | T
  522            ]) :-
  523    !,
  524    version_sort_key(VersionI, VDI),
  525    version_sort_key(VersionS, VDS),
  526    (   VDI @< VDS
  527    ->  Tag = 'U'
  528    ;   Tag = 'A'
  529    ),
  530    join_status(T0, T).
  531join_status([ pack(Pack, i, Title, VersionI, URL)
  532            | T0
  533            ],
  534            [ pack(Pack, l, Title, VersionI, URL)
  535            | T
  536            ]) :-
  537    !,
  538    join_status(T0, T).
  539join_status([H|T0], [H|T]) :-
  540    join_status(T0, T).

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

Search locally installed packs.

  546local_search(Query, Packs) :-
  547    findall(Pack, matching_installed_pack(Query, Pack), Packs).
  548
  549matching_installed_pack(Query, pack(Pack, i, Title, Version, URL)) :-
  550    current_pack(Pack),
  551    findall(Term,
  552            ( pack_info(Pack, _, Term),
  553              search_info(Term)
  554            ), Info),
  555    (   sub_atom_icasechk(Pack, _, Query)
  556    ->  true
  557    ;   memberchk(title(Title), Info),
  558        sub_atom_icasechk(Title, _, Query)
  559    ),
  560    option(title(Title), Info, '<no title>'),
  561    option(version(Version), Info, '<no version>'),
  562    option(download(URL), Info, '<no download url>').
  563
  564search_info(title(_)).
  565search_info(version(_)).
  566search_info(download(_)).
  567
  568
  569                 /*******************************
  570                 *            INSTALL           *
  571                 *******************************/

 pack_install(+Spec:atom) is det

 pack_install(+SpecOrList, +Options) is det

Install one or more packs from SpecOrList. SpecOrList is a single specification or a list of specifications. A specification is one of

• A pack name. This queries the pack repository at https://www.swi-prolog.org
• Archive file name
• A http(s) URL of an archive file name. This URL may contain a star (*) for the version. In this case pack_install/1 asks for the directory content and selects the latest version.
• An https GIT URL
• 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). Installation using a symlink is normally used during development of a pack.

Processes the options below. Default options as would be used by pack_install/1 are used to complete the provided Options. Note that pack_install/2 can be used through the SWI-Prolog command line app pack as below. Most of the options of this predicate are available as command line options.

swipl pack install <name>

Options:

url(+URL)

Source for downloading the package

pack_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.

version(+Version)

Demand the pack to satisfy some version requirement. Version is as defined by require_version/3. For example '1.5' is the same as >=('1.5').

branch(+Branch)

When installing from a git repository, clone this branch.

commit(+Commit)

When installing from a git repository, checkout this commit. Commit is either a hash, a tag, a branch or 'HEAD'.

build_type(+Type)

When building using CMake, use -DCMAKE_BUILD_TYPE=Type. Default is the build type of Prolog or Release.

register(+Boolean)

If true (default), register packages as downloaded after performing the download. This contacts the server with the meta-data of each pack that was downloaded. The server will either register the location as a new version or increment the download count. The server stores the IP address of the client. Subsequent downloads of the same version from the same IP address are ignored.

server(+URL)

Pack server to contact. Default is the setting prolog_pack:server, by default set to https://www.swi-prolog.org/pack/

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.

  671pack_install(Spec) :-
  672    pack_default_options(Spec, Pack, [], Options),
  673    pack_install(Pack, [pack(Pack)|Options]).
  674
  675pack_install(Specs, Options) :-
  676    is_list(Specs),
  677    !,
  678    maplist(pack_options(Options), Specs, Pairs),
  679    pack_install_dir(PackTopDir, Options),
  680    pack_install_set(Pairs, PackTopDir, Options).
  681pack_install(Spec, Options) :-
  682    pack_default_options(Spec, Pack, Options, DefOptions),
  683    (   option(already_installed(Installed), DefOptions)
  684    ->  print_message(informational, pack(already_installed(Installed)))
  685    ;   merge_options(Options, DefOptions, PackOptions),
  686        pack_install_dir(PackTopDir, PackOptions),
  687        pack_install_set([Pack-PackOptions], PackTopDir, Options)
  688    ).
  689
  690pack_options(Options, Spec, Pack-PackOptions) :-
  691    pack_default_options(Spec, Pack, Options, DefOptions),
  692    merge_options(Options, DefOptions, PackOptions).

 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. Cases:

1. Already installed. We must pass that as pack_default_options/4 is called twice from pack_install/2.
2. Install from a URL due to a url(URL) option. Determine whether the URL is a GIT repository, get the version and pack from the URL.
3. Install a local archive file. Extract the pack and version from the archive name.
4. Install from a git URL. Determines the pack, sets git(true) and adds the URL as option.
5. Install from a directory. Get the info from the packs.pl file.
6. Install from '.'. Create a symlink to make the current dir accessible as a pack.
7. Install from a non-git URL Determine pack and version.
8. Pack name. Query the server to find candidate packs and select an adequate pack.

  718pack_default_options(_Spec, Pack, OptsIn, Options) :-   % (1)
  719    option(already_installed(pack(Pack,_Version)), OptsIn),
  720    !,
  721    Options = OptsIn.
  722pack_default_options(_Spec, Pack, OptsIn, Options) :-   % (2)
  723    option(url(URL), OptsIn),
  724    !,
  725    (   option(git(_), OptsIn)
  726    ->  Options = OptsIn
  727    ;   git_url(URL, Pack)
  728    ->  Options = [git(true)|OptsIn]
  729    ;   Options = OptsIn
  730    ),
  731    (   nonvar(Pack)
  732    ->  true
  733    ;   option(pack(Pack), Options)
  734    ->  true
  735    ;   pack_version_file(Pack, _Version, URL)
  736    ).
  737pack_default_options(Archive, Pack, OptsIn, Options) :- % (3)
  738    must_be(atom, Archive),
  739    \+ uri_is_global(Archive),
  740    expand_file_name(Archive, [File]),
  741    exists_file(File),
  742    !,
  743    (   pack_version_file(Pack, Version, File)
  744    ->  uri_file_name(FileURL, File),
  745        merge_options([url(FileURL), version(Version)], OptsIn, Options)
  746    ;   domain_error(pack_file_name, Archive)
  747    ).
  748pack_default_options(URL, Pack, OptsIn, Options) :-     % (4)
  749    git_url(URL, Pack),
  750    !,
  751    merge_options([git(true), url(URL)], OptsIn, Options).
  752pack_default_options(FileURL, Pack, _, Options) :-      % (5)
  753    uri_file_name(FileURL, Dir),
  754    exists_directory(Dir),
  755    pack_info_term(Dir, name(Pack)),
  756    !,
  757    (   pack_info_term(Dir, version(Version))
  758    ->  uri_file_name(DirURL, Dir),
  759        Options = [url(DirURL), version(Version)]
  760    ;   throw(error(existence_error(key, version, Dir),_))
  761    ).
  762pack_default_options('.', Pack, OptsIn, Options) :-     % (6)
  763    pack_info_term('.', name(Pack)),
  764    !,
  765    working_directory(Dir, Dir),
  766    (   pack_info_term(Dir, version(Version))
  767    ->  uri_file_name(DirURL, Dir),
  768        NewOptions = [url(DirURL), version(Version) | Options1],
  769        (   current_prolog_flag(windows, true)
  770        ->  Options1 = []
  771        ;   Options1 = [link(true), rebuild(make)]
  772        ),
  773        merge_options(NewOptions, OptsIn, Options)
  774    ;   throw(error(existence_error(key, version, Dir),_))
  775    ).
  776pack_default_options(URL, Pack, OptsIn, Options) :-      % (7)
  777    pack_version_file(Pack, Version, URL),
  778    download_url(URL),
  779    !,
  780    available_download_versions(URL, Available),
  781    Available = [URLVersion-LatestURL|_],
  782    NewOptions = [url(LatestURL)|VersionOptions],
  783    version_options(Version, URLVersion, Available, VersionOptions),
  784    merge_options(NewOptions, OptsIn, Options).
  785pack_default_options(Pack, Pack, Options, Options) :-    % (8)
  786    \+ uri_is_global(Pack).
  787
  788version_options(Version, Version, _, [version(Version)]) :- !.
  789version_options(Version, _, Available, [versions(Available)]) :-
  790    sub_atom(Version, _, _, _, *),
  791    !.
  792version_options(_, _, _, []).

 pack_install_dir(-PackDir, +Options) is det

Determine the directory below which to install new packs. This find or creates a writeable directory. Options:

• pack_directory(+PackDir) Use PackDir. PackDir is created if it does not exist.
• global(+Boolean) If true, find a writeable global directory based on the file search path common_app_data. If false, find a user-specific writeable directory based on user_app_data
• If neither of the above is given, use the search path pack.

If no writeable directory is found, generate possible location where this directory can be created and ask the user to create one of them.

  812pack_install_dir(PackDir, Options) :-
  813    option(pack_directory(PackDir), Options),
  814    ensure_directory(PackDir),
  815    !.
  816pack_install_dir(PackDir, Options) :-
  817    base_alias(Alias, Options),
  818    absolute_file_name(Alias, PackDir,
  819                       [ file_type(directory),
  820                         access(write),
  821                         file_errors(fail)
  822                       ]),
  823    !.
  824pack_install_dir(PackDir, Options) :-
  825    pack_create_install_dir(PackDir, Options).
  826
  827base_alias(Alias, Options) :-
  828    option(global(true), Options),
  829    !,
  830    Alias = common_app_data(pack).
  831base_alias(Alias, Options) :-
  832    option(global(false), Options),
  833    !,
  834    Alias = user_app_data(pack).
  835base_alias(Alias, _Options) :-
  836    Alias = pack('.').
  837
  838pack_create_install_dir(PackDir, Options) :-
  839    base_alias(Alias, Options),
  840    findall(Candidate = create_dir(Candidate),
  841            ( absolute_file_name(Alias, Candidate, [solutions(all)]),
  842              \+ exists_file(Candidate),
  843              \+ exists_directory(Candidate),
  844              file_directory_name(Candidate, Super),
  845              (   exists_directory(Super)
  846              ->  access_file(Super, write)
  847              ;   true
  848              )
  849            ),
  850            Candidates0),
  851    list_to_set(Candidates0, Candidates),   % keep order
  852    pack_create_install_dir(Candidates, PackDir, Options).
  853
  854pack_create_install_dir(Candidates, PackDir, Options) :-
  855    Candidates = [Default=_|_],
  856    !,
  857    append(Candidates, [cancel=cancel], Menu),
  858    menu(pack(create_pack_dir), Menu, Default, Selected, Options),
  859    Selected \== cancel,
  860    (   catch(make_directory_path(Selected), E,
  861              (print_message(warning, E), fail))
  862    ->  PackDir = Selected
  863    ;   delete(Candidates, PackDir=create_dir(PackDir), Remaining),
  864        pack_create_install_dir(Remaining, PackDir, Options)
  865    ).
  866pack_create_install_dir(_, _, _) :-
  867    print_message(error, pack(cannot_create_dir(pack(.)))),
  868    fail.

 pack_unpack_from_local(+Source, +PackTopDir, +Name, -PackDir, +Options)

Unpack a package from a local media. If Source is a directory, either copy or link the directory. Else, Source must be an archive file. Options:

link(+Boolean)

If the source is a directory, link or copy the directory?

upgrade(true)

If the target is already there, wipe it and make a clean install.

  882pack_unpack_from_local(Source0, PackTopDir, Name, PackDir, Options) :-
  883    exists_directory(Source0),
  884    remove_slash(Source0, Source),
  885    !,
  886    directory_file_path(PackTopDir, Name, PackDir),
  887    (   option(link(true), Options)
  888    ->  (   same_file(Source, PackDir)
  889        ->  true
  890        ;   remove_existing_pack(PackDir, Options),
  891            atom_concat(PackTopDir, '/', PackTopDirS),
  892            relative_file_name(Source, PackTopDirS, RelPath),
  893            link_file(RelPath, PackDir, symbolic),
  894            assertion(same_file(Source, PackDir))
  895        )
  896    ;   \+ option(git(false), Options),
  897        is_git_directory(Source)
  898    ->  remove_existing_pack(PackDir, Options),
  899        run_process(path(git), [clone, Source, PackDir], [])
  900    ;   prepare_pack_dir(PackDir, Options),
  901        copy_directory(Source, PackDir)
  902    ).
  903pack_unpack_from_local(Source, PackTopDir, Name, PackDir, Options) :-
  904    exists_file(Source),
  905    directory_file_path(PackTopDir, Name, PackDir),
  906    prepare_pack_dir(PackDir, Options),
  907    pack_unpack(Source, PackDir, Name, Options).

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

Unpack an archive to the given package dir.

To be done

- If library(archive) is not provided we could check for a suitable external program such as tar or unzip.

  916:- if(exists_source(library(archive))).  917pack_unpack(Source, PackDir, Pack, Options) :-
  918    ensure_loaded_archive,
  919    pack_archive_info(Source, Pack, _Info, StripOptions),
  920    prepare_pack_dir(PackDir, Options),
  921    archive_extract(Source, PackDir,
  922                    [ exclude(['._*'])          % MacOS resource forks
  923                    | StripOptions
  924                    ]).
  925:- else.  926pack_unpack(_,_,_,_) :-
  927    existence_error(library, archive).
  928:- 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.

  936pack_install_local(M:Gen, Dir, Options) :-
  937    findall(Pack-PackOptions, call(M:Gen, Pack, PackOptions), Pairs),
  938    pack_install_set(Pairs, Dir, Options).
  939
  940pack_install_set(Pairs, Dir, Options) :-
  941    must_be(list(pair), Pairs),
  942    ensure_directory(Dir),
  943    partition(known_media, Pairs, Local, Remote),
  944    maplist(pack_options_to_versions, Local, LocalVersions),
  945    (   Remote == []
  946    ->  AllVersions = LocalVersions
  947    ;   pairs_keys(Remote, Packs),
  948        prolog_description(Properties),
  949        query_pack_server(versions(Packs, Properties), Result, Options),
  950        (   Result = true(RemoteVersions)
  951        ->  append(LocalVersions, RemoteVersions, AllVersions)
  952        ;   print_message(error, pack(query_failed(Result))),
  953            fail
  954        )
  955    ),
  956    local_packs(Dir, Existing),
  957    pack_resolve(Pairs, Existing, AllVersions, Plan, Options),
  958    !,                                      % for now, only first plan
  959    Options1 = [pack_directory(Dir)|Options],
  960    download_plan(Pairs, Plan, PlanB, Options1),
  961    register_downloads(PlanB, Options),
  962    maplist(update_automatic, PlanB),
  963    build_plan(PlanB, Built, Options1),
  964    publish_download(PlanB, Options),
  965    work_done(Pairs, Plan, PlanB, Built, Options).

 known_media(+Pair) is semidet

True when the options specify installation from a known media. If that applies to all packs, there is no need to query the server. We first download and unpack the known media, then examine the requirements and, if necessary, go to the server to resolve these.

  974known_media(_-Options) :-
  975    option(url(_), Options).

 pack_resolve(+Pairs, +Existing, +Versions, -Plan, +Options) is det

Generate an installation plan. Pairs is a list of Pack-Options pairs that specifies the desired packages. Existing is a list of pack(Pack, i, Title, Version, URL) terms that represents the already installed packages. Versions is obtained from the server. See pack.pl from the web server for details. On success, this results in a Plan to satisfies the requirements. The plan is a list of packages to install with their location. The steps satisfy the partial ordering of dependencies, such that dependencies are installed before the dependents. Options:

upgrade(true)

When specified, we try to install the latest version of all the packages. Otherwise, we try to minimise the installation.

  993pack_resolve(Pairs, Existing, Versions, Plan, Options) :-
  994    insert_existing(Existing, Versions, AllVersions, Options),
  995    phrase(select_version(Pairs, AllVersions,
  996                          [ plan(PlanA),           % access to plan
  997                            dependency_for([])     % dependencies
  998                          | Options
  999                          ]),
 1000           PlanA),
 1001    mark_installed(PlanA, Existing, Plan).

 insert_existing(+Existing, +Available, -Candidates, +Options) is det

Combine the already existing packages with the ones reported as available by the server to a list of Candidates, where the candidate of each package is ordered according by preference. When upgrade(true) is specified, the existing is merged into the set of Available versions. Otherwise Existing is prepended to Available, so it is selected as first.

 1012:- det(insert_existing/4). 1013insert_existing(Existing, [], Versions, _Options) =>
 1014    maplist(existing_to_versions, Existing, Versions).
 1015insert_existing(Existing, [Pack-Versions|T0], AllPackVersions, Options),
 1016    select(Installed, Existing, Existing2),
 1017    Installed.pack == Pack =>
 1018    can_upgrade(Installed, Versions, Installed2),
 1019    insert_existing_(Installed2, Versions, AllVersions, Options),
 1020    AllPackVersions = [Pack-AllVersions|T],
 1021    insert_existing(Existing2, T0, T, Options).
 1022insert_existing(Existing, [H|T0], AllVersions, Options) =>
 1023    AllVersions = [H|T],
 1024    insert_existing(Existing, T0, T, Options).
 1025
 1026existing_to_versions(Installed, Pack-[Version-[Installed]]) :-
 1027    Pack = Installed.pack,
 1028    Version = Installed.version.
 1029
 1030insert_existing_(Installed, Versions, AllVersions, Options) :-
 1031    option(upgrade(true), Options),
 1032    !,
 1033    insert_existing_(Installed, Versions, AllVersions).
 1034insert_existing_(Installed, Versions, AllVersions, _) :-
 1035    AllVersions = [Installed.version-[Installed]|Versions].
 1036
 1037insert_existing_(Installed, [H|T0], [H|T]) :-
 1038    H = V0-_Infos,
 1039    cmp_versions(>, V0, Installed.version),
 1040    !,
 1041    insert_existing_(Installed, T0, T).
 1042insert_existing_(Installed, [H0|T], [H|T]) :-
 1043    H0 = V0-Infos,
 1044    V0 == Installed.version,
 1045    !,
 1046    H = V0-[Installed|Infos].
 1047insert_existing_(Installed, Versions, All) :-
 1048    All =  [Installed.version-[Installed]|Versions].

 can_upgrade(+Installed, +Versions, -Installed2) is det

Add a latest_version key to Installed if its version is older than the latest available version.

 1055can_upgrade(Info, [Version-_|_], Info2) :-
 1056    cmp_versions(>, Version, Info.version),
 1057    !,
 1058    Info2 = Info.put(latest_version, Version).
 1059can_upgrade(Info, _, Info).

 mark_installed(+PlanA, +Existing, -Plan) is det

Mark already up-to-date packs from the plan and add a key upgrade:true to elements of PlanA in Existing that are not the same.

 1067mark_installed([], _, []).
 1068mark_installed([Info|T], Existing, Plan) :-
 1069    (   member(Installed, Existing),
 1070        Installed.pack == Info.pack
 1071    ->  (   (   Installed.git == true
 1072            ->  Info.git == true,
 1073                Installed.hash == Info.hash
 1074            ;   Version = Info.get(version)
 1075            ->  Installed.version == Version
 1076            )
 1077        ->  Plan = [Info.put(keep, true)|PlanT]    % up-to-date
 1078        ;   Plan = [Info.put(upgrade, Installed)|PlanT] % needs upgrade
 1079        )
 1080    ;   Plan = [Info|PlanT]                        % new install
 1081    ),
 1082    mark_installed(T, Existing, PlanT).

 select_version(+PackAndOptions, +Available, +Options)// is nondet

True when the output is a list of pack info dicts that satisfy the installation requirements of PackAndOptions from the packs known to be Available.

 1090select_version([], _, _) -->
 1091    [].
 1092select_version([Pack-PackOptions|More], Versions, Options) -->
 1093    { memberchk(Pack-PackVersions, Versions),
 1094      member(Version-Infos, PackVersions),
 1095      compatible_version(Pack, Version, PackOptions),
 1096      member(Info, Infos),
 1097      pack_options_compatible_with_info(Info, PackOptions),
 1098      pack_satisfies(Pack, Version, Info, Info2, PackOptions),
 1099      all_downloads(PackVersions, Downloads)
 1100    },
 1101    add_to_plan(Info2.put(_{version: Version, all_downloads:Downloads}),
 1102                Versions, Options),
 1103    select_version(More, Versions, Options).
 1104select_version([Pack-_PackOptions|_More], _Versions, _Options) -->
 1105    { existence_error(pack, Pack) }.               % or warn and continue?
 1106
 1107all_downloads(PackVersions, AllDownloads) :-
 1108    aggregate_all(sum(Downloads),
 1109                  ( member(_Version-Infos, PackVersions),
 1110                    member(Info, Infos),
 1111                    get_dict(downloads, Info, Downloads)
 1112                  ),
 1113                  AllDownloads).
 1114
 1115add_requirements([], _, _) -->
 1116    [].
 1117add_requirements([H|T], Versions, Options) -->
 1118    { is_prolog_token(H),
 1119      !,
 1120      prolog_satisfies(H)
 1121    },
 1122    add_requirements(T, Versions, Options).
 1123add_requirements([H|T], Versions, Options) -->
 1124    { member(Pack-PackVersions, Versions),
 1125      member(Version-Infos, PackVersions),
 1126      member(Info, Infos),
 1127      (   Provides = @(Pack,Version)
 1128      ;   member(Provides, Info.get(provides))
 1129      ),
 1130      satisfies_req(Provides, H),
 1131      all_downloads(PackVersions, Downloads)
 1132    },
 1133    add_to_plan(Info.put(_{version: Version, all_downloads:Downloads}),
 1134                Versions, Options),
 1135    add_requirements(T, Versions, Options).

 add_to_plan(+Info, +Versions, +Options) is semidet

Add Info to the plan. If an Info about the same pack is already in the plan, but this is a different version of the pack, we must fail as we cannot install two different versions of a pack.

 1143add_to_plan(Info, _Versions, Options) -->
 1144    { option(plan(Plan), Options),
 1145      member_nonvar(Planned, Plan),
 1146      Planned.pack == Info.pack,
 1147      !,
 1148      same_version(Planned, Info)                  % same pack, different version
 1149    }.
 1150add_to_plan(Info, _Versions, _Options) -->
 1151    { member(Conflict, Info.get(conflicts)),
 1152      is_prolog_token(Conflict),
 1153      prolog_satisfies(Conflict),
 1154      !,
 1155      fail                                         % incompatible with this Prolog
 1156    }.
 1157add_to_plan(Info, _Versions, Options) -->
 1158    { option(plan(Plan), Options),
 1159      member_nonvar(Planned, Plan),
 1160      info_conflicts(Info, Planned),               % Conflicts with a planned pack
 1161      !,
 1162      fail
 1163    }.
 1164add_to_plan(Info, Versions, Options) -->
 1165    { select_option(dependency_for(Dep0), Options, Options1),
 1166      Options2 = [dependency_for([Info.pack|Dep0])|Options1],
 1167      (   Dep0 = [DepFor|_]
 1168      ->  add_dependency_for(DepFor, Info, Info1)
 1169      ;   Info1 = Info
 1170      )
 1171    },
 1172    [Info1],
 1173    add_requirements(Info.get(requires,[]), Versions, Options2).
 1174
 1175add_dependency_for(Pack, Info, Info) :-
 1176    Old = Info.get(dependency_for),
 1177    !,
 1178    b_set_dict(dependency_for, Info, [Pack|Old]).
 1179add_dependency_for(Pack, Info0, Info) :-
 1180    Info = Info0.put(dependency_for, [Pack]).
 1181
 1182same_version(Info, Info) :-
 1183    !.
 1184same_version(Planned, Info) :-
 1185    Hash = Planned.get(hash),
 1186    Hash \== (-),
 1187    !,
 1188    Hash == Info.get(hash).
 1189same_version(Planned, Info) :-
 1190    Planned.get(version) == Info.get(version).

 info_conflicts(+Info1, +Info2) is semidet

True if Info2 is in conflict with Info2. The relation is symetric.

 1196info_conflicts(Info, Planned) :-
 1197    info_conflicts_(Info, Planned),
 1198    !.
 1199info_conflicts(Info, Planned) :-
 1200    info_conflicts_(Planned, Info),
 1201    !.
 1202
 1203info_conflicts_(Info, Planned) :-
 1204    member(Conflict, Info.get(conflicts)),
 1205    \+ is_prolog_token(Conflict),
 1206    info_provides(Planned, Provides),
 1207    satisfies_req(Provides, Conflict),
 1208    !.
 1209
 1210info_provides(Info, Provides) :-
 1211    (   Provides = Info.pack@Info.version
 1212    ;   member(Provides, Info.get(provides))
 1213    ).

 pack_satisfies(+Pack, +Version, +Info0, -Info, +Options) is semidet

True if Pack@Version with Info satisfies the pack installation options provided by Options.

 1220pack_satisfies(_Pack, _Version, Info0, Info, Options) :-
 1221    option(commit('HEAD'), Options),
 1222    !,
 1223    Info0.get(git) == true,
 1224    Info = Info0.put(commit, 'HEAD').
 1225pack_satisfies(_Pack, _Version, Info, Info, Options) :-
 1226    option(commit(Commit), Options),
 1227    !,
 1228    Commit == Info.get(hash).
 1229pack_satisfies(Pack, Version, Info, Info, Options) :-
 1230    option(version(ReqVersion), Options),
 1231    !,
 1232    satisfies_version(Pack, Version, ReqVersion).
 1233pack_satisfies(_Pack, _Version, Info, Info, _Options).

 satisfies_version(+Pack, +PackVersion, +RequiredVersion) is semidet

 1237satisfies_version(Pack, Version, ReqVersion) :-
 1238    catch(require_version(pack(Pack), Version, ReqVersion),
 1239          error(version_error(pack(Pack), Version, ReqVersion),_),
 1240          fail).

 satisfies_req(+Provides, +Required) is semidet

Check a token requirements.

 1246satisfies_req(Token, Token) => true.
 1247satisfies_req(@(Token,_), Token) => true.
 1248satisfies_req(@(Token,PrvVersion), Req), cmp(Req, Token, Cmp, ReqVersion) =>
 1249	cmp_versions(Cmp, PrvVersion, ReqVersion).
 1250satisfies_req(_,_) => fail.
 1251
 1252cmp(Token  < Version, Token, <,	 Version).
 1253cmp(Token =< Version, Token, =<, Version).
 1254cmp(Token =  Version, Token, =,	 Version).
 1255cmp(Token == Version, Token, ==, Version).
 1256cmp(Token >= Version, Token, >=, Version).
 1257cmp(Token >  Version, Token, >,	 Version).

 pack_options_to_versions(+PackOptionsPair, -Versions) is det

Create an available package term from Pack and Options if it contains a url(URL) option. This allows installing packages that are not known to the server. In most cases, the URL will be a git URL or the URL to download an archive. It can also be a file:// url to install from a local archive.

The first clause deals with a wildcard URL. See pack_default_options/4, case (7).

 1270:- det(pack_options_to_versions/2). 1271pack_options_to_versions(Pack-PackOptions, Pack-Versions) :-
 1272    option(versions(Available), PackOptions), !,
 1273    maplist(version_url_info(Pack, PackOptions), Available, Versions).
 1274pack_options_to_versions(Pack-PackOptions, Pack-[Version-[Info]]) :-
 1275    option(url(URL), PackOptions),
 1276    findall(Prop, option_info_prop(PackOptions, Prop), Pairs),
 1277    dict_create(Info, #,
 1278                [ pack-Pack,
 1279                  url-URL
 1280                | Pairs
 1281                ]),
 1282    Version = Info.get(version, '0.0.0').
 1283
 1284version_url_info(Pack, PackOptions, Version-URL, Version-[Info]) :-
 1285    findall(Prop,
 1286            ( option_info_prop(PackOptions, Prop),
 1287              Prop \= version-_
 1288            ),
 1289            Pairs),
 1290    dict_create(Info, #,
 1291                [ pack-Pack,
 1292                  url-URL,
 1293                  version-Version
 1294                | Pairs
 1295                ]).
 1296
 1297option_info_prop(PackOptions, Prop-Value) :-
 1298    option_info(Prop),
 1299    Opt =.. [Prop,Value],
 1300    option(Opt, PackOptions).
 1301
 1302option_info(git).
 1303option_info(hash).
 1304option_info(version).
 1305option_info(branch).
 1306option_info(link).

 compatible_version(+Pack, +Version, +Options) is semidet

Fails if Options demands a version and Version is not compatible with Version.

 1313compatible_version(Pack, Version, PackOptions) :-
 1314    option(version(ReqVersion), PackOptions),
 1315    !,
 1316    satisfies_version(Pack, Version, ReqVersion).
 1317compatible_version(_, _, _).

 pack_options_compatible_with_info(+Info, +PackOptions) is semidet

Ignore information from the server that is incompatible with the request.

 1324pack_options_compatible_with_info(Info, PackOptions) :-
 1325    findall(Prop, option_info_prop(PackOptions, Prop), Pairs),
 1326    dict_create(Dict, _, Pairs),
 1327    Dict >:< Info.

 download_plan(+Targets, +Plan, +Options) is semidet

Download or update all packages from Plan. We need to do this as a first step because we may not have (up-to-date) dependency information about all packs. For example, a pack may be installed at the git HEAD revision that is not yet know to the server or it may be installed from a url that is not known at all at the server.

 1337download_plan(_Targets, Plan, Plan, _Options) :-
 1338    exclude(installed, Plan, []),
 1339    !.
 1340download_plan(Targets, Plan0, Plan, Options) :-
 1341    confirm(download_plan(Plan0), yes, Options),
 1342    maplist(download_from_info(Options), Plan0, Plan1),
 1343    plan_unsatisfied_dependencies(Plan1, Deps),
 1344    (   Deps == []
 1345    ->  Plan = Plan1
 1346    ;   print_message(informational, pack(new_dependencies(Deps))),
 1347        prolog_description(Properties),
 1348        query_pack_server(versions(Deps, Properties), Result, []),
 1349        (   Result = true(Versions)
 1350        ->  pack_resolve(Targets, Plan1, Versions, Plan2, Options),
 1351            !,
 1352            download_plan(Targets, Plan2, Plan, Options)
 1353        ;   print_message(error, pack(query_failed(Result))),
 1354            fail
 1355        )
 1356    ).

 plan_unsatisfied_dependencies(+Plan, -Deps) is det

True when Deps is a list of dependency tokens in Plan that is not satisfied.

 1363plan_unsatisfied_dependencies(Plan, Deps) :-
 1364    phrase(plan_unsatisfied_dependencies(Plan, Plan), Deps).
 1365
 1366plan_unsatisfied_dependencies([], _) -->
 1367    [].
 1368plan_unsatisfied_dependencies([Info|Infos], Plan) -->
 1369    { Deps = Info.get(requires) },
 1370    plan_unsatisfied_requirements(Deps, Plan),
 1371    plan_unsatisfied_dependencies(Infos, Plan).
 1372
 1373plan_unsatisfied_requirements([], _) -->
 1374    [].
 1375plan_unsatisfied_requirements([H|T], Plan) -->
 1376    { is_prolog_token(H),           % Can this fail?
 1377      prolog_satisfies(H)
 1378    },
 1379    !,
 1380    plan_unsatisfied_requirements(T, Plan).
 1381plan_unsatisfied_requirements([H|T], Plan) -->
 1382    { member(Info, Plan),
 1383      (   (   Version = Info.get(version)
 1384          ->  Provides = @(Info.get(pack), Version)
 1385          ;   Provides = Info.get(pack)
 1386          )
 1387      ;   member(Provides, Info.get(provides))
 1388      ),
 1389      satisfies_req(Provides, H)
 1390    }, !,
 1391    plan_unsatisfied_requirements(T, Plan).
 1392plan_unsatisfied_requirements([H|T], Plan) -->
 1393    [H],
 1394    plan_unsatisfied_requirements(T, Plan).

 build_plan(+Plan, -Built, +Options) is det

Run post installation steps. We build dependencies before their dependents, so we first do a topological sort on the packs based on the pack dependencies.

 1403build_plan(Plan, Ordered, Options) :-
 1404    partition(needs_rebuild_from_info(Options), Plan, ToBuild, NoBuild),
 1405    maplist(attach_from_info(Options), NoBuild),
 1406    (   ToBuild == []
 1407    ->  Ordered = []
 1408    ;   order_builds(ToBuild, Ordered),
 1409        confirm(build_plan(Ordered), yes, Options),
 1410        maplist(exec_plan_rebuild_step(Options), Ordered)
 1411    ).
 1412
 1413needs_rebuild_from_info(Options, Info) :-
 1414    needs_rebuild(Info.installed, Options).

 needs_rebuild(+PackDir, +Options) is semidet

True when we need to rebuilt the pack in PackDir.

 1420needs_rebuild(PackDir, Options) :-
 1421    (   is_foreign_pack(PackDir, _),
 1422        \+ is_built(PackDir, Options)
 1423    ->  true
 1424    ;   is_autoload_pack(PackDir, Options),
 1425        post_install_autoload(PackDir, Options),
 1426        fail
 1427    ).

 is_built(+PackDir, +Options) is semidet

True if the pack in PackDir has been built.

To be done

- We now verify it was built by the exact same version. That is normally an overkill.

 1436is_built(PackDir, _Options) :-
 1437    current_prolog_flag(arch, Arch),
 1438    prolog_version_dotted(Version), % Major.Minor.Patch
 1439    pack_status_dir(PackDir, built(Arch, Version, _)).

 order_builds(+ToBuild, -Ordered) is det

Order the build processes by building dependencies before the packages that rely on them as they may need them during the build.

 1446order_builds(ToBuild, Ordered) :-
 1447    findall(Pack-Dep, dep_edge(ToBuild, Pack, Dep), Edges),
 1448    maplist(get_dict(pack), ToBuild, Packs),
 1449    vertices_edges_to_ugraph(Packs, Edges, Graph),
 1450    ugraph_layers(Graph, Layers),
 1451    append(Layers, PackNames),
 1452    maplist(pack_info_from_name(ToBuild), PackNames, Ordered).
 1453
 1454dep_edge(Infos, Pack, Dep) :-
 1455    member(Info, Infos),
 1456    Pack = Info.pack,
 1457    member(Dep, Info.get(dependency_for)),
 1458    (   member(DepInfo, Infos),
 1459        DepInfo.pack == Dep
 1460    ->  true
 1461    ).
 1462
 1463:- det(pack_info_from_name/3). 1464pack_info_from_name(Infos, Pack, Info) :-
 1465    member(Info, Infos),
 1466    Info.pack == Pack,
 1467    !.

 exec_plan_rebuild_step(+Options, +Info) is det

Execute the rebuild steps for the given Info.

 1473exec_plan_rebuild_step(Options, Info) :-
 1474    print_message(informational, pack(build(Info.pack, Info.installed))),
 1475    pack_post_install(Info.pack, Info.installed, Options),
 1476    attach_from_info(Options, Info).

 attach_from_info(+Options, +Info) is det

Make the package visible. Similar to pack_make_available/3.

 1482attach_from_info(_Options, Info) :-
 1483    Info.get(keep) == true,
 1484    !.
 1485attach_from_info(Options, Info) :-
 1486    (   option(pack_directory(_Parent), Options)
 1487    ->  pack_attach(Info.installed, [duplicate(replace)])
 1488    ;   pack_attach(Info.installed, [])
 1489    ).

 download_from_info(+Options, +Info0, -Info) is det

Download a package guided by Info. Note that this does not run any scripts. This implies that dependencies do not matter and we can proceed in any order. This is important because we may use packages at their git HEAD, which implies that requirements may be different from what is in the Info terms.

 1499download_from_info(Options, Info0, Info), option(dryrun(true), Options) =>
 1500    print_term(Info0, [nl(true)]),
 1501    Info = Info0.
 1502download_from_info(_Options, Info0, Info), installed(Info0) =>
 1503    Info = Info0.
 1504download_from_info(_Options, Info0, Info),
 1505    _{upgrade:OldInfo, git:true} :< Info0,
 1506    is_git_directory(OldInfo.installed) =>
 1507    PackDir = OldInfo.installed,
 1508    git_checkout_version(PackDir, [commit(Info0.hash)]),
 1509    reload_info(PackDir, Info0, Info).
 1510download_from_info(Options, Info0, Info),
 1511    _{upgrade:OldInfo} :< Info0 =>
 1512    PackDir = OldInfo.installed,
 1513    detach_pack(OldInfo.pack, PackDir),
 1514    delete_directory_and_contents(PackDir),
 1515    del_dict(upgrade, Info0, _, Info1),
 1516    download_from_info(Options, Info1, Info).
 1517download_from_info(Options, Info0, Info),
 1518    _{url:URL, git:true} :< Info0, \+ have_git =>
 1519    git_archive_url(URL, Archive, Options),
 1520    download_from_info([git_url(URL)|Options],
 1521                       Info0.put(_{ url:Archive,
 1522                                    git:false,
 1523                                    git_url:URL
 1524                                  }),
 1525                       Info1),
 1526                                % restore the hash to register the download.
 1527    (   Info1.get(version) == Info0.get(version),
 1528        Hash = Info0.get(hash)
 1529    ->  Info = Info1.put(hash, Hash)
 1530    ;   Info = Info1
 1531    ).
 1532download_from_info(Options, Info0, Info),
 1533    _{url:URL} :< Info0 =>
 1534    select_option(pack_directory(Dir), Options, Options1),
 1535    select_option(version(_), Options1, Options2, _),
 1536    download_info_extra(Info0, InstallOptions, Options2),
 1537    pack_download_from_url(URL, Dir, Info0.pack,
 1538                           [ interactive(false),
 1539                             pack_dir(PackDir)
 1540                           | InstallOptions
 1541                           ]),
 1542    reload_info(PackDir, Info0, Info).
 1543
 1544download_info_extra(Info, [git(true),commit(Hash)|Options], Options) :-
 1545    Info.get(git) == true,
 1546    !,
 1547    Hash = Info.get(commit, 'HEAD').
 1548download_info_extra(Info, [link(true)|Options], Options) :-
 1549    Info.get(link) == true,
 1550    !.
 1551download_info_extra(_, Options, Options).
 1552
 1553installed(Info) :-
 1554    _ = Info.get(installed).
 1555
 1556detach_pack(Pack, PackDir) :-
 1557    (   current_pack(Pack, PackDir)
 1558    ->  '$pack_detach'(Pack, PackDir)
 1559    ;   true
 1560    ).

 reload_info(+PackDir, +Info0, -Info) is det

Update the requires and provides metadata. Info0 is what we got from the server, but the package may be different as we may have asked for the git HEAD or the package URL may not have been known by the server at all.

 1569reload_info(_PackDir, Info, Info) :-
 1570    _ = Info.get(installed),	% we read it from the package
 1571    !.
 1572reload_info(PackDir, Info0, Info) :-
 1573    local_pack_info(PackDir, Info1),
 1574    Info = Info0.put(installed, PackDir)
 1575                .put(downloaded, Info0.url)
 1576                .put(Info1).

 work_done(+Targets, +Plan, +PlanB, +Built, +Options) is det

Targets has successfully been installed and the packs Built have successfully ran their build scripts.

 1583work_done(_, _, _, _, Options),
 1584    option(silent(true), Options) =>
 1585    true.
 1586work_done(Targets, Plan, Plan, [], _Options) =>
 1587    convlist(can_upgrade_target(Plan), Targets, CanUpgrade),
 1588    (   CanUpgrade == []
 1589    ->  pairs_keys(Targets, Packs),
 1590        print_message(informational, pack(up_to_date(Packs)))
 1591    ;   print_message(informational, pack(installed_can_upgrade(CanUpgrade)))
 1592    ).
 1593work_done(_, _, _, _, _) =>
 1594    true.
 1595
 1596can_upgrade_target(Plan, Pack-_, Info) =>
 1597    member(Info, Plan),
 1598    Info.pack == Pack,
 1599    !,
 1600    _ = Info.get(latest_version).

 local_packs(+Dir, -Packs) is det

True when Packs is a list with information for all installed packages.

 1607local_packs(Dir, Packs) :-
 1608    findall(Pack, pack_in_subdir(Dir, Pack), Packs).
 1609
 1610pack_in_subdir(Dir, Info) :-
 1611    directory_member(Dir, PackDir,
 1612                     [ file_type(directory),
 1613                       hidden(false)
 1614                     ]),
 1615    local_pack_info(PackDir, Info).
 1616
 1617local_pack_info(PackDir,
 1618                #{ pack: Pack,
 1619                   version: Version,
 1620                   title: Title,
 1621                   hash: Hash,
 1622                   url: URL,
 1623                   git: IsGit,
 1624                   requires: Requires,
 1625                   provides: Provides,
 1626                   conflicts: Conflicts,
 1627                   installed: PackDir
 1628                 }) :-
 1629    directory_file_path(PackDir, 'pack.pl', MetaFile),
 1630    exists_file(MetaFile),
 1631    file_base_name(PackDir, DirName),
 1632    findall(Term, pack_dir_info(PackDir, _, Term), Info),
 1633    option(pack(Pack), Info, DirName),
 1634    option(title(Title), Info, '<no title>'),
 1635    option(version(Version), Info, '<no version>'),
 1636    option(download(URL), Info, '<no download url>'),
 1637    findall(Req, member(requires(Req), Info), Requires),
 1638    findall(Prv, member(provides(Prv), Info), Provides),
 1639    findall(Cfl, member(conflicts(Cfl), Info), Conflicts),
 1640    (   have_git,
 1641        is_git_directory(PackDir)
 1642    ->  git_hash(Hash, [directory(PackDir)]),
 1643        IsGit = true
 1644    ;   Hash = '-',
 1645        IsGit = false
 1646    ).
 1647
 1648
 1649		 /*******************************
 1650		 *        PROLOG VERSIONS	*
 1651		 *******************************/