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, _Token, _Version).
  352
  353is_version(Version) :-
  354    split_string(Version, ".", "", Parts),
  355    maplist(number_string, _, Parts).
  356
  357is_dependency(Token, Token, *) :-
  358    atom(Token).
  359is_dependency(Term, Token, VersionCmp) :-
  360    Term =.. [Op,Token,Version],
  361    cmp(Op, _),
  362    is_version(Version),
  363    VersionCmp =.. [Op,Version].
  364
  365cmp(<,  @<).
  366cmp(=<, @=<).
  367cmp(==, ==).
  368cmp(>=, @>=).
  369cmp(>,  @>).
  370
  371
  372                 /*******************************
  373                 *            SEARCH            *
  374                 *******************************/

 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.

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

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

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

Search locally installed packs.

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

 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.

  662pack_install(Spec) :-
  663    pack_default_options(Spec, Pack, [], Options),
  664    pack_install(Pack, [pack(Pack)|Options]).
  665
  666pack_install(Specs, Options) :-
  667    is_list(Specs),
  668    !,
  669    maplist(pack_options(Options), Specs, Pairs),
  670    pack_install_dir(PackTopDir, Options),
  671    pack_install_set(Pairs, PackTopDir, Options).
  672pack_install(Spec, Options) :-
  673    pack_default_options(Spec, Pack, Options, DefOptions),
  674    (   option(already_installed(Installed), DefOptions)
  675    ->  print_message(informational, pack(already_installed(Installed)))
  676    ;   merge_options(Options, DefOptions, PackOptions),
  677        pack_install_dir(PackTopDir, PackOptions),
  678        pack_install_set([Pack-PackOptions], PackTopDir, Options)
  679    ).
  680
  681pack_options(Options, Spec, Pack-PackOptions) :-
  682    pack_default_options(Spec, Pack, Options, DefOptions),
  683    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.

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

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

  873pack_unpack_from_local(Source, PackTopDir, Name, PackDir, Options) :-
  874    exists_directory(Source),
  875    !,
  876    directory_file_path(PackTopDir, Name, PackDir),
  877    (   option(link(true), Options)
  878    ->  (   same_file(Source, PackDir)
  879        ->  true
  880        ;   remove_existing_pack(PackDir, Options),
  881            atom_concat(PackTopDir, '/', PackTopDirS),
  882            relative_file_name(Source, PackTopDirS, RelPath),
  883            link_file(RelPath, PackDir, symbolic),
  884            assertion(same_file(Source, PackDir))
  885        )
  886    ;   is_git_directory(Source)
  887    ->  remove_existing_pack(PackDir, Options),
  888        run_process(path(git), [clone, Source, PackDir], [])
  889    ;   prepare_pack_dir(PackDir, Options),
  890        copy_directory(Source, PackDir)
  891    ).
  892pack_unpack_from_local(Source, PackTopDir, Name, PackDir, Options) :-
  893    exists_file(Source),
  894    directory_file_path(PackTopDir, Name, PackDir),
  895    prepare_pack_dir(PackDir, Options),
  896    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.

  905:- if(exists_source(library(archive))).  906pack_unpack(Source, PackDir, Pack, Options) :-
  907    ensure_loaded_archive,
  908    pack_archive_info(Source, Pack, _Info, StripOptions),
  909    prepare_pack_dir(PackDir, Options),
  910    archive_extract(Source, PackDir,
  911                    [ exclude(['._*'])          % MacOS resource forks
  912                    | StripOptions
  913                    ]).
  914:- else.  915pack_unpack(_,_,_,_) :-
  916    existence_error(library, archive).
  917:- 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.

  925pack_install_local(M:Gen, Dir, Options) :-
  926    findall(Pack-PackOptions, call(M:Gen, Pack, PackOptions), Pairs),
  927    pack_install_set(Pairs, Dir, Options).
  928
  929pack_install_set(Pairs, Dir, Options) :-
  930    must_be(list(pair), Pairs),
  931    ensure_directory(Dir),
  932    partition(known_media, Pairs, Local, Remote),
  933    maplist(pack_options_to_versions, Local, LocalVersions),
  934    (   Remote == []
  935    ->  AllVersions = LocalVersions
  936    ;   pairs_keys(Remote, Packs),
  937        prolog_description(Properties),
  938        query_pack_server(versions(Packs, Properties), Result, Options),
  939        (   Result = true(RemoteVersions)
  940        ->  append(LocalVersions, RemoteVersions, AllVersions)
  941        ;   print_message(error, pack(query_failed(Result))),
  942            fail
  943        )
  944    ),
  945    local_packs(Dir, Existing),
  946    pack_resolve(Pairs, Existing, AllVersions, Plan, Options),
  947    !,                                      % for now, only first plan
  948    Options1 = [pack_directory(Dir)|Options],
  949    download_plan(Pairs, Plan, PlanB, Options1),
  950    register_downloads(PlanB, Options),
  951    maplist(update_automatic, PlanB),
  952    build_plan(PlanB, Built, Options1),
  953    publish_download(PlanB, Options),
  954    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.

  963known_media(_-Options) :-
  964    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.

  982pack_resolve(Pairs, Existing, Versions, Plan, Options) :-
  983    insert_existing(Existing, Versions, AllVersions, Options),
  984    phrase(select_version(Pairs, AllVersions,
  985                          [ plan(PlanA),           % access to plan
  986                            dependency_for([])     % dependencies
  987                          | Options
  988                          ]),
  989           PlanA),
  990    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.

 1001:- det(insert_existing/4). 1002insert_existing(Existing, [], Versions, _Options) =>
 1003    maplist(existing_to_versions, Existing, Versions).
 1004insert_existing(Existing, [Pack-Versions|T0], AllPackVersions, Options),
 1005    select(Installed, Existing, Existing2),
 1006    Installed.pack == Pack =>
 1007    can_upgrade(Installed, Versions, Installed2),
 1008    insert_existing_(Installed2, Versions, AllVersions, Options),
 1009    AllPackVersions = [Pack-AllVersions|T],
 1010    insert_existing(Existing2, T0, T, Options).
 1011insert_existing(Existing, [H|T0], AllVersions, Options) =>
 1012    AllVersions = [H|T],
 1013    insert_existing(Existing, T0, T, Options).
 1014
 1015existing_to_versions(Installed, Pack-[Version-[Installed]]) :-
 1016    Pack = Installed.pack,
 1017    Version = Installed.version.
 1018
 1019insert_existing_(Installed, Versions, AllVersions, Options) :-
 1020    option(upgrade(true), Options),
 1021    !,
 1022    insert_existing_(Installed, Versions, AllVersions).
 1023insert_existing_(Installed, Versions, AllVersions, _) :-
 1024    AllVersions = [Installed.version-[Installed]|Versions].
 1025
 1026insert_existing_(Installed, [H|T0], [H|T]) :-
 1027    H = V0-_Infos,
 1028    cmp_versions(>, V0, Installed.version),
 1029    !,
 1030    insert_existing_(Installed, T0, T).
 1031insert_existing_(Installed, [H0|T], [H|T]) :-
 1032    H0 = V0-Infos,
 1033    V0 == Installed.version,
 1034    !,
 1035    H = V0-[Installed|Infos].
 1036insert_existing_(Installed, Versions, All) :-
 1037    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.

 1044can_upgrade(Info, [Version-_|_], Info2) :-
 1045    cmp_versions(>, Version, Info.version),
 1046    !,
 1047    Info2 = Info.put(latest_version, Version).
 1048can_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.

 1056mark_installed([], _, []).
 1057mark_installed([Info|T], Existing, Plan) :-
 1058    (   member(Installed, Existing),
 1059        Installed.pack == Info.pack
 1060    ->  (   (   Installed.git == true
 1061            ->  Info.git == true,
 1062                Installed.hash == Info.hash
 1063            ;   Version = Info.get(version)
 1064            ->  Installed.version == Version
 1065            )
 1066        ->  Plan = [Info.put(keep, true)|PlanT]    % up-to-date
 1067        ;   Plan = [Info.put(upgrade, Installed)|PlanT] % needs upgrade
 1068        )
 1069    ;   Plan = [Info|PlanT]                        % new install
 1070    ),
 1071    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.

 1079select_version([], _, _) -->
 1080    [].
 1081select_version([Pack-PackOptions|More], Versions, Options) -->
 1082    { memberchk(Pack-PackVersions, Versions),
 1083      member(Version-Infos, PackVersions),
 1084      compatible_version(Pack, Version, PackOptions),
 1085      member(Info, Infos),
 1086      pack_options_compatible_with_info(Info, PackOptions),
 1087      pack_satisfies(Pack, Version, Info, Info2, PackOptions),
 1088      all_downloads(PackVersions, Downloads)
 1089    },
 1090    add_to_plan(Info2.put(_{version: Version, all_downloads:Downloads}),
 1091                Versions, Options),
 1092    select_version(More, Versions, Options).
 1093select_version([Pack-_PackOptions|_More], _Versions, _Options) -->
 1094    { existence_error(pack, Pack) }.               % or warn and continue?
 1095
 1096all_downloads(PackVersions, AllDownloads) :-
 1097    aggregate_all(sum(Downloads),
 1098                  ( member(_Version-Infos, PackVersions),
 1099                    member(Info, Infos),
 1100                    get_dict(downloads, Info, Downloads)
 1101                  ),
 1102                  AllDownloads).
 1103
 1104add_requirements([], _, _) -->
 1105    [].
 1106add_requirements([H|T], Versions, Options) -->
 1107    { is_prolog_token(H),
 1108      !,
 1109      prolog_satisfies(H)
 1110    },
 1111    add_requirements(T, Versions, Options).
 1112add_requirements([H|T], Versions, Options) -->
 1113    { member(Pack-PackVersions, Versions),
 1114      member(Version-Infos, PackVersions),
 1115      member(Info, Infos),
 1116      (   Provides = @(Pack,Version)
 1117      ;   member(Provides, Info.get(provides))
 1118      ),
 1119      satisfies_req(Provides, H),
 1120      all_downloads(PackVersions, Downloads)
 1121    },
 1122    add_to_plan(Info.put(_{version: Version, all_downloads:Downloads}),
 1123                Versions, Options),
 1124    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.

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

 info_conflicts(+Info1, +Info2) is semidet

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

 1185info_conflicts(Info, Planned) :-
 1186    info_conflicts_(Info, Planned),
 1187    !.
 1188info_conflicts(Info, Planned) :-
 1189    info_conflicts_(Planned, Info),
 1190    !.
 1191
 1192info_conflicts_(Info, Planned) :-
 1193    member(Conflict, Info.get(conflicts)),
 1194    \+ is_prolog_token(Conflict),
 1195    info_provides(Planned, Provides),
 1196    satisfies_req(Provides, Conflict),
 1197    !.
 1198
 1199info_provides(Info, Provides) :-
 1200    (   Provides = Info.pack@Info.version
 1201    ;   member(Provides, Info.get(provides))
 1202    ).

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

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

 1209pack_satisfies(_Pack, _Version, Info0, Info, Options) :-
 1210    option(commit('HEAD'), Options),
 1211    !,
 1212    Info0.get(git) == true,
 1213    Info = Info0.put(commit, 'HEAD').
 1214pack_satisfies(_Pack, _Version, Info, Info, Options) :-
 1215    option(commit(Commit), Options),
 1216    !,
 1217    Commit == Info.get(hash).
 1218pack_satisfies(Pack, Version, Info, Info, Options) :-
 1219    option(version(ReqVersion), Options),
 1220    !,
 1221    satisfies_version(Pack, Version, ReqVersion).
 1222pack_satisfies(_Pack, _Version, Info, Info, _Options).

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

 1226satisfies_version(Pack, Version, ReqVersion) :-
 1227    catch(require_version(pack(Pack), Version, ReqVersion),
 1228          error(version_error(pack(Pack), Version, ReqVersion),_),
 1229          fail).

 satisfies_req(+Provides, +Required) is semidet

