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

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

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

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

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

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

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

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

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

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

 info_conflicts(+Info1, +Info2) is semidet

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

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

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

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

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

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

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

 satisfies_req(+Provides, +Required) is semidet

Check a token requirements.

 1244satisfies_req(Token, Token) => true.
 1245satisfies_req(@(Token,_), Token) => true.
 1246satisfies_req(@(Token,PrvVersion), Req), cmp(Req, Token, Cmp, ReqVersion) =>
 1247	cmp_versions(Cmp, PrvVersion, ReqVersion).
 1248satisfies_req(_,_) => fail.
 1249
 1250cmp(Token  < Version, Token, <,	 Version).
 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).

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

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

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

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

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

 pack_options_compatible_with_info(+Info, +PackOptions) is semidet

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

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

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

 plan_unsatisfied_dependencies(+Plan, -Deps) is det

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

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

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

 needs_rebuild(+PackDir, +Options) is semidet

True when we need to rebuilt the pack in PackDir.

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

 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.

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

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

 exec_plan_rebuild_step(+Options, +Info) is det

Execute the rebuild steps for the given Info.

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

 attach_from_info(+Options, +Info) is det

Make the package visible. Similar to pack_make_available/3.

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

 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.

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

 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.

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

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

 local_packs(+Dir, -Packs) is det

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

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