Commit faecd82c authored by Eric Timmons's avatar Eric Timmons
Browse files

Update documentation

parent 0abda06b
#+TITLE: CLPM Changelog
* v0.2.0 - Unreleased
+ Major rewrite of metadata storage. All source data is now stored in flat
files that are read on demand.
+ Thread support is no longer mandatory.
+ Config and clpmfile{,.lock} formats have changed.
* v0.0.8 - 2019-04-05
Bug fix, bundle install now correctly fetches git repos when a commit is missing
* v0.0.7 - 2019-01-28
......
#+TITLE: Installing CLPM
#+AUTHOR: CLPM Developers
#+EMAIL: clpm-devel@common-lisp.net
#+OPTIONS: email:t toc:2 num:nil
CLPM is distributed in both source and binary form. For either version, first
install the dependencies:
+ tar :: Required.
+ git :: If you want to use development versions of your dependencies.
+ sbcl or ccl :: Either is required if systems need to be groveled for
dependencies (likely needed if you use development versions of any
dependency). SBCL is required if you are installing from source.
After installing CLPM core, it is recommended you also install the CLPM client
(see [[file:doc/client.org][client.org]]), but it is not needed for the quickstart.
* Prebuilt binaries
To install CLPM in binary form, download the appropriate file from
[[https://common-lisp.net/project/clpm/downloads/][https://common-lisp.net/project/clpm/downloads/]]. Each release of CLPM
consists of the following files:
+ =clpm-amd64-linux-gnu-$VERSION.tar.gz= :: CLPM compiled for 64bit
Linux using GNU libc (by far the most common).
+ =clpm-amd64-linux-musl-$VERSION.tar.gz= :: CLPM compiled for 64bit
Linux using musl libc (e.g., Alpine Linux).
+ =clpm-arm64-linux-gnu-$VERSION.tar.gz= :: CLPM compiled for 64bit
Linux on ARM processors using GNU libc.
+ =clpm-arm64-linux-musl-$VERSION.tar.gz= :: CLPM compiled for 64bit
Linux on ARM processors using musl libc.
+ =clpm-armv7-linux-gnu-$VERSION.tar.gz= :: CLPM compiled for 32bit
Linux on ARM processors using GNU libc.
+ =clpm-armv7-linux-musl-$VERSION.tar.gz= :: CLPM compiled for 32bit
Linux on ARM processors using musl libc.
+ =clpm-amd64-windows-$VERSION.msi= :: CLPM installer for 64 bit Windows.
+ =clpm-$VERSION.DIGESTS= :: Text file containing the SHA512 sums for every
previously mentioned file.
+ =clpm-$VERSION.DIGESTS.asc= :: Same as =clpm-$VERSION.DIGESTS=, but signed
with GPG key =0x10327DE761AB977333B1AD7629932AC49F3044CE=.
** GNU/Linux
After downloading the tarball and validating the SHA512 sum, unpack it and
run =sh install.sh=. By default, it is installed to =/usr/local/=, but that
prefix con be changed using the =INSTALL_ROOT= environment
variable. However, if you change the prefix, you will also likely need to
set the =CLPM_HOME= environment variable to point to
=$INSTALL_ROOT/lib/clpm/=.
** Windows
After downloading the installer and validating the SHA512 sum, simply run
the installer and follow the directions.
* Source install
** Configuring
CLPM can be customized by placing a file named
=customize-target-features.lisp-expr= in the root of the repo with a single
=lambda= form in it that takes a list of features and returns a modified
feature list. See [[file:src/clpm-build/features.lisp]] for a brief description
of the available features.
For example, to disable Dexador support, use the following form:
#+begin_src common-lisp
(lambda (features)
(flet ((enable (feature)
(pushnew feature features))
(disable (feature)
(setf features (remove feature features))))
(declare (ignorable #'enable #'disable))
(disable :clpm-dexador))
features)
#+end_src
** Build and install
After cloning the repo and checking out the version you want, ensure the
submodules are up to date (=git submodule init= and =git submodule update=)
and run:
#+begin_src shell
sbcl --script scripts/build.lisp
#+end_src
If you're on GNU/Linux, you can then run =sh install.sh= to install (see
above).
If you're on Windows, you need to additionally install [[https://wixtoolset.org/][WiX v3.x]] and run the
following:
#+begin_src shell
sbcl --script scripts/build-wxs.lisp
cd build
%PATH_TO_WIX_INSTALL%/bin/candle clpm.wxs
%PATH_TO_WIX_INSTALL%/bin/light clpm.wxs -ext %PATH_TO_WIX_INSTALL%/bin/WixUIExtension.dll -cultures:en-us -out clpm.msi
#+end_src
This will get you an installer you can use.
** Live install
If you would like to hack on CLPM, it may be easiest to load CLPM every time
you want to use it instead of building a binary. The easiest way to do this
is to execute =scripts/clpm-live-sbcl=. I recommend symlinking it to
something like =/usr/local/bin/clpm=.
......@@ -3,184 +3,170 @@
#+EMAIL: clpm-devel@common-lisp.net
#+OPTIONS: email:t toc:2 num:nil
**WARNING**: This software is ALPHA quality. I use it as my daily driver, but it
is still a little rough around the edges and it may accidentally eat your files.
**WARNING**: This software is BETA quality. I use it as my daily driver, but it
is still a little rough around the edges and it may accidentally eat your
files.
* Description
CLPM is a package manager for Common Lisp. It is focused on managing packages
for both user contexts and project specific contexts (bundles).
CLPM is a package manager for Common Lisp. It can manage packages in both
global and project specific contexts.
It consists of two major pieces. First is a standalone program that is
responsible for all the heavy lifting of fetching and unpacking releases in
the correct place and managing project specific environments. This piece is
generally referred to as CLPM, the CLPM core, or =clpm= and is distributed as
a precompiled image using SBCL (but it is possible to compile it from
source). The second is a small client library written in portable Common Lisp
that interfaces with ASDF and calls CLPM as necessary to find and install
missing systems. This piece is generally referred to as the CLPM client or
=clpm-client= and is meant to be loaded into development images.
To contact the developers, send email to and/or join
clpm-devel@common-lisp.net
responsible for all the heavy lifting of downloading and unpacking releases
in the correct place, resolving dependencies, and managing project specific
environments. This piece is generally referred to as CLPM, the CLPM core, or
=clpm= and is distributed as a precompiled executable using SBCL (but it is
possible to compile it from source). The second is a small client library
written in portable Common Lisp that interfaces with ASDF and calls CLPM as
necessary to find and install missing systems. This piece is generally
referred to as the CLPM client or =clpm-client= and is meant to be loaded
when you are interactively developing code.
To contact the developers, send email to clpm-devel@common-lisp.net
[[https://mailman.common-lisp.net/listinfo/clpm-devel]].
* Project Goals
CLPM is far from the only package manager available for Common Lisp[fn:1], but
it makes very different assumptions and design choices than the other
available solutions. In this section we describe our high level goals and how
they affect our design decisions.
+ Minimize footprint in development Lisp image :: Ultimately, dependency
management should not be a large part of developing a library or
application - you should be focused on creating your cool functionality
instead of downloading and installing dependencies. So why should all the
(nontrivial amounts of) code necessary for downloading libraries, resolving
their dependencies, unpacking them, and installing them ever be present in
your development Lisp image? This drives CLPM's separation into the core and
the client. Additionally, some Lisps (I'm looking at you, SBCL) have a large
memory footprint and this helps keep that down.
+ Use existing libraries where possible :: Because the CLPM core never needs
to be loaded into a development image, there are no issues with version
conflicts or incompatibilities between third party libraries used by CLPM
and the code being developed. This means that existing libraries can be
leveraged where it makes sense and we don't need to reinvent the wheel.
+ Support cleanup on image dump :: Many Common Lisp implementations allow you
to deliver programs by dumping an in-memory image to file. For most programs
generated there is no need to have a bundled package manager. Therefore,
CLPM provides an option to remove the client from the image when it is
dumped (using UIOP provided functions).
+ Support multiple workflows and configurations :: We want it to be equally
easy to hack on CLPM, to use it for CI, and to use it for development by
coders uninterested in hacking on CLPM itself. This means we strive to
support both distribution of a (mostly) statically linked program as well as
using CLPM directly from source.
+ Support installing multiple package versions :: CLPM supports installing
multiple versions of the same package simultaneously. This is an enabling
feature for managing project specific dependencies as well as global
dependencies.
+ Support multiple package sources :: At first, CLPM will support only
Quicklisp-style distributions as a package source/repository. But we
envision adding support for new sources, preferably including one that
stores the upstream repos for each project.
* Installing
CLPM is distributed in both source and binary form. Additionally, the binaries
are distributed in both dynamically and statically linked forms (note: the
binaries are built with SBCL, which does not support statically linking against
the C library[fn:3], so you need to get the one that matches your OS's libc
(most likely the =gnu= variant)).
For either version, first install the dependencies:
+ tar :: Required[fn:2].
+ git :: If using bundles with git repos specified.
+ sbcl or ccl :: If systems need to be groveled for dependencies (likely
needed if you use bundles).
+ openssl :: Needed if accessing sources over https *and* compiling from
source or using the dynamically linked version.
After installing CLPM core, it is recommended you also install the CLPM client
(see [[file:doc/client.org][client.org]]), but it is not needed for the quickstart.
** Prebuilt binaries
To install CLPM in binary form, download the appropriate file from
[[https://common-lisp.net/project/clpm/downloads/][https://common-lisp.net/project/clpm/downloads/]]. It is highly recommended that
you use the static variants. Each release of CLPM consists of the following
files:
+ =clpm-$VERSION-x86_64-linux-gnu-dynamic= :: CLPM compiled for 64bit
Linux. Dynamically links against glibc (GNU's libc) and all supporting
libraries.
+ =clpm-$VERSION-x86_64-linux-gnu-static= :: CLPM compiled for 64bit
Linux. Dynamically links against glibc (GNU's libc) and statically linked
against all supporting libraries.
+ =clpm-$VERSION-x86_64-linux-musl-dynamic= :: CLPM compiled for 64bit
Linux. Dynamically links against musl libc and all supporting libraries.
+ =clpm-$VERSION-x86_64-linux-musl-static= :: CLPM compiled for 64bit
Linux. Dynamically links against musl libc and statically linked against
all supporting libraries.
+ =clpm-$VERSION-x86_64-windows-dynamic.exe= :: CLPM compiled for 64bit
Windows. Dynamically links against all supporting libraries.
+ =clpm-$VERSION-x86_64-windows-static.exe= :: CLPM compiled for 64bit
Windows. Statically linked against all supporting libraries.
+ =clpm-$VERSION-x86_64-darwin-dynamic= :: CLPM compiled for 64bit
MacOS. Dynamically links against all supporting libraries.
+ =clpm-$VERSION.DIGESTS= :: Text file containing the SHA512 sums for every
previously mentioned file.
+ =clpm-$VERSION.DIGESTS.asc= :: Same as =clpm-$VERSION.DIGESTS=, but signed
with GPG key =0x10327DE761AB977333B1AD7629932AC49F3044CE=.
After downloading the binary and validating the SHA512 sum, make sure the
file is executable, and save it as =clpm= (or =clpm.exe=) somewhere on your
PATH.
** Source install
The next easiest way to install CLPM is to install SBCL, clone the CLPM
sources (including the git submodules!), and symlink the [[file:scripts/clpm-live][clpm-live]] script as
=clpm= somewhere on your PATH. Alternatively, you can build a dynamically or
statically linked executable by running one of the following:
#+begin_src shell
sbcl --script scripts/clpm-build-dynamic-sbcl
sbcl --script scripts/clpm-build-static-sbcl
#+end_src
See [[file:INSTALL.org][INSTALL.org]] for detailed installation instructions.
* Quickstart
Now that you have CLPM installed, you can begin using it! First, you need to
add a software repository. You likely want to start with the main Quicklisp
distribution, so create a file called =~/.config/common-lisp/clpm/clpm.conf=
with the following contents:
Now that you have CLPM installed, this section walks you through how to set
it up as a Quicklisp alternative.
First, configure CLPM to use the Quicklisp index as a source for packages and
to use HTTPS to fetch files from it [fn:1]. Create a file called
=~/.config/clpm/sources.conf= with the following contents:
#+begin_src common-lisp
(clpm-config
:sources
("quicklisp"
(:type :quicklisp
:url "https://beta.quicklisp.org/dist/quicklisp.txt"
:force-https t)))
("quicklisp"
:type :quicklisp
:url "https://beta.quicklisp.org/dist/quicklisp.txt")
#+end_src
This configures CLPM to use the primary Quicklisp distribution and configures
it to always fetch files from it over HTTPS [fn:5] [fn:6]. See [[file:doc/config.org][config.org]] for
more details.
See [[file:doc/sources.org][sources.org]] for more details on configuring sources.
Then, sync your local copy of the Quicklisp metadata by running:
Next, configure your favorite Lisp to load the client by placing the output
of the following command in your Lisp's init file (such as =~/.sbclrc=).
#+begin_src shell
clpm sync
clpm client rc --quicklisp-alternative
#+end_src
Syncing may take a while the first time. When it's finished, you can install a
project, such as CFFI, by running:
Then, sync your local copy of the Quicklisp metadata by running:
#+begin_src shell
clpm install cffi
clpm sync
#+end_src
This will install all ASDF systems belonging to the CFFI project (currently
=cffi=, =cffi-uffi-compat=, =cffi-toolchain=, =cffi-tests=, =cffi-libffi=,
=cffi-grovel=, and =cffi-examples=) and all their dependencies.
Syncing may take a while the first time as it needs to fetch and process the
metadata for every Quicklisp release.
If you want to install only a single system and its dependencies[fn:4] you can use
the =-s= (system) option, such as:
Then you can start your favorite lisp and try loading a system, such as
alexandria:
#+begin_src shell
clpm install -s cffi
#+begin_src common-lisp
(asdf:load-system :alexandria)
#+end_src
You can test this was successful by starting your favorite Lisp and running:
CLPM will see that alexandria is not present locally and automatically
install it before loading it.
#+begin_src common-lisp
(require :asdf)
(asdf:load-system :cffi)
#+end_src
* Project Goals
CLPM is far from the only package manager available for Common Lisp[fn:2], but
it makes very different assumptions and design choices than the other
available solutions. In this section we describe our high level goals and how
they affect our design decisions.
Note how you do not need to load any CLPM code inside your Lisp image in order
to load CFFI after installing it. (Assuming you have ASDF 3+ installed).
** Use existing libraries where possible
If you look at Quicklisp, you'll quickly notice that the client does not
rely on any third party code and all functionality, from an HTTP client to
untaring, are implemented completely as part of the Quicklisp client
project. The upsides of this strategy are that only required functionality
is loaded into the development image, it prevents version conflicts between
code the Quicklisp client depends on and the code you're developing depends
on, and it helps ensure that Quicklisp works on a broad set of Common Lisp
implementations. However, it has a major downside: the maintenance and
development costs of the package manager are high, potentially making it
difficult to implement new features and the package manager does not really
drive the quality of code in the community at large higher.
The desire to use existing libraries drives the decision for the CLPM core
and client to be separated. The client has no external dependencies which
allows it to share all the benefits of Quicklisp's model, and the core never
needs to be loaded into a development image, so it can leverage any
dependency that makes sense without impacting the development image in the
slightest.
** Support HTTPS
HTTPS is becoming more and more ubiquitous. Some websites (such as Github
and Gitlab) are only served over HTTPS and some users insist on HTTPS
everywhere possible. This trend is not going away, therefore CLPM should
natively support HTTPS.
As no Lisp implementation I am aware of has native support for TLS, this
means that CLPM has to use third party tools to achieve this support. This
further drives the separation of the core and client, as CLPM can use
foreign libraries to provide TLS support and this is not something that
should be brought into a development image that does not need it
otherwise.
Additionally, Quicklisp packages are served over HTTPS. While the Quicklisp
client cannot take advantage of that (without
[[https://github.com/snmsts/quicklisp-https]]), CLPM can, providing a little
more of a guarantee that packages have not been tampered with.
** Minimize footprint in development images and deployments
Many Common Lisp implementations allow you to deliver programs by dumping an
image to file. For most programs generated this way there is no need to have
a bundled package manager. Therefore, there should be an easy way to use a
package manager without leaving traces if it in your deployed system.
To this end, CLPM can be used without ever loading the client (for example,
=clpm bundle exec= configures ASDF entirely through environment variables)
and if you do choose to use the client for better interactive development,
CLPM is able to remove itself from the image when it is dumped.
** Support CI/CD workflows
CI and CD are nice to have and nicer still when the jobs can run quickly and
give fast feedback. To that end, CLPM is distributed in both binary and
source form. Source for hackers or people who want to use a different
feature set and binary for quick and easy installation in other cases.
** Support installing multiple package versions
Ideally, updates to packages would never introduce regressions. However, we
live in reality and this happens frequently (just look at the packages that
get removed from Quicklisp in any given release for failing to
build). Additionally, sometimes you just really need to use an old version
of a dependcy for some project while using the latest version of the same
dependency in another project.
To this end, CLPM supports installing multiple versions of the same package
simultaneously. This is additionally an enabling feature for managing
project specific contexts as well as global contexts.
** Support and encourage explicitly versioned systems
ASDF allows developers to provide version numbers for their systems and
associate version requirements with dependencies. IMHO this is a criminally
underutilized feature of ASDF and it should be *required* that any release
of a package in any package index should declare a version number. However,
it is a lot of work to convince others to believe the same way and even if a
critical mass did buy in, things wouldn't change overnight.
Therefore, CLPM supports both the status quo (a Quicklisp package index
versioned by date) as well as a work in progress package index (working name
of CLPI). This new Common Lisp Package Index includes both extra metadata
about projects (such as the upstream repo which can be used to check out
development versions) and requires that systems are versioned in order to be
released.
* In-depth Documentation
......@@ -195,19 +181,7 @@ is still a little rough around the edges and it may accidentally eat your files.
* Footnotes
[fn:6] On Windows, CLPM will fetch over HTTPS, but it will *not* currently
validate the certificates. See [[https://gitlab.common-lisp.net/clpm/clpm/issues/1][issue#1]] for more info.
[fn:5] All files in the primary Quicklisp distribution are served over both
[fn:1] All files in the primary Quicklisp distribution are served over both
HTTPS and HTTP, even though the Quicklisp client cannot use HTTPS itself.
[fn:4] Really, the entire project the system belongs to will be installed, but
only the dependencies of the specified system will be installed.
[fn:3] If you know a way to statically link SBCL against libc, please let me
know!
[fn:1] See, for example: [[https://www.quicklisp.org/beta/][Quicklisp]], [[https://github.com/fukamachi/qlot/][Qlot]], and [[https://github.com/CodyReichert/qi][Qi]].
[fn:2] Using the archive CL library for a full Common Lisp solution is on the
roadmap, but it needs a decent amount of work.
[fn:2] See, for example: [[https://www.quicklisp.org/beta/][Quicklisp]], [[https://github.com/fukamachi/qlot/][Qlot]], and [[https://github.com/CodyReichert/qi][Qi]].
......@@ -2,13 +2,15 @@
#+AUTHOR: CLPM Developers
#+EMAIL: clpm-devel@common-lisp.net
This file describes the "bundle" capabilities of CLPM. Bundles are meant to
ease the problems of creating repeatable development, deployment, and testing
environments. While ASDF does not allow developers to specify upper bounds on
dependency versions (only lower bounds) [fn:1], CLPM's bundle capability allows
exactly that, in addition to specifying that some dependency should be
satisfied by some unreleased version directly from source control (great for
developing projects in multiple repos simultaneously!).
This file describes the "bundle" capabilities of CLPM. Bundles are anonymous,
project specific contexts that can be included in source repositories.
Bundles are meant to ease the problems of creating repeatable development,
deployment, and testing environments. While ASDF does not allow developers to
specify upper bounds on dependency versions (only lower bounds) [fn:1], CLPM's
bundle capability allows exactly that, in addition to specifying that some
dependency should be satisfied by some unreleased version directly from source
control (great for developing projects in multiple repos simultaneously!).
A CLPM bundle is a collection of systems locked at specific versions. A bundle
is fully defined by a =clpmfile.lock= file, which is itself created from a
......@@ -25,7 +27,7 @@ with zero configuration or helpers needed (other than ASDF, of course).
consists of a series of directives where each directive is a list starting
with a keyword. The directives are described below. Additionally, the first
directive in the file must be the ~:api-version~ directive. This document
describes version "0.2".
describes version "0.3".
*** ~:api-version~
......@@ -34,7 +36,7 @@ with zero configuration or helpers needed (other than ASDF, of course).
file is described in. Example:
#+begin_src common-lisp
(:api-version "0.2")
(:api-version "0.3")
#+end_src
*** ~:source~
......@@ -49,8 +51,7 @@ with zero configuration or helpers needed (other than ASDF, of course).
#+begin_src common-lisp
(:source "quicklisp"
:type :quicklisp
:url "https://beta.quicklisp.org/dist/quicklisp.txt"
:force-https t)
:url "https://beta.quicklisp.org/dist/quicklisp.txt")
#+end_src
*** ~:project~
......@@ -118,7 +119,7 @@ with zero configuration or helpers needed (other than ASDF, of course).
relative to the clpmfile.
+ ~systems~ :: What systems defined by the ASD file should be included. Must
be a list of strings. If NIL, then all systems explicitly defined in the
asd file are required and have their dependencies satisfied.[fn:2]
asd file are required and have their dependencies satisfied.
** clpmfile.lock
......@@ -132,10 +133,9 @@ with zero configuration or helpers needed (other than ASDF, of course).
* Configuration
Every bundle command reads the file =.clpm/bundle.conf= (if it exists,
relative to the =clpmfile.lock=) and merges the configuration defined in that
file into CLPM's central config. Currently, all configuration sections are
merged, in a future version a whitelist of configuration options will be
defined.
relative to the =clpmfile=) and merges the configuration defined in that file
into CLPM's central config. Currently, all configuration sections are merged,
in a future version a whitelist of configuration options will be defined.
* Commands
** =clpm bundle install=
......@@ -167,26 +167,7 @@ with zero configuration or helpers needed (other than ASDF, of course).
Update the lock file to point to the latest versions available that satisfy
the constraints in the =clpmfile=.
* Comparisons
In the Common Lisp world, CLPM's bundle is most similar to [[https://github.com/fukamachi/qlot][Qlot]]. Unlike Qlot,
however, CLPM has the following features:
+ Does not use the Quicklisp client under the hood.
+ Has no dependency on roswell for its command line executable.
+ Is distributed both as source and an executable.
+ Works harder to determine dependencies of systems fetched from git.
+ Allows for more complex version specifications in the clpmfile.
+ Allows for easily cloning remote repositories over HTTPS with
authentication.
Like Qlot, this portion of CLPM was heavily influenced by Ruby's bundler.
* Footnotes
[fn:1] https://bugs.launchpad.net/asdf/+bug/1183179
[fn:2] Only the top level system of a package-inferred-system is considered to
be explicitly defined. If you require dependencies of subsystems that the top
level system does not depend on to be satisfied, you must list those systems
explicitly.
......@@ -2,34 +2,53 @@
#+AUTHOR: CLPM Developers
#+EMAIL: clpm-devel@common-lisp.net
While CLPM can be used without the client, installing and using the client makes
Common Lisp coding a more interactive and fun experience. The CLPM client can be
loaded into a Lisp image and integrates with ASDF to seamlessly install missing
systems a la the Quicklisp client.
* Installing
To install the CLPM Client, run the following in your favorite terminal
emulator. It will additionally prompt if you want to add the client to your
ASDF search path (highly recommended).
#+begin_src shell
clpm client
#+end_src
* Using
To use the client, just load it with ASDF and activate it.
#+begin_src common-lisp
(asdf:load-system :clpm-client)
(clpm-client:activate-clpm)
#+end_src
Now, if you attempt to ~asdf:load-system~ a missing system, a condition will
be signaled with a ~INSTALL-SYSTEM~ restart that will attempt to install the
missing system using CLPM and then load it.
If you would prefer the system to be automatically installed, you can set
~clpm-client:*clpm-system-not-found-behavior*~ to ~:install~ and it will be
silently installed if possible.
While CLPM can be used without the client, installing and using the client
makes Common Lisp coding a more interactive and fun experience. The CLPM client
can be loaded into a Lisp image and integrates with ASDF to seamlessly install
missing systems similar to the Quicklisp client.
Note that the clpm-client interface may change at any time before a stable
1.0.0 version is released.
* clpm-client ASDF System
The client's ASDF system name is =clpm-client=. It is installed with CLPM,
typically in =/usr/local/lib/clpm/src/clpm-client=. In order to use the
client, you must configure ASDF to find this system (see the ASDF manual for
more information on how to do this) or directly load the .asd file using
=asdf:load-asd=.
The output of =clpm client rc= prints several ways to load and configure the
client. The default rc configuration provides a function that loads the
client when called. The =--quicklisp-alternative= option can be used to
generate rc file contents that automatically load the client and configure it
to behave similarly to Quicklisp.
* ASDF Integration
By default, the client does not hook into ASDF unless directed to. In order
to get the benefit of automatically installing systems, enable the ASDF hooks
by running =(clpm-client:activate-clpm-asdf-integration)=
* Configuring
The client exports several variables that control its behavior. These
variables are:
+ =*clpm-cleanup-on-dump-p*= :: Defaults to T. If non-NIL, then the client
attempts to clean up after itself on image dumps. This cleanup attempts to
remove all traces of CLPM from various hooks and then deletes all packages
that belong to the client.
+ =*clpm-context*= :: Defaults to ="default"=. A string naming the global
context to use when not inside a bundle.
+ =*clpm-executable*= :: If you installed CLPM at a non-standard path or wish
to execute it with non-standard options, set this variable. It can either
be a string (the path to CLPM) or a list of strings.
+ =*clpm-system-not-found-behavior*= :: Defaults to =:error=. Controls the
behavior of the client when it ASDF integration has been enabled and a
system cannot be found. If =:error=, it signals a condition with several
restarts enabled to let you interactively determine how to proceed. If
=:install= then it tries to install the missing system. If