Next: Introduction, Previous: (dir), Up: (dir) [Contents][Index]
This is the qlot Reference Manual, version 0.9.15, generated automatically by Declt version 3.0 "Montgomery Scott" on Mon Dec 02 11:09:07 2019 GMT+0.
| • Introduction | What qlot is all about | |
| • Systems | The systems documentation | |
| • Files | The files documentation | |
| • Packages | The packages documentation | |
| • Definitions | The symbols documentation | |
| • Indexes | Concepts, functions, variables and data types |
Qlot (pronounced kyü-'lät, like culotte) is a project-local library installer using Quicklisp facility. This aims to be like Bundler of Ruby or Carton of Perl.
Warning: This software is still BETA quality. The APIs will be likely to change.
# "qlfile" of "myapp"
git clack https://github.com/fukamachi/clack.git
github datafly fukamachi/datafly :branch v0.7.x
ql log4cl 2014-03-17
$ cd /path/to/myapp
# Installing libraries project-locally.
$ qlot install
# Updating depending libraries of a project.
$ qlot update
# Updating specific libraries
$ qlot update --project mito
# Execute a command with a project-local Quicklisp
$ qlot exec ros -S . run
$ qlot exec clackup app.lisp
We have Quicklisp, the central library registry. It made installation of libraries damn easy.
However, what only you can specify is the month of distribution. Which means you have to use all libraries of the same moment and you cannot use a newer/older version of a library for your project.
"local-projects/" or ASDF configurations may be a solution to this problem, but there are a couple of problems.
They are not project-local. If you have multiple projects that use the different version of the same library, it would be a problem.
They are difficult to fix the version or to update them. If your project need to work on other than your machine, for instance on other people's machine or on servers, the version of depending libraries should be the same.
This is what Qlot is trying to solve.
It also can be installed with Roswell.
$ ros install qlot
# Install the latest version from GitHub
$ ros install fukamachi/qlot
It's almost the same as using Quicklisp, except it also introduces a shell command "qlot".
$ which qlot
/Users/nitro_idiot/.roswell/bin/qlot
$ qlot
Usage: qlot COMMAND [ARGS..]
COMMANDS:
install
Installs libraries to './.qlot'.
update
Makes './.qlot' up-to-date and update 'qlfile.lock'.
Possible to update specific projects with --project option.
ex) qlot update --project mito
bundle
Dumps all libraries to './bundle-libs' to allow to load them without Qlot and Quicklisp.
run
Starts REPL with the project local Quicklisp dists (Same as 'qlot exec ros run').
exec [shell-args..]
Invokes the following shell-command with the project local Quicklisp.
Put a file "qlfile" at the root of your project directory.
See qlfile syntax section to know how to write it.
You can install libraries into the project directory via:
$ qlot install
It creates .qlot/ directory in the project directory and a file qlfile.lock.
qlfile.lock is similar to qlfile except the library versions are qualified. This will ensure that other developers or your deployment environment use exactly the same versions of libraries you just installed.
Make sure you add qlfile and qlfile.lock to your version controlled repository and make the .qlot/ directory ignored.
$ echo .qlot/ >> .gitignore
$ git add qlfile qlfile.lock
$ git commit -m 'Start using Qlot.'
You can update the content of .qlot/ directory via:
$ qlot update
It will also overwrite qlfile.lock.
You can bundle all depending libraries into bundle-libs/ via:
$ qlot bundle
$ git add bundle-libs/
$ git commit -m 'Bundle dependencies.'
qlot install will install Quicklisp and libraries that declared in qlfile project-locally. qlfile.lock will be used with precedence if it exists.
$ qlot install
$ qlot install /path/to/myapp/qlfile
qlot update will update the project-local .qlot/ directory using qlfile.
$ qlot update
qlot bundle will bundle dependencies into bundle-libs/ by using ql:bundle-systems.
$ qlot bundle
qlot exec does following:
CL_SOURCE_REGISTRY environment variable by adding a current directory;bin directory to the PATH environment variable;Here are few usefull commands:
qlot exec ros emacs - starts Emacs for development. Inferior lisp will use only
systems, installed by qlot install. If you want to use systems from directories other than
current and ./.qlot/, then set CL_SOURCE_REGISTRY variable before starting qlot.
This can be useful in case, if you have development versions of some systems, for example,
in ~/common-lisp/ directory and want to use them during project development:
CL_SOURCE_REGISTRY=~/common-lisp// qlot exec ros emacs
Read more about CL_SOURCE_REGISTRY in
asdf's documentation.
qlot exec ros build some-app.ros - another command, useful, to build a binary
from systems, fixed in qlfile and qlfile.lock. This way you can be sure that your builds are stable.
qlfile syntax"qlfile" is a collection of Quicklisp dist declarations. Each line of that represents a dist.
<source> <project name> [arg1, arg2..]
Currently, <source> must be one of ql, http, git or github.
ql <project name> <version>
ql <project name> :latest
ql :all <version>
ql source will download libraries from Quicklisp official dist, but you can specify the version.
If you want to use Clack in Quicklisp dist of January 13, 2014, qlfile would be like this.
ql clack 2014-01-13
ql source also allows :all as <dist name> and :latest as the version.
ql :all 2014-01-13
ql clack :latest
http <project name> <url> [<file md5>]
http source will download a tarball.
http yason http://netzhansa.com/yason.tar.gz
git <project name> <repos url>
git <project name> <repos url> :ref <commit ref>
git <project name> <repos url> :branch <branch name>
git <project name> <repos url> :tag <tag name>
git source will download libraries from a public git repository.
git clack https://github.com/fukamachi/clack.git
You can also specify :ref, :branch or :tag.
git clack https://github.com/fukamachi/clack.git :branch develop
git datafly https://github.com/fukamachi/datafly.git :tag v0.7.4
git cl-dbi https://github.com/fukamachi/cl-dbi.git :ref 54928984e5756e92ba298aae51de8b95a6b0cf4b
Qlot doesn't authenticate itself, but retrieving from private repository can be done via git's SSH key authentication. Which means, if the current user can git clone, Qlot also would be possible to do it.
git myapp git@github.com:somewrite-adtech/myapp
github <project name> <repos>
github <project name> <repos> :ref <commit ref>
github <project name> <repos> :branch <branch name>
github <project name> <repos> :tag <tag name>
github source is similar to git, but it is specifically for GitHub. As it uses GitHub API and tarballs GitHub serves, it doesn't require "git" command.
github datafly fukamachi/datafly
github datafly fukamachi/datafly :branch develop
If multiple distributions provide the same library, lower one would take priority over higher ones.
SLIME is the most popular development environment in Common Lisp. However, its REPL always loads the global Quicklisp, not the project-local one.
Here's quick steps to start project-local REPL with SLIME:
init.el.(defun slime-qlot-exec (directory)
(interactive (list (read-directory-name "Project directory: ")))
(slime-start :program "qlot"
:program-args '("exec" "ros" "-S" "." "run")
:directory directory
:name 'qlot
:env (list (concat "PATH=" (mapconcat 'identity exec-path ":")))))
M-x slime-qlot-exec RET /path/to/project/.PROJECT_ROOT/.qlot/local-projects can be used for local git repositories. Symbolic links are also be accessible in Qlot environment.
Copyright (c) 2014 Eitaro Fukamachi (e.arrows@gmail.com)
Licensed under the MIT License
Next: Files, Previous: Introduction, Up: Top [Contents][Index]
The main system appears first, followed by any subsystem dependency.
| • The qlot system | ||
| • The qlot/main system | ||
| • The qlot/util system |
Next: The qlot/main system, Previous: Systems, Up: Systems [Contents][Index]
Eitaro Fukamachi
MIT
A project-local library installer
0.9.15
qlot/main (system)
qlot.asd (file)
Next: The qlot/util system, Previous: The qlot system, Up: Systems [Contents][Index]
Eitaro Fukamachi
MIT
qlot/util (system)
qlot.asd (file)
lisp.lisp (file)
Previous: The qlot/main system, Up: Systems [Contents][Index]
Files are sorted by type and then listed depth-first from the systems components trees.
| • Lisp files |
| • The qlot.asd file | ||
| • The qlot/main/lisp.lisp file | ||
| • The qlot/util/lisp.lisp file |
Next: The qlot/main/lisp․lisp file, Previous: Lisp files, Up: Lisp files [Contents][Index]
Next: The qlot/util/lisp․lisp file, Previous: The qlot․asd file, Up: Lisp files [Contents][Index]
qlot/main (system)
main.lisp
Previous: The qlot/main/lisp․lisp file, Up: Lisp files [Contents][Index]
qlot/util (system)
util.lisp
Next: Definitions, Previous: Files, Up: Top [Contents][Index]
Packages are listed by definition order.
| • The qlot package | ||
| • The qlot/util package |
Next: The qlot/util package, Previous: Packages, Up: Packages [Contents][Index]
lisp.lisp (file)
qlot/main
common-lisp
Previous: The qlot package, Up: Packages [Contents][Index]
lisp.lisp (file)
common-lisp
Definitions are sorted by export status, category, package, and then by lexicographic order.
| • Exported definitions | ||
| • Internal definitions |
Next: Internal definitions, Previous: Definitions, Up: Definitions [Contents][Index]
| • Exported special variables | ||
| • Exported macros | ||
| • Exported functions |
Next: Exported macros, Previous: Exported definitions, Up: Exported definitions [Contents][Index]
Next: Exported functions, Previous: Exported special variables, Up: Exported definitions [Contents][Index]
Previous: Exported macros, Up: Exported definitions [Contents][Index]
According to ASDF documentation:
https://common-lisp.net/project/asdf/asdf/Shell_002dfriendly-syntax-for-configuration.html
environment variable can contain a string with directories to search systems in,
or a s-exp in DSL, describing sources of systems.
This function modifies such string by adding ‘dir-to-add’ in such
way, so it will have a preference over other system sources specified
in CL_SOURCE_REGISTRY environment variable.
Install Quicklisp and libraries that declared in qlfile project-locally. qlfile.lock will be used with precedence if it exists.
Install Quicklisp in the given PATH.
If PATH isn’t specified, this installs it to ’./.qlot/’.
This function differ from alexandria:make-keyword because it upcases text before making it a keyword.
Load SYSTEMS in the each project-local ‘.qlot/‘.
Update the project-local ’.qlot/’ directory using qlfile.
Previous: Exported definitions, Up: Definitions [Contents][Index]
| • Internal special variables | ||
| • Internal functions |
Next: Internal functions, Previous: Internal definitions, Up: Internal definitions [Contents][Index]
Previous: Internal special variables, Up: Internal definitions [Contents][Index]
Add all entries from FROM-TABLE to TO-TABLE, overwriting existing entries with the same key.
Previous: Definitions, Up: Top [Contents][Index]
| • Concept index | ||
| • Function index | ||
| • Variable index | ||
| • Data type index |
Next: Function index, Previous: Indexes, Up: Indexes [Contents][Index]
| Jump to: | F L Q |
|---|
| Jump to: | F L Q |
|---|
Next: Variable index, Previous: Concept index, Up: Indexes [Contents][Index]
| Jump to: | A B C E F G I M P Q R S U W |
|---|
| Jump to: | A B C E F G I M P Q R S U W |
|---|
Next: Data type index, Previous: Function index, Up: Indexes [Contents][Index]
| Jump to: | *
S |
|---|
| Jump to: | *
S |
|---|
Previous: Variable index, Up: Indexes [Contents][Index]
| Jump to: | P Q S |
|---|
| Jump to: | P Q S |
|---|