Check a token requirements.

 1235satisfies_req(Token, Token) => true.
 1236satisfies_req(@(Token,_), Token) => true.
 1237satisfies_req(@(Token,PrvVersion), Req), cmp(Req, Token, Cmp, ReqVersion) =>
 1238	cmp_versions(Cmp, PrvVersion, ReqVersion).
 1239satisfies_req(_,_) => fail.
 1240
 1241cmp(Token  < Version, Token, <,	 Version).
 1242cmp(Token =< Version, Token, =<, Version).
 1243cmp(Token =  Version, Token, =,	 Version).
 1244cmp(Token == Version, Token, ==, Version).
 1245cmp(Token >= Version, Token, >=, Version).
 1246cmp(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).

 1259:- det(pack_options_to_versions/2). 1260pack_options_to_versions(Pack-PackOptions, Pack-Versions) :-
 1261    option(versions(Available), PackOptions), !,
 1262    maplist(version_url_info(Pack, PackOptions), Available, Versions).
 1263pack_options_to_versions(Pack-PackOptions, Pack-[Version-[Info]]) :-
 1264    option(url(URL), PackOptions),
 1265    findall(Prop, option_info_prop(PackOptions, Prop), Pairs),
 1266    dict_create(Info, #,
 1267                [ pack-Pack,
 1268                  url-URL
 1269                | Pairs
 1270                ]),
 1271    Version = Info.get(version, '0.0.0').
 1272
 1273version_url_info(Pack, PackOptions, Version-URL, Version-[Info]) :-
 1274    findall(Prop,
 1275            ( option_info_prop(PackOptions, Prop),
 1276              Prop \= version-_
 1277            ),
 1278            Pairs),
 1279    dict_create(Info, #,
 1280                [ pack-Pack,
 1281                  url-URL,
 1282                  version-Version
 1283                | Pairs
 1284                ]).
 1285
 1286option_info_prop(PackOptions, Prop-Value) :-
 1287    option_info(Prop),
 1288    Opt =.. [Prop,Value],
 1289    option(Opt, PackOptions).
 1290
 1291option_info(git).
 1292option_info(hash).
 1293option_info(version).
 1294option_info(branch).
 1295option_info(link).

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

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

 1302compatible_version(Pack, Version, PackOptions) :-
 1303    option(version(ReqVersion), PackOptions),
 1304    !,
 1305    satisfies_version(Pack, Version, ReqVersion).
 1306compatible_version(_, _, _).

 pack_options_compatible_with_info(+Info, +PackOptions) is semidet

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

 1313pack_options_compatible_with_info(Info, PackOptions) :-
 1314    findall(Prop, option_info_prop(PackOptions, Prop), Pairs),
 1315    dict_create(Dict, _, Pairs),
 1316    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.

 1326download_plan(_Targets, Plan, Plan, _Options) :-
 1327    exclude(installed, Plan, []),
 1328    !.
 1329download_plan(Targets, Plan0, Plan, Options) :-
 1330    confirm(download_plan(Plan0), yes, Options),
 1331    maplist(download_from_info(Options), Plan0, Plan1),
 1332    plan_unsatisfied_dependencies(Plan1, Deps),
 1333    (   Deps == []
 1334    ->  Plan = Plan1
 1335    ;   print_message(informational, pack(new_dependencies(Deps))),
 1336        prolog_description(Properties),
 1337        query_pack_server(versions(Deps, Properties), Result, []),
 1338        (   Result = true(Versions)
 1339        ->  pack_resolve(Targets, Plan1, Versions, Plan2, Options),
 1340            !,
 1341            download_plan(Targets, Plan2, Plan, Options)
 1342        ;   print_message(error, pack(query_failed(Result))),
 1343            fail
 1344        )
 1345    ).

 plan_unsatisfied_dependencies(+Plan, -Deps) is det

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

 1352plan_unsatisfied_dependencies(Plan, Deps) :-
 1353    phrase(plan_unsatisfied_dependencies(Plan, Plan), Deps).
 1354
 1355plan_unsatisfied_dependencies([], _) -->
 1356    [].
 1357plan_unsatisfied_dependencies([Info|Infos], Plan) -->
 1358    { Deps = Info.get(requires) },
 1359    plan_unsatisfied_requirements(Deps, Plan),
 1360    plan_unsatisfied_dependencies(Infos, Plan).
 1361
 1362plan_unsatisfied_requirements([], _) -->
 1363    [].
 1364plan_unsatisfied_requirements([H|T], Plan) -->
 1365    { is_prolog_token(H),           % Can this fail?
 1366      prolog_satisfies(H)
 1367    },
 1368    !,
 1369    plan_unsatisfied_requirements(T, Plan).
 1370plan_unsatisfied_requirements([H|T], Plan) -->
 1371    { member(Info, Plan),
 1372      (   (   Version = Info.get(version)
 1373          ->  Provides = @(Info.get(pack), Version)
 1374          ;   Provides = Info.get(pack)
 1375          )
 1376      ;   member(Provides, Info.get(provides))
 1377      ),
 1378      satisfies_req(Provides, H)
 1379    }, !,
 1380    plan_unsatisfied_requirements(T, Plan).
 1381plan_unsatisfied_requirements([H|T], Plan) -->
 1382    [H],
 1383    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.

 1392build_plan(Plan, Ordered, Options) :-
 1393    partition(needs_rebuild_from_info(Options), Plan, ToBuild, NoBuild),
 1394    maplist(attach_from_info(Options), NoBuild),
 1395    (   ToBuild == []
 1396    ->  Ordered = []
 1397    ;   order_builds(ToBuild, Ordered),
 1398        confirm(build_plan(Ordered), yes, Options),
 1399        maplist(exec_plan_rebuild_step(Options), Ordered)
 1400    ).
 1401
 1402needs_rebuild_from_info(Options, Info) :-
 1403    needs_rebuild(Info.installed, Options).

 needs_rebuild(+PackDir, +Options) is semidet

