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

swipl pack help

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

 current_pack(?Pack) is nondet

 current_pack(?Pack, ?Dir) is nondet

True if Pack is a currently installed pack.

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

 pack_list_installed is det

List currently installed packages and report possible dependency issues.

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

 pack_info(+Pack)

Print more detailed information about Pack.

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

 pack_info_term(+PackDir, ?Info) is nondet

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

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

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

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

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

 pack_info_term(?Term) is nondet

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

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

 pack_list(+Query) is det

 pack_list(+Query, +Options) is det

 pack_search(+Query) is det

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

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

Options processed:

installed(true)

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

outdated(true)

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

server((Server|false))

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

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

The predicates pack_list/1 and pack_search/1 are synonyms. Both contact the package server at https://www.swi-prolog.org to find available packages. Contacting the server can be avoided using the server(false) option.

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

 join_status(+PacksIn, -PacksOut) is det

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

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

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

Search locally installed packs.

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

 pack_install(+Spec:atom) is det

 pack_install(+SpecOrList, +Options) is det

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

• A pack name. This queries the pack repository at https://www.swi-prolog.org
• Archive file name
• A http(s) URL of an archive file name. This URL may contain a star (*) for the version. In this case pack_install/1 asks for the directory content and selects the latest version.
• An https GIT URL
• A local directory name given as file:// URL
• '.', in which case a relative symlink is created to the current directory (all other options for Spec make a copy of the files). Installation using a symlink is normally used during development of a pack.

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

swipl pack install <name>

Options:

url(+URL)

Source for downloading the package

pack_directory(+Dir)

Directory into which to install the package.

global(+Boolean)

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

insecure(+Boolean)

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

interactive(+Boolean)

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

silent(+Boolean)

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

upgrade(+Boolean)

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

rebuild(Condition)

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

test(Boolean)

If true (default), run the pack tests.

git(+Boolean)

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

link(+Boolean)

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

version(+Version)

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

branch(+Branch)

When installing from a git repository, clone this branch.

commit(+Commit)

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

build_type(+Type)

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

register(+Boolean)

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

server(+URL)

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

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

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

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

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

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

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

 pack_install_dir(-PackDir, +Options) is det

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

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

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

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

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

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

link(+Boolean)

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

upgrade(true)

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

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

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

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

  973known_media(_-Options) :-
  974    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.

  992pack_resolve(Pairs, Existing, Versions, Plan, Options) :-
  993    insert_existing(Existing, Versions, AllVersions, Options),
  994    phrase(select_version(Pairs, AllVersions,
  995                          [ plan(PlanA),           % access to plan
  996                            dependency_for([])     % dependencies
  997                          | Options
  998                          ]),
  999           PlanA),
 1000    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.

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

 1054can_upgrade(Info, [Version-_|_], Info2) :-
 1055    cmp_versions(>, Version, Info.version),
 1056    !,
 1057    Info2 = Info.put(latest_version, Version).
 1058can_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.

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

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

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

 info_conflicts(+Info1, +Info2) is semidet

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

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

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

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

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

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

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

 satisfies_req(+Provides, +Required) is semidet

Check a token requirements.

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

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

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

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

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

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

 pack_options_compatible_with_info(+Info, +PackOptions) is semidet

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

 1323pack_options_compatible_with_info(Info, PackOptions) :-
 1324    findall(Prop, option_info_prop(PackOptions, Prop), Pairs),
 1325    dict_create(Dict, _, Pairs),
 1326    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.

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

 plan_unsatisfied_dependencies(+Plan, -Deps) is det

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

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

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

 needs_rebuild(+PackDir, +Options) is semidet

True when we need to rebuilt the pack in PackDir.

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

 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.

 1435is_built(PackDir, _Options) :-
 1436    current_prolog_flag(arch, Arch),
 1437    prolog_version_dotted(Version), % Major.Minor.Patch
 1438    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.

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

 exec_plan_rebuild_step(+Options, +Info) is det

Execute the rebuild steps for the given Info.

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

 attach_from_info(+Options, +Info) is det

Make the package visible. Similar to pack_make_available/3.

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

 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.

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

 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.

 1568reload_info(_PackDir, Info, Info) :-
 1569    _ = Info.get(installed),	% we read it from the package
 1570    !.
 1571reload_info(PackDir, Info0, Info) :-
 1572    local_pack_info(PackDir, Info1),
 1573    Info = Info0.put(installed, PackDir)
 1574                .put(downloaded, Info0.url)
 1575                .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.

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

 local_packs(+Dir, -Packs) is det

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

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