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),
   70              [pairs_keys/2, map_list_to_pairs/3, pairs_values/2]).   71:- autoload(library(git)).   72:- autoload(library(sgml)).   73:- autoload(library(sha)).   74:- autoload(library(build/tools)).   75:- autoload(library(ansi_term), [ansi_format/3]).   76:- autoload(library(pprint), [print_term/2]).   77:- autoload(library(prolog_versions), [require_version/3, cmp_versions/3]).   78:- autoload(library(ugraphs), [vertices_edges_to_ugraph/3, ugraph_layers/2]).   79:- autoload(library(process), [process_which/2]).   80:- autoload(library(aggregate), [aggregate_all/3]).   81
   82:- meta_predicate
   83    pack_install_local(2, +, +).

swipl pack help

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

 current_pack(?Pack) is nondet

 current_pack(?Pack, ?Dir) is nondet

True if Pack is a currently installed pack.

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

 pack_list_installed is det

List currently installed packages and report possible dependency issues.

  134pack_list_installed :-
  135    pack_list('', [installed(true)]),
  136    validate_dependencies.

 pack_info(+Pack)

Print more detailed information about Pack.

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

 pack_info_term(+PackDir, ?Info) is nondet

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

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

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

 pack_info_term(?Term) is nondet

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

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

 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.

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

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

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

Search locally installed packs.

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

 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.

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

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

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

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

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

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

 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.

  983known_media(_-Options) :-
  984    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.

 1002pack_resolve(Pairs, Existing, Versions, Plan, Options) :-
 1003    insert_existing(Existing, Versions, AllVersions, Options),
 1004    phrase(select_version(Pairs, AllVersions,
 1005                          [ plan(PlanA),           % access to plan
 1006                            dependency_for([])     % dependencies
 1007                          | Options
 1008                          ]),
 1009           PlanA),
 1010    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.

 1021:- det(insert_existing/4). 1022insert_existing(Existing, [], Versions, _Options) =>
 1023    maplist(existing_to_versions, Existing, Versions).
 1024insert_existing(Existing, [Pack-Versions|T0], AllPackVersions, Options),
 1025    select(Installed, Existing, Existing2),
 1026    Installed.pack == Pack =>
 1027    can_upgrade(Installed, Versions, Installed2),
 1028    insert_existing_(Installed2, Versions, AllVersions, Options),
 1029    AllPackVersions = [Pack-AllVersions|T],
 1030    insert_existing(Existing2, T0, T, Options).
 1031insert_existing(Existing, [H|T0], AllVersions, Options) =>
 1032    AllVersions = [H|T],
 1033    insert_existing(Existing, T0, T, Options).
 1034
 1035existing_to_versions(Installed, Pack-[Version-[Installed]]) :-
 1036    Pack = Installed.pack,
 1037    Version = Installed.version.
 1038
 1039insert_existing_(Installed, Versions, AllVersions, Options) :-
 1040    option(upgrade(true), Options),
 1041    !,
 1042    insert_existing_(Installed, Versions, AllVersions).
 1043insert_existing_(Installed, Versions, AllVersions, _) :-
 1044    AllVersions = [Installed.version-[Installed]|Versions].
 1045
 1046insert_existing_(Installed, [H|T0], [H|T]) :-
 1047    H = V0-_Infos,
 1048    cmp_versions(>, V0, Installed.version),
 1049    !,
 1050    insert_existing_(Installed, T0, T).
 1051insert_existing_(Installed, [H0|T], [H|T]) :-
 1052    H0 = V0-Infos,
 1053    V0 == Installed.version,
 1054    !,
 1055    H = V0-[Installed|Infos].
 1056insert_existing_(Installed, Versions, All) :-
 1057    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.

 1064can_upgrade(Info, [Version-_|_], Info2) :-
 1065    cmp_versions(>, Version, Info.version),
 1066    !,
 1067    Info2 = Info.put(latest_version, Version).
 1068can_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.

 1076mark_installed([], _, []).
 1077mark_installed([Info|T], Existing, Plan) :-
 1078    (   member(Installed, Existing),
 1079        Installed.pack == Info.pack
 1080    ->  (   (   Installed.git == true
 1081            ->  Info.git == true,
 1082                Installed.hash == Info.hash
 1083            ;   Version = Info.get(version)
 1084            ->  Installed.version == Version
 1085            )
 1086        ->  Plan = [Info.put(keep, true)|PlanT]    % up-to-date
 1087        ;   Plan = [Info.put(upgrade, Installed)|PlanT] % needs upgrade
 1088        )
 1089    ;   Plan = [Info|PlanT]                        % new install
 1090    ),
 1091    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.

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

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

 info_conflicts(+Info1, +Info2) is semidet

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

 1205info_conflicts(Info, Planned) :-
 1206    info_conflicts_(Info, Planned),
 1207    !.
 1208info_conflicts(Info, Planned) :-
 1209    info_conflicts_(Planned, Info),
 1210    !.
 1211
 1212info_conflicts_(Info, Planned) :-
 1213    member(Conflict, Info.get(conflicts)),
 1214    \+ is_prolog_token(Conflict),
 1215    info_provides(Planned, Provides),
 1216    satisfies_req(Provides, Conflict),
 1217    !.
 1218
 1219info_provides(Info, Provides) :-
 1220    (   Provides = Info.pack@Info.version
 1221    ;   member(Provides, Info.get(provides))
 1222    ).

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

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

 1229pack_satisfies(_Pack, _Version, Info0, Info, Options) :-
 1230    option(commit('HEAD'), Options),
 1231    !,
 1232    Info0.get(git) == true,
 1233    Info = Info0.put(commit, 'HEAD').
 1234pack_satisfies(_Pack, _Version, Info, Info, Options) :-
 1235    option(commit(Commit), Options),
 1236    !,
 1237    Commit == Info.get(hash).
 1238pack_satisfies(Pack, Version, Info, Info, Options) :-
 1239    option(version(ReqVersion), Options),
 1240    !,
 1241    satisfies_version(Pack, Version, ReqVersion).
 1242pack_satisfies(_Pack, _Version, Info, Info, _Options).

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

 1246satisfies_version(Pack, Version, ReqVersion) :-
 1247    catch(require_version(pack(Pack), Version, ReqVersion),
 1248          error(version_error(pack(Pack), Version, ReqVersion),_),
 1249          fail).

 satisfies_req(+Provides, +Required) is semidet