True when we need to rebuilt the pack in PackDir.

 1409needs_rebuild(PackDir, Options) :-
 1410    (   is_foreign_pack(PackDir, _),
 1411        \+ is_built(PackDir, Options)
 1412    ->  true
 1413    ;   is_autoload_pack(PackDir, Options),
 1414        post_install_autoload(PackDir, Options),
 1415        fail
 1416    ).

 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.

 1425is_built(PackDir, _Options) :-
 1426    current_prolog_flag(arch, Arch),
 1427    prolog_version_dotted(Version), % Major.Minor.Patch
 1428    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.

 1435order_builds(ToBuild, Ordered) :-
 1436    findall(Pack-Dep, dep_edge(ToBuild, Pack, Dep), Edges),
 1437    maplist(get_dict(pack), ToBuild, Packs),
 1438    vertices_edges_to_ugraph(Packs, Edges, Graph),
 1439    ugraph_layers(Graph, Layers),
 1440    append(Layers, PackNames),
 1441    maplist(pack_info_from_name(ToBuild), PackNames, Ordered).
 1442
 1443dep_edge(Infos, Pack, Dep) :-
 1444    member(Info, Infos),
 1445    Pack = Info.pack,
 1446    member(Dep, Info.get(dependency_for)),
 1447    (   member(DepInfo, Infos),
 1448        DepInfo.pack == Dep
 1449    ->  true
 1450    ).
 1451
 1452:- det(pack_info_from_name/3). 1453pack_info_from_name(Infos, Pack, Info) :-
 1454    member(Info, Infos),
 1455    Info.pack == Pack,
 1456    !.

 exec_plan_rebuild_step(+Options, +Info) is det

Execute the rebuild steps for the given Info.

 1462exec_plan_rebuild_step(Options, Info) :-
 1463    print_message(informational, pack(build(Info.pack, Info.installed))),
 1464    pack_post_install(Info.pack, Info.installed, Options),
 1465    attach_from_info(Options, Info).

 attach_from_info(+Options, +Info) is det

Make the package visible. Similar to pack_make_available/3.

 1471attach_from_info(_Options, Info) :-
 1472    Info.get(keep) == true,
 1473    !.
 1474attach_from_info(Options, Info) :-
 1475    (   option(pack_directory(_Parent), Options)
 1476    ->  pack_attach(Info.installed, [duplicate(replace)])
 1477    ;   pack_attach(Info.installed, [])
 1478    ).

 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.

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

 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.

 1555reload_info(_PackDir, Info, Info) :-
 1556    _ = Info.get(installed),	% we read it from the package
 1557    !.
 1558reload_info(PackDir, Info0, Info) :-
 1559    local_pack_info(PackDir, Info1),
 1560    Info = Info0.put(installed, PackDir)
 1561                .put(downloaded, Info0.url)
 1562                .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.

 1569work_done(_, _, _, _, Options),
 1570    option(silent(true), Options) =>
 1571    true.
 1572work_done(Targets, Plan, Plan, [], _Options) =>
 1573    convlist(can_upgrade_target(Plan), Targets, CanUpgrade),
 1574    (   CanUpgrade == []
 1575    ->  pairs_keys(Targets, Packs),
 1576        print_message(informational, pack(up_to_date(Packs)))
 1577    ;   print_message(informational, pack(installed_can_upgrade(CanUpgrade)))
 1578    ).
 1579work_done(_, _, _, _, _) =>
 1580    true.
 1581
 1582can_upgrade_target(Plan, Pack-_, Info) =>
 1583    member(Info, Plan),
 1584    Info.pack == Pack,
 1585    !,
 1586    _ = Info.get(latest_version).

 local_packs(+Dir, -Packs) is det

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

 1593local_packs(Dir, Packs) :-
 1594    findall(Pack, pack_in_subdir(Dir, Pack), Packs).
 1595
 1596pack_in_subdir(Dir, Info) :-
 1597    directory_member(Dir, PackDir,
 1598                     [ file_type(directory),
 1599                       hidden(false)
 1600                     ]),
 1601    local_pack_info(PackDir, Info).
 1602
 1603local_pack_info(PackDir,
 1604                #{ pack: Pack,
 1605                   version: Version,
 1606                   title: Title,
 1607                   hash: Hash,
 1608                   url: URL,
 1609                   git: IsGit,
 1610                   requires: Requires,
 1611                   provides: Provides,
 1612                   conflicts: Conflicts,
 1613                   installed: PackDir
 1614                 }) :-
 1615    directory_file_path(PackDir, 'pack.pl', MetaFile),
 1616    exists_file(MetaFile),
 1617    file_base_name(PackDir, DirName),
 1618    findall(Term, pack_dir_info(PackDir, _, Term), Info),
 1619    option(pack(Pack), Info, DirName),
 1620    option(title(Title), Info, '<no title>'),
 1621    option(version(Version), Info, '<no version>'),
 1622    option(download(URL), Info, '<no download url>'),
 1623    findall(Req, member(requires(Req), Info), Requires),
 1624    findall(Prv, member(provides(Prv), Info), Provides),
 1625    findall(Cfl, member(conflicts(Cfl), Info), Conflicts),
 1626    (   have_git,
 1627        is_git_directory(PackDir)
 1628    ->  git_hash(Hash, [directory(PackDir)]),
 1629        IsGit = true
 1630    ;   Hash = '-',
 1631        IsGit = false
 1632    ).
 1633
 1634
 1635		 /*******************************
 1636		 *        PROLOG VERSIONS	*
 1637		 *******************************/