Check a token requirements.

 1255satisfies_req(Token, Token) => true.
 1256satisfies_req(@(Token,_), Token) => true.
 1257satisfies_req(@(Token,PrvVersion), Req), cmp(Req, Token, Cmp, ReqVersion) =>
 1258	cmp_versions(Cmp, PrvVersion, ReqVersion).
 1259satisfies_req(_,_) => fail.
 1260
 1261cmp(Token  < Version, Token, <,	 Version).
 1262cmp(Token =< Version, Token, =<, Version).
 1263cmp(Token =  Version, Token, =,	 Version).
 1264cmp(Token == Version, Token, ==, Version).
 1265cmp(Token >= Version, Token, >=, Version).
 1266cmp(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).

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

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

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

 1322compatible_version(Pack, Version, PackOptions) :-
 1323    option(version(ReqVersion), PackOptions),
 1324    !,
 1325    satisfies_version(Pack, Version, ReqVersion).
 1326compatible_version(_, _, _).

 pack_options_compatible_with_info(+Info, +PackOptions) is semidet

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

 1333pack_options_compatible_with_info(Info, PackOptions) :-
 1334    findall(Prop, option_info_prop(PackOptions, Prop), Pairs),
 1335    dict_create(Dict, _, Pairs),
 1336    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.

 1346download_plan(_Targets, Plan, Plan, _Options) :-
 1347    exclude(installed, Plan, []),
 1348    !.
 1349download_plan(Targets, Plan0, Plan, Options) :-
 1350    confirm(download_plan(Plan0), yes, Options),
 1351    maplist(download_from_info(Options), Plan0, Plan1),
 1352    plan_unsatisfied_dependencies(Plan1, Deps),
 1353    (   Deps == []
 1354    ->  Plan = Plan1
 1355    ;   print_message(informational, pack(new_dependencies(Deps))),
 1356        prolog_description(Properties),
 1357        query_pack_server(versions(Deps, Properties), Result, []),
 1358        (   Result = true(Versions)
 1359        ->  pack_resolve(Targets, Plan1, Versions, Plan2, Options),
 1360            !,
 1361            download_plan(Targets, Plan2, Plan, Options)
 1362        ;   print_message(error, pack(query_failed(Result))),
 1363            fail
 1364        )
 1365    ).

 plan_unsatisfied_dependencies(+Plan, -Deps) is det

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

 1372plan_unsatisfied_dependencies(Plan, Deps) :-
 1373    phrase(plan_unsatisfied_dependencies(Plan, Plan), Deps).
 1374
 1375plan_unsatisfied_dependencies([], _) -->
 1376    [].
 1377plan_unsatisfied_dependencies([Info|Infos], Plan) -->
 1378    { Deps = Info.get(requires) },
 1379    plan_unsatisfied_requirements(Deps, Plan),
 1380    plan_unsatisfied_dependencies(Infos, Plan).
 1381
 1382plan_unsatisfied_requirements([], _) -->
 1383    [].
 1384plan_unsatisfied_requirements([H|T], Plan) -->
 1385    { is_prolog_token(H),           % Can this fail?
 1386      prolog_satisfies(H)
 1387    },
 1388    !,
 1389    plan_unsatisfied_requirements(T, Plan).
 1390plan_unsatisfied_requirements([H|T], Plan) -->
 1391    { member(Info, Plan),
 1392      (   (   Version = Info.get(version)
 1393          ->  Provides = @(Info.get(pack), Version)
 1394          ;   Provides = Info.get(pack)
 1395          )
 1396      ;   member(Provides, Info.get(provides))
 1397      ),
 1398      satisfies_req(Provides, H)
 1399    }, !,
 1400    plan_unsatisfied_requirements(T, Plan).
 1401plan_unsatisfied_requirements([H|T], Plan) -->
 1402    [H],
 1403    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.

 1412build_plan(Plan, Ordered, Options) :-
 1413    partition(needs_rebuild_from_info(Options), Plan, ToBuild, NoBuild),
 1414    maplist(attach_from_info(Options), NoBuild),
 1415    (   ToBuild == []
 1416    ->  Ordered = []
 1417    ;   order_builds(ToBuild, Ordered),
 1418        confirm(build_plan(Ordered), yes, Options),
 1419        maplist(exec_plan_rebuild_step(Options), Ordered)
 1420    ).
 1421
 1422needs_rebuild_from_info(Options, Info) :-
 1423    needs_rebuild(Info.installed, Options).

 needs_rebuild(+PackDir, +Options) is semidet

True when we need to rebuilt the pack in PackDir.

 1429needs_rebuild(PackDir, Options) :-
 1430    (   is_foreign_pack(PackDir, _),
 1431        \+ is_built(PackDir, Options)
 1432    ->  true
 1433    ;   is_autoload_pack(PackDir, Options),
 1434        post_install_autoload(PackDir, Options),
 1435        fail
 1436    ).

 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.

 1445is_built(PackDir, _Options) :-
 1446    current_prolog_flag(arch, Arch),
 1447    prolog_version_dotted(Version), % Major.Minor.Patch
 1448    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.

 1455order_builds(ToBuild, Ordered) :-
 1456    findall(DepForPack-Pack, dep_edge(ToBuild, Pack, DepForPack), Edges),
 1457    maplist(get_dict(pack), ToBuild, Packs),
 1458    vertices_edges_to_ugraph(Packs, Edges, Graph),
 1459    ugraph_layers(Graph, Layers),
 1460    append(Layers, PackNames),
 1461    maplist(pack_info_from_name(ToBuild), PackNames, Ordered).

 dep_edge(+Infos, -Pack, -DepForPack) is nondet

True when DepForPack is a dependency for Pack. Both Pack and DepForPack are pack _names.

 1468dep_edge(Infos, Pack, DepForPack) :-
 1469    member(Info, Infos),
 1470    Pack = Info.pack,
 1471    member(DepForPack, Info.get(dependency_for)),
 1472    (   member(DepInfo, Infos),
 1473        DepInfo.pack == DepForPack
 1474    ->  true
 1475    ).
 1476
 1477:- det(pack_info_from_name/3). 1478pack_info_from_name(Infos, Pack, Info) :-
 1479    member(Info, Infos),
 1480    Info.pack == Pack,
 1481    !.

 exec_plan_rebuild_step(+Options, +Info) is det

Execute the rebuild steps for the given Info.

 1487exec_plan_rebuild_step(Options, Info) :-
 1488    print_message(informational, pack(build(Info.pack, Info.installed))),
 1489    pack_post_install(Info.pack, Info.installed, Options),
 1490    attach_from_info(Options, Info).

 attach_from_info(+Options, +Info) is det

Make the package visible. Similar to pack_make_available/3.

 1496attach_from_info(_Options, Info) :-
 1497    Info.get(keep) == true,
 1498    !.
 1499attach_from_info(Options, Info) :-
 1500    (   option(pack_directory(_Parent), Options)
 1501    ->  pack_attach(Info.installed, [duplicate(replace)])
 1502    ;   pack_attach(Info.installed, [])
 1503    ).

 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.

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

 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.

 1583reload_info(_PackDir, Info, Info) :-
 1584    _ = Info.get(installed),	% we read it from the package
 1585    !.
 1586reload_info(PackDir, Info0, Info) :-
 1587    local_pack_info(PackDir, Info1),
 1588    Info = Info0.put(installed, PackDir)
 1589                .put(downloaded, Info0.url)
 1590                .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.

 1597work_done(_, _, _, _, Options),
 1598    option(silent(true), Options) =>
 1599    true.
 1600work_done(Targets, Plan, Plan, [], _Options) =>
 1601    convlist(can_upgrade_target(Plan), Targets, CanUpgrade),
 1602    (   CanUpgrade == []
 1603    ->  pairs_keys(Targets, Packs),
 1604        print_message(informational, pack(up_to_date(Packs)))
 1605    ;   print_message(informational, pack(installed_can_upgrade(CanUpgrade)))
 1606    ).
 1607work_done(_, _, _, _, _) =>
 1608    true.
 1609
 1610can_upgrade_target(Plan, Pack-_, Info) =>
 1611    member(Info, Plan),
 1612    Info.pack == Pack,
 1613    !,
 1614    _ = Info.get(latest_version).

 local_packs(+Dir, -Packs) is det

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

 1621local_packs(Dir, Packs) :-
 1622    findall(Pack, pack_in_subdir(Dir, Pack), Packs).
 1623
 1624pack_in_subdir(Dir, Info) :-
 1625    directory_member(Dir, PackDir,
 1626                     [ file_type(directory),
 1627                       hidden(false)
 1628                     ]),
 1629    local_pack_info(PackDir, Info).
 1630
 1631local_pack_info(PackDir,
 1632                #{ pack: Pack,
 1633                   version: Version,
 1634                   title: Title,
 1635                   hash: Hash,
 1636                   url: URL,
 1637                   git: IsGit,
 1638                   requires: Requires,
 1639                   provides: Provides,
 1640                   conflicts: Conflicts,
 1641                   installed: PackDir
 1642                 }) :-
 1643    directory_file_path(PackDir, 'pack.pl', MetaFile),
 1644    exists_file(MetaFile),
 1645    file_base_name(PackDir, DirName),
 1646    findall(Term, pack_dir_info(PackDir, _, Term), Info),
 1647    option(pack(Pack), Info, DirName),
 1648    option(title(Title), Info, '<no title>'),
 1649    option(version(Version), Info, '<no version>'),
 1650    option(download(URL), Info, '<no download url>'),
 1651    findall(Req, member(requires(Req), Info), Requires),
 1652    findall(Prv, member(provides(Prv), Info), Provides),
 1653    findall(Cfl, member(conflicts(Cfl), Info), Conflicts),
 1654    (   have_git,
 1655        is_git_directory(PackDir)
 1656    ->  git_hash(Hash, [directory(PackDir)]),
 1657        IsGit = true
 1658    ;   Hash = '-',
 1659        IsGit = false
 1660    ).
 1661
 1662
 1663		 /*******************************
 1664		 *        PROLOG VERSIONS	*
 1665		 *******************************/