summaryrefslogtreecommitdiff
path: root/gnu
diff options
context:
space:
mode:
authorPierre Neidhardt <mail@ambrevar.xyz>2019-10-29 15:44:33 +0100
committerPierre Neidhardt <mail@ambrevar.xyz>2019-11-28 19:36:12 +0100
commitabf43a67d5929bf279edce3e790ef1348dda32a5 (patch)
tree2fe4feefeb2e96a4dd811ae5dd1028da39f21cd8 /gnu
parent183fd2070c7c50675df419e456d6bc036b4aa490 (diff)
gnu: Move lisp libraries to lisp-xyz, uglify-js to javascript and stumpwm to wm.
* gnu/local.mk: Include lisp-xyz.scm. * gnu/packages/lisp-xyz.scm: New file. * gnu/packages/lisp.scm: Move all lisp libraries to lisp-xyz.scm, uglify-js to javascript.scm and stumpwm to wm.scm. * gnu/packages/javascript.scm: Add uglify-js. * gnu/packages/wm.scm: Add stumpwm. * gnu/packages/bioinformatics.scm: Find uglify-js in javascript.scm. * gnu/packages/machine-learning.scm: Depend on lisp-xyz.scm instead of lisp.scm. * gnu/packages/web.scm: Find uglify-js in javascript.scm. * gnu/packages/web-browsers.scm: Depend on lisp-xyz.scm instead of lisp.scm.
Diffstat (limited to 'gnu')
-rw-r--r--gnu/local.mk1
-rw-r--r--gnu/packages/bioinformatics.scm2
-rw-r--r--gnu/packages/cran.scm1
-rw-r--r--gnu/packages/javascript.scm48
-rw-r--r--gnu/packages/lisp-xyz.scm7205
-rw-r--r--gnu/packages/lisp.scm7323
-rw-r--r--gnu/packages/machine-learning.scm2
-rw-r--r--gnu/packages/web-browsers.scm1
-rw-r--r--gnu/packages/web.scm2
-rw-r--r--gnu/packages/wm.scm121
10 files changed, 7385 insertions, 7321 deletions
diff --git a/gnu/local.mk b/gnu/local.mk
index a49c9109ab..2e633a7d7a 100644
--- a/gnu/local.mk
+++ b/gnu/local.mk
@@ -308,6 +308,7 @@ GNU_SYSTEM_MODULES = \
%D%/packages/linux.scm \
%D%/packages/lirc.scm \
%D%/packages/lisp.scm \
+ %D%/packages/lisp-xyz.scm \
%D%/packages/llvm.scm \
%D%/packages/lout.scm \
%D%/packages/logging.scm \
diff --git a/gnu/packages/bioinformatics.scm b/gnu/packages/bioinformatics.scm
index 616fcedc35..901ebe23b7 100644
--- a/gnu/packages/bioinformatics.scm
+++ b/gnu/packages/bioinformatics.scm
@@ -84,10 +84,10 @@
#:use-module (gnu packages imagemagick)
#:use-module (gnu packages java)
#:use-module (gnu packages java-compression)
+ #:use-module (gnu packages javascript)
#:use-module (gnu packages jemalloc)
#:use-module (gnu packages dlang)
#:use-module (gnu packages linux)
- #:use-module (gnu packages lisp)
#:use-module (gnu packages logging)
#:use-module (gnu packages machine-learning)
#:use-module (gnu packages man)
diff --git a/gnu/packages/cran.scm b/gnu/packages/cran.scm
index 7761135b28..9ac5ef8e8a 100644
--- a/gnu/packages/cran.scm
+++ b/gnu/packages/cran.scm
@@ -62,7 +62,6 @@
#:use-module (gnu packages imagemagick)
#:use-module (gnu packages java)
#:use-module (gnu packages javascript)
- #:use-module (gnu packages lisp)
#:use-module (gnu packages machine-learning)
#:use-module (gnu packages maths)
#:use-module (gnu packages mpi)
diff --git a/gnu/packages/javascript.scm b/gnu/packages/javascript.scm
index 0e33f889b8..6718274da2 100644
--- a/gnu/packages/javascript.scm
+++ b/gnu/packages/javascript.scm
@@ -26,6 +26,7 @@
#:use-module (gnu packages base)
#:use-module (gnu packages compression)
#:use-module (gnu packages lisp)
+ #:use-module (gnu packages lisp-xyz)
#:use-module (gnu packages readline)
#:use-module (guix packages)
#:use-module (guix download)
@@ -452,3 +453,50 @@ to use, and is very similar to Lua. There is no need to interact with byzantine
C++ template mechanisms, or worry about marking and unmarking garbage collection
roots, or wrestle with obscure build systems.")
(license license:isc)))
+
+(define-public uglify-js
+ (package
+ (inherit sbcl-cl-uglify-js)
+ (name "uglify-js")
+ (build-system trivial-build-system)
+ (arguments
+ `(#:modules ((guix build utils))
+ #:builder
+ (let* ((bin (string-append (assoc-ref %outputs "out") "/bin/"))
+ (script (string-append bin "uglify-js")))
+ (use-modules (guix build utils))
+ (mkdir-p bin)
+ (with-output-to-file script
+ (lambda _
+ (format #t "#!~a/bin/sbcl --script
+ (require :asdf)
+ (push (truename \"~a/lib/sbcl\") asdf:*central-registry*)"
+ (assoc-ref %build-inputs "sbcl")
+ (assoc-ref %build-inputs "sbcl-cl-uglify-js"))
+ ;; FIXME: cannot use progn here because otherwise it fails to
+ ;; find cl-uglify-js.
+ (for-each
+ write
+ '(;; Quiet, please!
+ (let ((*standard-output* (make-broadcast-stream))
+ (*error-output* (make-broadcast-stream)))
+ (asdf:load-system :cl-uglify-js))
+ (let ((file (cadr *posix-argv*)))
+ (if file
+ (format t "~a"
+ (cl-uglify-js:ast-gen-code
+ (cl-uglify-js:ast-mangle
+ (cl-uglify-js:ast-squeeze
+ (with-open-file (in file)
+ (parse-js:parse-js in))))
+ :beautify nil))
+ (progn
+ (format *error-output*
+ "Please provide a JavaScript file.~%")
+ (sb-ext:exit :code 1))))))))
+ (chmod script #o755)
+ #t)))
+ (inputs
+ `(("sbcl" ,sbcl)
+ ("sbcl-cl-uglify-js" ,sbcl-cl-uglify-js)))
+ (synopsis "JavaScript compressor")))
diff --git a/gnu/packages/lisp-xyz.scm b/gnu/packages/lisp-xyz.scm
new file mode 100644
index 0000000000..1f60e22150
--- /dev/null
+++ b/gnu/packages/lisp-xyz.scm
@@ -0,0 +1,7205 @@
+;;; GNU Guix --- Functional package management for GNU
+;;; Copyright © 2014 John Darrington <jmd@gnu.org>
+;;; Copyright © 2015 Taylan Ulrich Bayırlı/Kammer <taylanbayirli@gmail.com>
+;;; Copyright © 2015 Mark H Weaver <mhw@netris.org>
+;;; Copyright © 2016 Federico Beffa <beffa@fbengineering.ch>
+;;; Copyright © 2016, 2017 ng0 <ng0@n0.is>
+;;; Copyright © 2016, 2017 Andy Patterson <ajpatter@uwaterloo.ca>
+;;; Copyright © 2017, 2019 Ricardo Wurmus <rekado@elephly.net>
+;;; Copyright © 2017, 2018, 2019 Efraim Flashner <efraim@flashner.co.il>
+;;; Copyright © 2017, 2019 Tobias Geerinckx-Rice <me@tobias.gr>
+;;; Copyright © 2018 Benjamin Slade <slade@jnanam.net>
+;;; Copyright © 2018 Alex Vong <alexvong1995@gmail.com>
+;;; Copyright © 2018 Pierre Neidhardt <mail@ambrevar.xyz>
+;;; Copyright © 2018, 2019 Pierre Langlois <pierre.langlois@gmx.com>
+;;; Copyright © 2019 Katherine Cox-Buday <cox.katherine.e@gmail.com>
+;;; Copyright © 2019 Jesse Gildersleve <jessejohngildersleve@protonmail.com>
+;;; Copyright © 2019 Guillaume Le Vaillant <glv@posteo.net>
+;;;
+;;; This file is part of GNU Guix.
+;;;
+;;; GNU Guix is free software; you can redistribute it and/or modify it
+;;; under the terms of the GNU General Public License as published by
+;;; the Free Software Foundation; either version 3 of the License, or (at
+;;; your option) any later version.
+;;;
+;;; GNU Guix is distributed in the hope that it will be useful, but
+;;; WITHOUT ANY WARRANTY; without even the implied warranty of
+;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;;; GNU General Public License for more details.
+;;;
+;;; You should have received a copy of the GNU General Public License
+;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>.
+
+;;; This file only contains Common Lisp libraries.
+;;; Common Lisp compilers and tooling go to lisp.scm.
+;;; Common Lisp applications should go to the most appropriate file,
+;;; e.g. StumpWM is in wm.scm.
+
+(define-module (gnu packages lisp-xyz)
+ #:use-module (gnu packages)
+ #:use-module ((guix licenses) #:prefix license:)
+ #:use-module (guix packages)
+ #:use-module (guix download)
+ #:use-module (guix git-download)
+ #:use-module (guix hg-download)
+ #:use-module (guix utils)
+ #:use-module (guix build-system asdf)
+ #:use-module (guix build-system trivial)
+ #:use-module (gnu packages c)
+ #:use-module (gnu packages compression)
+ #:use-module (gnu packages glib)
+ #:use-module (gnu packages gtk)
+ #:use-module (gnu packages libffi)
+ #:use-module (gnu packages lisp)
+ #:use-module (gnu packages pkg-config)
+ #:use-module (gnu packages python)
+ #:use-module (gnu packages python-xyz)
+ #:use-module (gnu packages sqlite)
+ #:use-module (gnu packages tls)
+ #:use-module (gnu packages webkit)
+ #:use-module (gnu packages xdisorg)
+ #:use-module (ice-9 match)
+ #:use-module (srfi srfi-19))
+
+(define-public sbcl-alexandria
+ (let ((revision "1")
+ (commit "3b849bc0116ea70f215ee6b2fbf354e862aaa9dd"))
+ (package
+ (name "sbcl-alexandria")
+ (version (git-version "1.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://gitlab.common-lisp.net/alexandria/alexandria.git")
+ (commit commit)))
+ (sha256
+ (base32
+ "04amwvx2vl691f0plcfbqqwxgib9zimih7jrn5zl7mbwvrxy022b"))
+ (file-name (git-file-name name version))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("rt" ,sbcl-rt)))
+ (synopsis "Collection of portable utilities for Common Lisp")
+ (description
+ "Alexandria is a collection of portable utilities. It does not contain
+conceptual extensions to Common Lisp. It is conservative in scope, and
+portable between implementations.")
+ (home-page "https://common-lisp.net/project/alexandria/")
+ (license license:public-domain))))
+
+(define-public cl-alexandria
+ (sbcl-package->cl-source-package sbcl-alexandria))
+
+(define-public ecl-alexandria
+ (sbcl-package->ecl-package sbcl-alexandria))
+
+(define-public sbcl-net.didierverna.asdf-flv
+ (package
+ (name "sbcl-net.didierverna.asdf-flv")
+ (version "2.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/didierverna/asdf-flv")
+ (commit (string-append "version-" version))))
+ (file-name (git-file-name "asdf-flv" version))
+ (sha256
+ (base32 "1fi2y4baxan103jbg4idjddzihy03kwnj2mzbwrknw4d4x7xlgwj"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Common Lisp ASDF extension to provide support for file-local variables")
+ (description "ASDF-FLV provides support for file-local variables through
+ASDF. A file-local variable behaves like @code{*PACKAGE*} and
+@code{*READTABLE*} with respect to @code{LOAD} and @code{COMPILE-FILE}: a new
+dynamic binding is created before processing the file, so that any
+modification to the variable becomes essentially file-local.
+
+In order to make one or several variables file-local, use the macros
+@code{SET-FILE-LOCAL-VARIABLE(S)}.")
+ (home-page "https://www.lrde.epita.fr/~didier/software/lisp/misc.php#asdf-flv")
+ (license (license:non-copyleft
+ "https://www.gnu.org/prep/maintain/html_node/License-Notices-for-Other-Files.html"
+ "GNU All-Permissive License"))))
+
+(define-public cl-net.didierverna.asdf-flv
+ (sbcl-package->cl-source-package sbcl-net.didierverna.asdf-flv))
+
+(define-public ecl-net.didierverna.asdf-flv
+ (sbcl-package->ecl-package sbcl-net.didierverna.asdf-flv))
+
+(define-public sbcl-fiveam
+ (package
+ (name "sbcl-fiveam")
+ (version "1.4.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sionescu/fiveam.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "fiveam" version))
+ (sha256
+ (base32 "1q3d38pwafnwnw42clq0f8g5xw7pbzr287jl9jsqmb1vb0n1vrli"))))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("net.didierverna.asdf-flv" ,sbcl-net.didierverna.asdf-flv)
+ ("trivial-backtrace" ,sbcl-trivial-backtrace)))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Common Lisp testing framework")
+ (description "FiveAM is a simple (as far as writing and running tests
+goes) regression testing framework. It has been designed with Common Lisp's
+interactive development model in mind.")
+ (home-page "https://common-lisp.net/project/fiveam/")
+ (license license:bsd-3)))
+
+(define-public cl-fiveam
+ (sbcl-package->cl-source-package sbcl-fiveam))
+
+(define-public ecl-fiveam
+ (sbcl-package->ecl-package sbcl-fiveam))
+
+(define-public sbcl-bordeaux-threads
+ (let ((commit "5dce49fbc829f4d136a734f5ef4f5d599660984f")
+ (revision "1"))
+ (package
+ (name "sbcl-bordeaux-threads")
+ (version (git-version "0.8.6" revision commit))
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sionescu/bordeaux-threads.git")
+ (commit commit)))
+ (sha256
+ (base32 "1gkh9rz7zw57n3110ikcf4835950wr4hgp8l79id5ai6nd86x7wv"))
+ (file-name
+ (git-file-name "bordeaux-threads" version))))
+ (inputs `(("alexandria" ,sbcl-alexandria)))
+ (native-inputs `(("fiveam" ,sbcl-fiveam)))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Portable shared-state concurrency library for Common Lisp")
+ (description "BORDEAUX-THREADS is a proposed standard for a minimal
+MP/Threading interface. It is similar to the CLIM-SYS threading and lock
+support.")
+ (home-page "https://common-lisp.net/project/bordeaux-threads/")
+ (license license:x11))))
+
+(define-public cl-bordeaux-threads
+ (sbcl-package->cl-source-package sbcl-bordeaux-threads))
+
+(define-public ecl-bordeaux-threads
+ (sbcl-package->ecl-package sbcl-bordeaux-threads))
+
+(define-public sbcl-trivial-gray-streams
+ (let ((revision "1")
+ (commit "0483ade330508b4b2edeabdb47d16ec9437ee1cb"))
+ (package
+ (name "sbcl-trivial-gray-streams")
+ (version (string-append "0.0.0-" revision "." (string-take commit 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri
+ (git-reference
+ (url "https://github.com/trivial-gray-streams/trivial-gray-streams.git")
+ (commit commit)))
+ (sha256
+ (base32 "0m3rpf2x0zmdk3nf1qfa01j6a55vj7gkwhyw78qslcgbjlgh8p4d"))
+ (file-name
+ (string-append "trivial-gray-streams-" version "-checkout"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Compatibility layer for Gray streams implementations")
+ (description "Gray streams is an interface proposed for inclusion with
+ANSI CL by David N. Gray. The proposal did not make it into ANSI CL, but most
+popular CL implementations implement it. This package provides an extremely
+thin compatibility layer for gray streams.")
+ (home-page "http://www.cliki.net/trivial-gray-streams")
+ (license license:x11))))
+
+(define-public cl-trivial-gray-streams
+ (sbcl-package->cl-source-package sbcl-trivial-gray-streams))
+
+(define-public ecl-trivial-gray-streams
+ (sbcl-package->ecl-package sbcl-trivial-gray-streams))
+
+(define-public sbcl-fiasco
+ (let ((commit "d62f7558b21addc89f87e306f65d7f760632655f")
+ (revision "1"))
+ (package
+ (name "sbcl-fiasco")
+ (version (git-version "0.0.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/joaotavora/fiasco.git")
+ (commit commit)))
+ (file-name (git-file-name "fiasco" version))
+ (sha256
+ (base32
+ "1zwxs3d6iswayavcmb49z2892xhym7n556d8dnmvalc32pm9bkjh"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
+ (synopsis "Simple and powerful test framework for Common Lisp")
+ (description "A Common Lisp test framework that treasures your failures,
+logical continuation of Stefil. It focuses on interactive debugging.")
+ (home-page "https://github.com/joaotavora/fiasco")
+ ;; LICENCE specifies this is public-domain unless the legislation
+ ;; doesn't allow or recognize it. In that case it falls back to a
+ ;; permissive licence.
+ (license (list license:public-domain
+ (license:x11-style "file://LICENCE"))))))
+
+(define-public cl-fiasco
+ (sbcl-package->cl-source-package sbcl-fiasco))
+
+(define-public ecl-fiasco
+ (sbcl-package->ecl-package sbcl-fiasco))
+
+(define-public sbcl-flexi-streams
+ (package
+ (name "sbcl-flexi-streams")
+ (version "1.0.16")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/edicl/flexi-streams.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "flexi-streams" version))
+ (sha256
+ (base32 "0gvykjlmja060zqq6nn6aqxlshh6r6ijahmmgf20q0d839rwpgxc"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'make-git-checkout-writable
+ (lambda _
+ (for-each make-file-writable (find-files "."))
+ #t)))))
+ (inputs `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
+ (synopsis "Implementation of virtual bivalent streams for Common Lisp")
+ (description "Flexi-streams is an implementation of \"virtual\" bivalent
+streams that can be layered atop real binary or bivalent streams and that can
+be used to read and write character data in various single- or multi-octet
+encodings which can be changed on the fly. It also supplies in-memory binary
+streams which are similar to string streams.")
+ (home-page "http://weitz.de/flexi-streams/")
+ (license license:bsd-3)))
+
+(define-public cl-flexi-streams
+ (sbcl-package->cl-source-package sbcl-flexi-streams))
+
+(define-public ecl-flexi-streams
+ (sbcl-package->ecl-package sbcl-flexi-streams))
+
+(define-public sbcl-cl-ppcre
+ (package
+ (name "sbcl-cl-ppcre")
+ (version "2.0.11")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/edicl/cl-ppcre.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-ppcre" version))
+ (sha256
+ (base32 "0q3iany07vgqm144lw6pj0af2d3vsikpbkwcxr30fci3kzsq4f49"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs `(("flexi-streams" ,sbcl-flexi-streams)))
+ (synopsis "Portable regular expression library for Common Lisp")
+ (description "CL-PPCRE is a portable regular expression library for Common
+Lisp, which is compatible with perl. It is pretty fast, thread-safe, and
+compatible with ANSI-compliant Common Lisp implementations.")
+ (home-page "http://weitz.de/cl-ppcre/")
+ (license license:bsd-2)))
+
+(define-public cl-ppcre
+ (sbcl-package->cl-source-package sbcl-cl-ppcre))
+
+(define-public ecl-cl-ppcre
+ (sbcl-package->ecl-package sbcl-cl-ppcre))
+
+(define sbcl-cl-unicode-base
+ (let ((revision "1")
+ (commit "9fcd06fba1ddc9e66aed2f2d6c32dc9b764f03ea"))
+ (package
+ (name "sbcl-cl-unicode-base")
+ (version (string-append "0.1.5-" revision "." (string-take commit 7)))
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/edicl/cl-unicode.git")
+ (commit commit)))
+ (file-name (string-append "cl-unicode-" version "-checkout"))
+ (sha256
+ (base32
+ "1jicprb5b3bv57dy1kg03572gxkcaqdjhak00426s76g0plmx5ki"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-file "cl-unicode.asd"
+ #:asd-system-name "cl-unicode/base"))
+ (inputs
+ `(("cl-ppcre" ,sbcl-cl-ppcre)))
+ (home-page "http://weitz.de/cl-unicode/")
+ (synopsis "Portable Unicode library for Common Lisp")
+ (description "CL-UNICODE is a portable Unicode library Common Lisp, which
+is compatible with perl. It is pretty fast, thread-safe, and compatible with
+ANSI-compliant Common Lisp implementations.")
+ (license license:bsd-2))))
+
+(define-public sbcl-cl-unicode
+ (package
+ (inherit sbcl-cl-unicode-base)
+ (name "sbcl-cl-unicode")
+ (inputs
+ `(("cl-unicode/base" ,sbcl-cl-unicode-base)
+ ,@(package-inputs sbcl-cl-unicode-base)))
+ (native-inputs
+ `(("flexi-streams" ,sbcl-flexi-streams)))
+ (arguments '())))
+
+(define-public ecl-cl-unicode
+ (sbcl-package->ecl-package sbcl-cl-unicode))
+
+(define-public cl-unicode
+ (sbcl-package->cl-source-package sbcl-cl-unicode))
+
+(define-public sbcl-clx
+ (package
+ (name "sbcl-clx")
+ (version "0.7.5")
+ (source
+ (origin
+ (method git-fetch)
+ (uri
+ (git-reference
+ (url "https://github.com/sharplispers/clx.git")
+ (commit version)))
+ (sha256
+ (base32
+ "1vi67z9hpj5rr4xcmfbfwzmlcc0ah7hzhrmfid6lqdkva238v2wf"))
+ (file-name (string-append "clx-" version))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("fiasco" ,sbcl-fiasco)))
+ (home-page "http://www.cliki.net/portable-clx")
+ (synopsis "X11 client library for Common Lisp")
+ (description "CLX is an X11 client library for Common Lisp. The code was
+originally taken from a CMUCL distribution, was modified somewhat in order to
+make it compile and run under SBCL, then a selection of patches were added
+from other CLXes around the net.")
+ (license license:x11)))
+
+(define-public cl-clx
+ (sbcl-package->cl-source-package sbcl-clx))
+
+(define-public ecl-clx
+ (sbcl-package->ecl-package sbcl-clx))
+
+(define-public sbcl-cl-ppcre-unicode
+ (package (inherit sbcl-cl-ppcre)
+ (name "sbcl-cl-ppcre-unicode")
+ (arguments
+ `(#:tests? #f ; tests fail with "Component :CL-PPCRE-TEST not found"
+ #:asd-file "cl-ppcre-unicode.asd"))
+ (inputs
+ `(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
+ ("sbcl-cl-unicode" ,sbcl-cl-unicode)))))
+
+;; The slynk that users expect to install includes all of slynk's contrib
+;; modules. Therefore, we build the base module and all contribs first; then
+;; we expose the union of these as `sbcl-slynk'. The following variable
+;; describes the base module.
+(define sbcl-slynk-boot0
+ (let ((revision "2")
+ (commit "cbf84c36c4eca8b032e3fd16177a7bc02df3ec4c"))
+ (package
+ (name "sbcl-slynk-boot0")
+ (version (string-append "1.0.0-beta-" revision "." (string-take commit 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri
+ (git-reference
+ (url "https://github.com/joaotavora/sly.git")
+ (commit commit)))
+ (sha256
+ (base32 "13dyhsravn591p7g6is01mp2ynzjnnj7pwgi57r6xqmd4611y9vh"))
+ (file-name (string-append "slynk-" version "-checkout"))
+ (modules '((guix build utils)
+ (ice-9 ftw)))
+ (snippet
+ '(begin
+ ;; Move the contribs into the main source directory for easier
+ ;; access
+ (substitute* "slynk/slynk.asd"
+ (("\\.\\./contrib")
+ "contrib")
+ (("\\(defsystem :slynk/util")
+ "(defsystem :slynk/util :depends-on (:slynk)")
+ ((":depends-on \\(:slynk :slynk/util\\)")
+ ":depends-on (:slynk :slynk-util)"))
+ (substitute* "contrib/slynk-trace-dialog.lisp"
+ (("\\(slynk::reset-inspector\\)") ; Causes problems on load
+ "nil"))
+ (substitute* "contrib/slynk-profiler.lisp"
+ (("slynk:to-line")
+ "slynk-pprint-to-line"))
+ (substitute* "contrib/slynk-fancy-inspector.lisp"
+ (("slynk/util") "slynk-util")
+ ((":compile-toplevel :load-toplevel") ""))
+ (rename-file "contrib" "slynk/contrib")
+ ;; Move slynk's contents into the base directory for easier
+ ;; access
+ (for-each (lambda (file)
+ (unless (string-prefix? "." file)
+ (rename-file (string-append "slynk/" file)
+ (string-append "./" (basename file)))))
+ (scandir "slynk"))
+ #t))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:tests? #f ; No test suite
+ #:asd-system-name "slynk"))
+ (synopsis "Common Lisp IDE for Emacs")
+ (description "SLY is a fork of SLIME, an IDE backend for Common Lisp.
+It also features a completely redesigned REPL based on Emacs's own
+full-featured comint.el, live code annotations, and a consistent interactive
+button interface. Everything can be copied to the REPL. One can create
+multiple inspectors with independent history.")
+ (home-page "https://github.com/joaotavora/sly")
+ (license license:public-domain)
+ (properties `((cl-source-variant . ,(delay cl-slynk)))))))
+
+(define-public cl-slynk
+ (package
+ (inherit (sbcl-package->cl-source-package sbcl-slynk-boot0))
+ (name "cl-slynk")))
+
+(define ecl-slynk-boot0
+ (sbcl-package->ecl-package sbcl-slynk-boot0))
+
+(define sbcl-slynk-arglists
+ (package
+ (inherit sbcl-slynk-boot0)
+ (name "sbcl-slynk-arglists")
+ (inputs `(("slynk" ,sbcl-slynk-boot0)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-slynk-boot0)
+ ((#:asd-file _ "") "slynk.asd")
+ ((#:asd-system-name _ #f) "slynk/arglists")))))
+
+(define ecl-slynk-arglists
+ (sbcl-package->ecl-package sbcl-slynk-arglists))
+
+(define sbcl-slynk-util
+ (package
+ (inherit sbcl-slynk-boot0)
+ (name "sbcl-slynk-util")
+ (inputs `(("slynk" ,sbcl-slynk-boot0)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-slynk-boot0)
+ ((#:asd-file _ "") "slynk.asd")
+ ((#:asd-system-name _ #f) "slynk/util")))))
+
+(define ecl-slynk-util
+ (sbcl-package->ecl-package sbcl-slynk-util))
+
+(define sbcl-slynk-fancy-inspector
+ (package
+ (inherit sbcl-slynk-arglists)
+ (name "sbcl-slynk-fancy-inspector")
+ (inputs `(("slynk-util" ,sbcl-slynk-util)
+ ,@(package-inputs sbcl-slynk-arglists)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
+ ((#:asd-system-name _ #f) "slynk/fancy-inspector")))))
+
+(define ecl-slynk-fancy-inspector
+ (sbcl-package->ecl-package sbcl-slynk-fancy-inspector))
+
+(define sbcl-slynk-package-fu
+ (package
+ (inherit sbcl-slynk-arglists)
+ (name "sbcl-slynk-package-fu")
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
+ ((#:asd-system-name _ #f) "slynk/package-fu")))))
+
+(define ecl-slynk-package-fu
+ (sbcl-package->ecl-package sbcl-slynk-package-fu))
+
+(define sbcl-slynk-mrepl
+ (package
+ (inherit sbcl-slynk-fancy-inspector)
+ (name "sbcl-slynk-mrepl")
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
+ ((#:asd-system-name _ #f) "slynk/mrepl")))))
+
+(define ecl-slynk-mrepl
+ (sbcl-package->ecl-package sbcl-slynk-mrepl))
+
+(define sbcl-slynk-trace-dialog
+ (package
+ (inherit sbcl-slynk-arglists)
+ (name "sbcl-slynk-trace-dialog")
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
+ ((#:asd-system-name _ #f) "slynk/trace-dialog")))))
+
+(define ecl-slynk-trace-dialog
+ (sbcl-package->ecl-package sbcl-slynk-trace-dialog))
+
+(define sbcl-slynk-profiler
+ (package
+ (inherit sbcl-slynk-arglists)
+ (name "sbcl-slynk-profiler")
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
+ ((#:asd-system-name _ #f) "slynk/profiler")))))
+
+(define ecl-slynk-profiler
+ (sbcl-package->ecl-package sbcl-slynk-profiler))
+
+(define sbcl-slynk-stickers
+ (package
+ (inherit sbcl-slynk-arglists)
+ (name "sbcl-slynk-stickers")
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
+ ((#:asd-system-name _ #f) "slynk/stickers")))))
+
+(define ecl-slynk-stickers
+ (sbcl-package->ecl-package sbcl-slynk-stickers))
+
+(define sbcl-slynk-indentation
+ (package
+ (inherit sbcl-slynk-arglists)
+ (name "sbcl-slynk-indentation")
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
+ ((#:asd-system-name _ #f) "slynk/indentation")))))
+
+(define ecl-slynk-indentation
+ (sbcl-package->ecl-package sbcl-slynk-indentation))
+
+(define sbcl-slynk-retro
+ (package
+ (inherit sbcl-slynk-arglists)
+ (name "sbcl-slynk-retro")
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
+ ((#:asd-system-name _ #f) "slynk/retro")))))
+
+(define ecl-slynk-retro
+ (sbcl-package->ecl-package sbcl-slynk-retro))
+
+(define slynk-systems
+ '("slynk"
+ "slynk-util"
+ "slynk-arglists"
+ "slynk-fancy-inspector"
+ "slynk-package-fu"
+ "slynk-mrepl"
+ "slynk-profiler"
+ "slynk-trace-dialog"
+ "slynk-stickers"
+ "slynk-indentation"
+ "slynk-retro"))
+
+(define-public sbcl-slynk
+ (package
+ (inherit sbcl-slynk-boot0)
+ (name "sbcl-slynk")
+ (inputs
+ `(("slynk" ,sbcl-slynk-boot0)
+ ("slynk-util" ,sbcl-slynk-util)
+ ("slynk-arglists" ,sbcl-slynk-arglists)
+ ("slynk-fancy-inspector" ,sbcl-slynk-fancy-inspector)
+ ("slynk-package-fu" ,sbcl-slynk-package-fu)
+ ("slynk-mrepl" ,sbcl-slynk-mrepl)
+ ("slynk-profiler" ,sbcl-slynk-profiler)
+ ("slynk-trace-dialog" ,sbcl-slynk-trace-dialog)
+ ("slynk-stickers" ,sbcl-slynk-stickers)
+ ("slynk-indentation" ,sbcl-slynk-indentation)
+ ("slynk-retro" ,sbcl-slynk-retro)))
+ (native-inputs `(("sbcl" ,sbcl)))
+ (build-system trivial-build-system)
+ (source #f)
+ (outputs '("out" "image"))
+ (arguments
+ `(#:modules ((guix build union)
+ (guix build utils)
+ (guix build lisp-utils))
+ #:builder
+ (begin
+ (use-modules (ice-9 match)
+ (srfi srfi-1)
+ (guix build union)
+ (guix build lisp-utils))
+
+ (union-build
+ (assoc-ref %outputs "out")
+ (filter-map
+ (match-lambda
+ ((name . path)
+ (if (string-prefix? "slynk" name) path #f)))
+ %build-inputs))
+
+ (prepend-to-source-registry
+ (string-append (assoc-ref %outputs "out") "//"))
+
+ (parameterize ((%lisp-type "sbcl")
+ (%lisp (string-append (assoc-ref %build-inputs "sbcl")
+ "/bin/sbcl")))
+ (build-image (string-append
+ (assoc-ref %outputs "image")
+ "/bin/slynk")
+ %outputs
+ #:dependencies ',slynk-systems))
+ #t)))))
+
+(define-public ecl-slynk
+ (package
+ (inherit sbcl-slynk)
+ (name "ecl-slynk")
+ (inputs
+ (map (match-lambda
+ ((name pkg . _)
+ (list name (sbcl-package->ecl-package pkg))))
+ (package-inputs sbcl-slynk)))
+ (native-inputs '())
+ (outputs '("out"))
+ (arguments
+ '(#:modules ((guix build union))
+ #:builder
+ (begin
+ (use-modules (ice-9 match)
+ (guix build union))
+ (match %build-inputs
+ (((names . paths) ...)
+ (union-build (assoc-ref %outputs "out")
+ paths)
+ #t)))))))
+
+(define-public sbcl-parse-js
+ (let ((commit "fbadc6029bec7039602abfc06c73bb52970998f6")
+ (revision "1"))
+ (package
+ (name "sbcl-parse-js")
+ (version (string-append "0.0.0-" revision "." (string-take commit 9)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "http://marijn.haverbeke.nl/git/parse-js")
+ (commit commit)))
+ (file-name (string-append name "-" commit "-checkout"))
+ (sha256
+ (base32
+ "1wddrnr5kiya5s3gp4cdq6crbfy9fqcz7fr44p81502sj3bvdv39"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "http://marijnhaverbeke.nl/parse-js/")
+ (synopsis "Parse JavaScript")
+ (description "Parse-js is a Common Lisp package for parsing
+JavaScript (ECMAScript 3). It has basic support for ECMAScript 5.")
+ (license license:zlib))))
+
+(define-public cl-parse-js
+ (sbcl-package->cl-source-package sbcl-parse-js))
+
+(define-public sbcl-parse-number
+ (package
+ (name "sbcl-parse-number")
+ (version "1.7")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sharplispers/parse-number/")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0sk06ib1bhqv9y39vwnnw44vmbc4b0kvqm37xxmkxd4dwchq82d7"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "http://www.cliki.net/PARSE-NUMBER")
+ (synopsis "Parse numbers")
+ (description "@code{parse-number} is a library of functions for parsing
+strings into one of the standard Common Lisp number types without using the
+reader. @code{parse-number} accepts an arbitrary string and attempts to parse
+the string into one of the standard Common Lisp number types, if possible, or
+else @code{parse-number} signals an error of type @code{invalid-number}.")
+ (license license:bsd-3)))
+
+(define-public cl-parse-number
+ (sbcl-package->cl-source-package sbcl-parse-number))
+
+(define-public sbcl-iterate
+ (package
+ (name "sbcl-iterate")
+ ;; The latest official release (1.4.3) fails to build so we have to take
+ ;; the current darcs tarball from quicklisp.
+ (version "20160825")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "http://beta.quicklisp.org/archive/iterate/"
+ "2016-08-25/iterate-"
+ version "-darcs.tgz"))
+ (sha256
+ (base32
+ "0kvz16gnxnkdz0fy1x8y5yr28nfm7i2qpvix7mgwccdpjmsb4pgm"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("rt" ,sbcl-rt)))
+ (home-page "https://common-lisp.net/project/iterate/")
+ (synopsis "Iteration construct for Common Lisp")
+ (description "@code{iterate} is an iteration construct for Common Lisp.
+It is similar to the @code{CL:LOOP} macro, with these distinguishing marks:
+
+@itemize
+@item it is extensible,
+@item it helps editors like Emacs indent iterate forms by having a more
+ lisp-like syntax, and
+@item it isn't part of the ANSI standard for Common Lisp.
+@end itemize\n")
+ (license license:expat)))
+
+(define-public cl-iterate
+ (sbcl-package->cl-source-package sbcl-iterate))
+
+(define-public ecl-iterate
+ (sbcl-package->ecl-package sbcl-iterate))
+
+(define-public sbcl-cl-uglify-js
+ ;; There have been many bug fixes since the 2010 release.
+ (let ((commit "429c5e1d844e2f96b44db8fccc92d6e8e28afdd5")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-uglify-js")
+ (version (string-append "0.1-" revision "." (string-take commit 9)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/mishoo/cl-uglify-js.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0k39y3c93jgxpr7gwz7w0d8yknn1fdnxrjhd03057lvk5w8js27a"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("sbcl-parse-js" ,sbcl-parse-js)
+ ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
+ ("sbcl-cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
+ ("sbcl-parse-number" ,sbcl-parse-number)
+ ("sbcl-iterate" ,sbcl-iterate)))
+ (home-page "https://github.com/mishoo/cl-uglify-js")
+ (synopsis "JavaScript compressor library for Common Lisp")
+ (description "This is a Common Lisp version of UglifyJS, a JavaScript
+compressor. It works on data produced by @code{parse-js} to generate a
+@dfn{minified} version of the code. Currently it can:
+
+@itemize
+@item reduce variable names (usually to single letters)
+@item join consecutive @code{var} statements
+@item resolve simple binary expressions
+@item group most consecutive statements using the @code{sequence} operator (comma)
+@item remove unnecessary blocks
+@item convert @code{IF} expressions in various ways that result in smaller code
+@item remove some unreachable code
+@end itemize\n")
+ (license license:zlib))))
+
+(define-public cl-uglify-js
+ (sbcl-package->cl-source-package sbcl-cl-uglify-js))
+
+(define-public sbcl-cl-strings
+ (let ((revision "1")
+ (commit "c5c5cbafbf3e6181d03c354d66e41a4f063f00ae"))
+ (package
+ (name "sbcl-cl-strings")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/diogoalexandrefranco/cl-strings")
+ (commit commit)))
+ (sha256
+ (base32
+ "00754mfaqallj480lwd346nkfb6ra8pa8xcxcylf4baqn604zlmv"))
+ (file-name (string-append "cl-strings-" version "-checkout"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Portable, dependency-free set of utilities to manipulate strings in Common Lisp")
+ (description
+ "@command{cl-strings} is a small, portable, dependency-free set of
+utilities that make it even easier to manipulate text in Common Lisp. It has
+100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.")
+ (home-page "https://github.com/diogoalexandrefranco/cl-strings")
+ (license license:expat))))
+
+(define-public cl-strings
+ (sbcl-package->cl-source-package sbcl-cl-strings))
+
+(define-public ecl-cl-strings
+ (sbcl-package->ecl-package sbcl-cl-strings))
+
+(define-public sbcl-trivial-features
+ (package
+ (name "sbcl-trivial-features")
+ (version "0.8")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/trivial-features/trivial-features.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "trivial-features" version))
+ (sha256
+ (base32 "0ccv7dqyrk55xga78i5vzlic7mdwp28in3g1a8fqhlk6626scsq9"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments '(#:tests? #f))
+ (home-page "http://cliki.net/trivial-features")
+ (synopsis "Ensures consistency of @code{*FEATURES*} in Common Lisp")
+ (description "Trivial-features ensures that @code{*FEATURES*} is
+consistent across multiple Common Lisp implementations.")
+ (license license:expat)))
+
+(define-public cl-trivial-features
+ (sbcl-package->cl-source-package sbcl-trivial-features))
+
+(define-public ecl-trivial-features
+ (sbcl-package->ecl-package sbcl-trivial-features))
+
+(define-public sbcl-hu.dwim.asdf
+ (package
+ (name "sbcl-hu.dwim.asdf")
+ (version "20190521")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "http://beta.quicklisp.org/archive/hu.dwim.asdf/"
+ "2019-05-21/hu.dwim.asdf-" version "-darcs.tgz"))
+ (sha256
+ (base32
+ "0rsbv71vyszy8w35yjwb5h6zcmknjq223hkzir79y72qdsc6sabn"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://hub.darcs.net/hu.dwim/hu.dwim.asdf")
+ (synopsis "Extensions to ASDF")
+ (description "Various ASDF extensions such as attached test and
+documentation system, explicit development support, etc.")
+ (license license:public-domain)))
+
+(define-public cl-hu.dwim.asdf
+ (sbcl-package->cl-source-package sbcl-hu.dwim.asdf))
+
+(define-public ecl-hu.dwim.asdf
+ (sbcl-package->ecl-package sbcl-hu.dwim.asdf))
+
+(define-public sbcl-hu.dwim.stefil
+ (let ((commit "ab6d1aa8995878a1b66d745dfd0ba021090bbcf9"))
+ (package
+ (name "sbcl-hu.dwim.stefil")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri
+ (git-reference
+ (url "https://gitlab.common-lisp.net/xcvb/hu.dwim.stefil.git")
+ (commit commit)))
+ (sha256
+ (base32 "1d8yccw65zj3zh46cbi3x6nmn1dwdb76s9d0av035077mvyirqqp"))
+ (file-name (git-file-name "hu.dwim.stefil" version))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("asdf:cl-hu.dwim.asdf" ,sbcl-hu.dwim.asdf)))
+ (inputs
+ `(("sbcl-alexandria" ,sbcl-alexandria)))
+ (home-page "https://hub.darcs.net/hu.dwim/hu.dwim.stefil")
+ (synopsis "Simple test framework")
+ (description "Stefil is a simple test framework for Common Lisp,
+with a focus on interactive development.")
+ (license license:public-domain))))
+
+(define-public cl-hu.dwim.stefil
+ (sbcl-package->cl-source-package sbcl-hu.dwim.stefil))
+
+(define-public ecl-hu.dwim.stefil
+ (sbcl-package->ecl-package sbcl-hu.dwim.stefil))
+
+(define-public sbcl-babel
+ (package
+ (name "sbcl-babel")
+ (version "0.5.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/cl-babel/babel.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "babel" version))
+ (sha256
+ (base32 "139a8rn2gnhj082n8jg01gc8fyr63hkj57hgrnmb3d1r327yc77f"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("tests:cl-hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
+ (inputs
+ `(("sbcl-alexandria" ,sbcl-alexandria)
+ ("sbcl-trivial-features" ,sbcl-trivial-features)))
+ (home-page "https://common-lisp.net/project/babel/")
+ (synopsis "Charset encoding and decoding library")
+ (description "Babel is a charset encoding and decoding library, not unlike
+GNU libiconv, but completely written in Common Lisp.")
+ (license license:expat)))
+
+(define-public cl-babel
+ (sbcl-package->cl-source-package sbcl-babel))
+
+(define-public ecl-babel
+ (sbcl-package->ecl-package sbcl-babel))
+
+(define-public sbcl-cl-yacc
+ (package
+ (name "sbcl-cl-yacc")
+ (version "0.3")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/jech/cl-yacc")
+ (commit (string-append "cl-yacc-" version))))
+ (sha256
+ (base32
+ "16946pzf8vvadnyfayvj8rbh4zjzw90h0azz2qk1mxrvhh5wklib"))
+ (file-name (string-append "cl-yacc-" version "-checkout"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:asd-file "yacc.asd"
+ #:asd-system-name "yacc"))
+ (synopsis "LALR(1) parser generator for Common Lisp, similar in spirit to Yacc")
+ (description
+ "CL-Yacc is a LALR(1) parser generator for Common Lisp, similar in spirit
+to AT&T Yacc, Berkeley Yacc, GNU Bison, Zebu, lalr.cl or lalr.scm.
+
+CL-Yacc uses the algorithm due to Aho and Ullman, which is the one also used
+by AT&T Yacc, Berkeley Yacc and Zebu. It does not use the faster algorithm due
+to DeRemer and Pennello, which is used by Bison and lalr.scm (not lalr.cl).")
+ (home-page "https://www.irif.fr/~jch//software/cl-yacc/")
+ (license license:expat)))
+
+(define-public cl-yacc
+ (sbcl-package->cl-source-package sbcl-cl-yacc))
+
+(define-public ecl-cl-yacc
+ (sbcl-package->ecl-package sbcl-cl-yacc))
+
+(define-public sbcl-jpl-util
+ (let ((commit "0311ed374e19a49d43318064d729fe3abd9a3b62"))
+ (package
+ (name "sbcl-jpl-util")
+ (version "20151005")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ ;; Quicklisp uses this fork.
+ (url "https://github.com/hawkir/cl-jpl-util")
+ (commit commit)))
+ (file-name
+ (git-file-name "jpl-util" version))
+ (sha256
+ (base32
+ "0nc0rk9n8grkg3045xsw34whmcmddn2sfrxki4268g7kpgz0d2yz"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Collection of Common Lisp utility functions and macros")
+ (description
+ "@command{cl-jpl-util} is a collection of Common Lisp utility functions
+and macros, primarily for software projects written in CL by the author.")
+ (home-page "https://www.thoughtcrime.us/software/cl-jpl-util/")
+ (license license:isc))))
+
+(define-public cl-jpl-util
+ (sbcl-package->cl-source-package sbcl-jpl-util))
+
+(define-public ecl-jpl-util
+ (sbcl-package->ecl-package sbcl-jpl-util))
+
+(define-public sbcl-jpl-queues
+ (package
+ (name "sbcl-jpl-queues")
+ (version "0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://www.thoughtcrime.us/software/jpl-queues/jpl-queues-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1wvvv7j117h9a42qaj1g4fh4mji28xqs7s60rn6d11gk9jl76h96"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("jpl-util" ,sbcl-jpl-util)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)))
+ (arguments
+ ;; Tests seem to be broken.
+ `(#:tests? #f))
+ (synopsis "Common Lisp library implementing a few different kinds of queues")
+ (description
+ "A Common Lisp library implementing a few different kinds of queues:
+
+@itemize
+@item Bounded and unbounded FIFO queues.
+@item Lossy bounded FIFO queues that drop elements when full.
+@item Unbounded random-order queues that use less memory than unbounded FIFO queues.
+@end itemize
+
+Additionally, a synchronization wrapper is provided to make any queue
+conforming to the @command{jpl-queues} API thread-safe for lightweight
+multithreading applications. (See Calispel for a more sophisticated CL
+multithreaded message-passing library with timeouts and alternation among
+several blockable channels.)")
+ (home-page "https://www.thoughtcrime.us/software/jpl-queues/")
+ (license license:isc)))
+
+(define-public cl-jpl-queues
+ (sbcl-package->cl-source-package sbcl-jpl-queues))
+
+(define-public ecl-jpl-queues
+ (sbcl-package->ecl-package sbcl-jpl-queues))
+
+(define-public sbcl-eos
+ (let ((commit "b0faca83781ead9a588661e37bd47f90362ccd94"))
+ (package
+ (name "sbcl-eos")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/adlai/Eos")
+ (commit commit)))
+ (sha256
+ (base32
+ "1bq8cfg087iyxmxi1mwgx5cfgy3b8ydrf81xljcis8qbgb2vszph"))
+ (file-name (git-file-name "eos" version))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Unit Testing for Common Lisp")
+ (description
+ "Eos was a unit testing library for Common Lisp.
+It began as a fork of FiveAM; however, FiveAM development has continued, while
+that of Eos has not. Thus, Eos is now deprecated in favor of FiveAM.")
+ (home-page "https://github.com/adlai/Eos")
+ (license license:expat))))
+
+(define-public cl-eos
+ (sbcl-package->cl-source-package sbcl-eos))
+
+(define-public ecl-eos
+ (sbcl-package->ecl-package sbcl-eos))
+
+(define-public sbcl-esrap
+ (let ((commit "133be8b05c2aae48696fe5b739eea2fa573fa48d"))
+ (package
+ (name "sbcl-esrap")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/nikodemus/esrap")
+ (commit commit)))
+ (sha256
+ (base32
+ "02d5clihsdryhf7pix8c5di2571fdsffh75d40fkzhws90r5mksl"))
+ (file-name (git-file-name "esrap" version))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("eos" ,sbcl-eos))) ;For testing only.
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)))
+ (synopsis "Common Lisp packrat parser")
+ (description
+ "A packrat parser for Common Lisp.
+In addition to regular Packrat / Parsing Grammar / TDPL features ESRAP supports:
+
+@itemize
+@item dynamic redefinition of nonterminals
+@item inline grammars
+@item semantic predicates
+@item introspective facilities (describing grammars, tracing, setting breaks)
+@end itemize\n")
+ (home-page "https://nikodemus.github.io/esrap/")
+ (license license:expat))))
+
+(define-public cl-esrap
+ (sbcl-package->cl-source-package sbcl-esrap))
+
+(define-public ecl-esrap
+ (sbcl-package->ecl-package sbcl-esrap))
+
+(define-public sbcl-split-sequence
+ (package
+ (name "sbcl-split-sequence")
+ (version "1.4.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sharplispers/split-sequence")
+ (commit (string-append "v" version))))
+ (sha256
+ (base32
+ "0c3zp6b7fmmp93sfhq112ind4zkld49ycw68z409xpnz3gc0wpf0"))
+ (file-name (git-file-name "split-sequence" version))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; TODO: Tests seem to be broken.
+ ;; https://github.com/sharplispers/split-sequence/issues/8
+ `(#:tests? #f))
+ (synopsis "Member of the Common Lisp Utilities family of programs")
+ (description
+ "Splits sequence into a list of subsequences delimited by objects
+satisfying the test.")
+ (home-page "https://cliki.net/split-sequence")
+ (license license:expat)))
+
+(define-public cl-split-sequence
+ (sbcl-package->cl-source-package sbcl-split-sequence))
+
+(define-public ecl-split-sequence
+ (sbcl-package->ecl-package sbcl-split-sequence))
+
+(define-public sbcl-html-encode
+ (package
+ (name "sbcl-html-encode")
+ (version "1.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://beta.quicklisp.org/archive/html-encode/2010-10-06/html-encode-"
+ version ".tgz"))
+ (sha256
+ (base32
+ "06mf8wn95yf5swhmzk4vp0xr4ylfl33dgfknkabbkd8n6jns8gcf"))
+ (file-name (string-append "colorize" version "-checkout"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Common Lisp library for encoding text in various web-savvy encodings")
+ (description
+ "A library for encoding text in various web-savvy encodings.")
+ (home-page "http://quickdocs.org/html-encode/")
+ (license license:expat)))
+
+(define-public cl-html-encode
+ (sbcl-package->cl-source-package sbcl-html-encode))
+
+(define-public ecl-html-encode
+ (sbcl-package->ecl-package sbcl-html-encode))
+
+(define-public sbcl-colorize
+ (let ((commit "ea676b584e0899cec82f21a9e6871172fe3c0eb5"))
+ (package
+ (name "sbcl-colorize")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/kingcons/colorize")
+ (commit commit)))
+ (sha256
+ (base32
+ "1pdg4kiaczmr3ivffhirp7m3lbr1q27rn7dhaay0vwghmi31zcw9"))
+ (file-name (git-file-name "colorize" version))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("split-sequence" ,sbcl-split-sequence)
+ ("html-encode" ,sbcl-html-encode)))
+ (synopsis "Common Lisp for syntax highlighting")
+ (description
+ "@command{colorize} is a Lisp library for syntax highlighting
+supporting the following languages: Common Lisp, Emacs Lisp, Scheme, Clojure,
+C, C++, Java, Python, Erlang, Haskell, Objective-C, Diff, Webkit.")
+ (home-page "https://github.com/kingcons/colorize")
+ ;; TODO: Missing license?
+ (license license:expat))))
+
+(define-public cl-colorize
+ (sbcl-package->cl-source-package sbcl-colorize))
+
+(define-public ecl-colorize
+ (sbcl-package->ecl-package sbcl-colorize))
+
+(define-public sbcl-3bmd
+ (let ((commit "192ea13435b605a96ef607df51317056914cabbd"))
+ (package
+ (name "sbcl-3bmd")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/3b/3bmd")
+ (commit commit)))
+ (sha256
+ (base32
+ "1rgv3gi7wf963ikmmpk132wgn0icddf226gq3bmcnk1fr3v9gf2f"))
+ (file-name (git-file-name "3bmd" version))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; FIXME: We need to specify the name because the build-system thinks
+ ;; "3" is a version marker.
+ `(#:asd-system-name "3bmd"))
+ (inputs
+ `(("esrap" ,sbcl-esrap)
+ ("split-sequence" ,sbcl-split-sequence)))
+ (synopsis "Markdown processor in Command Lisp using esrap parser")
+ (description
+ "Common Lisp Markdown -> HTML converter, using @command{esrap} for
+parsing, and grammar based on @command{peg-markdown}.")
+ (home-page "https://github.com/3b/3bmd")
+ (license license:expat))))
+
+(define-public cl-3bmd
+ (sbcl-package->cl-source-package sbcl-3bmd))
+
+(define-public ecl-3bmd
+ (sbcl-package->ecl-package sbcl-3bmd))
+
+(define-public sbcl-3bmd-ext-code-blocks
+ (let ((commit "192ea13435b605a96ef607df51317056914cabbd"))
+ (package
+ (inherit sbcl-3bmd)
+ (name "sbcl-3bmd-ext-code-blocks")
+ (arguments
+ `(#:asd-system-name "3bmd-ext-code-blocks"
+ #:asd-file "3bmd-ext-code-blocks.asd"))
+ (inputs
+ `(("3bmd" ,sbcl-3bmd)
+ ("colorize" ,sbcl-colorize)))
+ (synopsis "3bmd extension which adds support for GitHub-style fenced
+code blocks")
+ (description
+ "3bmd extension which adds support for GitHub-style fenced code blocks,
+with @command{colorize} support."))))
+
+(define-public cl-3bmd-ext-code-blocks
+ (sbcl-package->cl-source-package sbcl-3bmd-ext-code-blocks))
+
+(define-public ecl-3bmd-ext-code-blocks
+ (sbcl-package->ecl-package sbcl-3bmd-ext-code-blocks))
+
+(define-public sbcl-cl-fad
+ (package
+ (name "sbcl-cl-fad")
+ (version "0.7.5")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/edicl/cl-fad/")
+ (commit (string-append "v" version))))
+ (sha256
+ (base32
+ "1l1qmk9z57q84bz5r04sxsksggsnd7dgkxlybzh9imz6ma7sm52m"))
+ (file-name (string-append "cl-fad" version "-checkout"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
+ (synopsis "Portable pathname library for Common Lisp")
+ (description
+ "CL-FAD (for \"Files and Directories\") is a thin layer atop Common
+Lisp's standard pathname functions. It is intended to provide some
+unification between current CL implementations on Windows, OS X, Linux, and
+Unix. Most of the code was written by Peter Seibel for his book Practical
+Common Lisp.")
+ (home-page "https://edicl.github.io/cl-fad/")
+ (license license:bsd-2)))
+
+(define-public cl-fad
+ (sbcl-package->cl-source-package sbcl-cl-fad))
+
+(define-public ecl-cl-fad
+ (sbcl-package->ecl-package sbcl-cl-fad))
+
+(define-public sbcl-rt
+ (package
+ (name "sbcl-rt")
+ (version "1990.12.19")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "http://beta.quicklisp.org/archive/rt/2010-10-06/rt-"
+ "20101006-git" ".tgz"))
+ (sha256
+ (base32
+ "1jncar0xwkqk8yrc2dln389ivvgzs7ijdhhs3zpfyi5d21f0qa1v"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "MIT Regression Tester")
+ (description
+ "RT provides a framework for writing regression test suites.")
+ (home-page "https://github.com/sharplispers/nibbles")
+ (license license:unlicense)))
+
+(define-public cl-rt
+ (sbcl-package->cl-source-package sbcl-rt))
+
+(define-public ecl-rt
+ (sbcl-package->ecl-package sbcl-rt))
+
+(define-public sbcl-nibbles
+ (package
+ (name "sbcl-nibbles")
+ (version "0.14")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sharplispers/nibbles/")
+ (commit (string-append "v" version))))
+ (sha256
+ (base32
+ "1v7qfgpvdr6nz7v63dj69d26dis0kff3rd8xamr1llfdvza2pm8f"))
+ (file-name (git-file-name "nibbles" version))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ ;; Tests only.
+ `(("rt" ,sbcl-rt)))
+ (synopsis "Common Lisp library for accessing octet-addressed blocks of data")
+ (description
+ "When dealing with network protocols and file formats, it's common to
+have to read or write 16-, 32-, or 64-bit datatypes in signed or unsigned
+flavors. Common Lisp sort of supports this by specifying :element-type for
+streams, but that facility is underspecified and there's nothing similar for
+read/write from octet vectors. What most people wind up doing is rolling their
+own small facility for their particular needs and calling it a day.
+
+This library attempts to be comprehensive and centralize such
+facilities. Functions to read 16-, 32-, and 64-bit quantities from octet
+vectors in signed or unsigned flavors are provided; these functions are also
+SETFable. Since it's sometimes desirable to read/write directly from streams,
+functions for doing so are also provided. On some implementations,
+reading/writing IEEE singles/doubles (i.e. single-float and double-float) will
+also be supported.")
+ (home-page "https://github.com/sharplispers/nibbles")
+ (license license:bsd-3)))
+
+(define-public cl-nibbles
+ (sbcl-package->cl-source-package sbcl-nibbles))
+
+(define-public ecl-nibbles
+ (sbcl-package->ecl-package sbcl-nibbles))
+
+(define-public sbcl-ironclad
+ (package
+ (name "sbcl-ironclad")
+ (version "0.46")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sharplispers/ironclad/")
+ (commit (string-append "v" version))))
+ (sha256
+ (base32
+ "1s391awi2lsl7m1dbjirgpkm4p9p8wd076pakgvsvpn1rrznisnd"))
+ (file-name (git-file-name name version))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ ;; Tests only.
+ `(("rt" ,sbcl-rt)))
+ (inputs
+ `(("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("flexi-streams" ,sbcl-flexi-streams)
+ ("nibbles" ,sbcl-nibbles)))
+ (synopsis "Cryptographic toolkit written in Common Lisp")
+ (description
+ "Ironclad is a cryptography library written entirely in Common Lisp.
+It includes support for several popular ciphers, digests, MACs and public key
+cryptography algorithms. For several implementations that support Gray
+streams, support is included for convenient stream wrappers.")
+ (home-page "https://github.com/sharplispers/ironclad")
+ (license license:bsd-3)))
+
+(define-public cl-ironclad
+ (sbcl-package->cl-source-package sbcl-ironclad))
+
+(define-public ecl-ironclad
+ (sbcl-package->ecl-package sbcl-ironclad))
+
+(define-public sbcl-named-readtables
+ (let ((commit "4dfb89fa1af6b305b6492b8af042f5190c11e9fc")
+ (revision "1"))
+ (package
+ (name "sbcl-named-readtables")
+ (version (string-append "0.9-" revision "." (string-take commit 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/melisgl/named-readtables.git")
+ (commit commit)))
+ (sha256
+ (base32 "083kgh5462iqbb4px6kq8s7sggvpvkm36hx4qi9rnaw53b6ilqkk"))
+ (file-name (git-file-name "named-readtables" version))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; Tests seem to be broken.
+ `(#:tests? #f))
+ (home-page "https://github.com/melisgl/named-readtables/")
+ (synopsis "Library that creates a namespace for named readtables")
+ (description "Named readtables is a library that creates a namespace for
+named readtables, which is akin to package namespacing in Common Lisp.")
+ (license license:bsd-3))))
+
+(define-public cl-named-readtables
+ (sbcl-package->cl-source-package sbcl-named-readtables))
+
+(define-public ecl-named-readtables
+ (sbcl-package->ecl-package sbcl-named-readtables))
+
+(define-public sbcl-pythonic-string-reader
+ (let ((commit "47a70ba1e32362e03dad6ef8e6f36180b560f86a"))
+ (package
+ (name "sbcl-pythonic-string-reader")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/smithzvk/pythonic-string-reader/")
+ (commit commit)))
+ (sha256
+ (base32 "1b5iryqw8xsh36swckmz8rrngmc39k92si33fgy5pml3n9l5rq3j"))
+ (file-name (git-file-name "pythonic-string-reader" version))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("named-readtables" ,sbcl-named-readtables)))
+ (home-page "https://github.com/smithzvk/pythonic-string-reader")
+ (synopsis "Read table modification inspired by Python's three quote strings")
+ (description "This piece of code sets up some reader macros that make it
+simpler to input string literals which contain backslashes and double quotes
+This is very useful for writing complicated docstrings and, as it turns out,
+writing code that contains string literals that contain code themselves.")
+ (license license:bsd-3))))
+
+(define-public cl-pythonic-string-reader
+ (sbcl-package->cl-source-package sbcl-pythonic-string-reader))
+
+(define-public ecl-pythonic-string-reader
+ (sbcl-package->ecl-package sbcl-pythonic-string-reader))
+
+;; SLIME does not have a ASDF system definition to build all of Swank. As a
+;; result, the asdf-build-system/sbcl will produce an almost empty package.
+;; Some work was done to fix this at
+;; https://github.com/sionescu/slime/tree/swank-asdf but it was never merged
+;; and is now lagging behind. Building SBCL fasls might not be worth the
+;; hassle, so let's just ship the source then.
+(define-public cl-slime-swank
+ (package
+ (name "cl-slime-swank")
+ (version "2.24")
+ (source
+ (origin
+ (file-name (string-append name "-" version ".tar.gz"))
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/slime/slime/")
+ (commit (string-append "v" version))))
+ (sha256
+ (base32
+ "0js24x42m7b5iymb4rxz501dff19vav5pywnzv50b673rbkaaqvh"))))
+ (build-system asdf-build-system/source)
+ (home-page "https://github.com/slime/slime")
+ (synopsis "Common Lisp Swank server")
+ (description
+ "This is only useful if you want to start a Swank server in a Lisp
+processes that doesn't run under Emacs. Lisp processes created by
+@command{M-x slime} automatically start the server.")
+ (license (list license:gpl2+ license:public-domain))))
+
+(define-public sbcl-slime-swank
+ (deprecated-package "sbcl-slime-swank" cl-slime-swank))
+
+(define-public sbcl-mgl-pax
+ (let ((commit "818448418d6b9de74620f606f5b23033c6082769"))
+ (package
+ (name "sbcl-mgl-pax")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/melisgl/mgl-pax")
+ (commit commit)))
+ (sha256
+ (base32
+ "1p97zfkh130bdxqqxwaw2j9psv58751wakx7czbfpq410lg7dd7i"))
+ (file-name (git-file-name "mgl-pax" version))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("3bmd" ,sbcl-3bmd)
+ ("3bmd-ext-code-blocks" ,sbcl-3bmd-ext-code-blocks)
+ ("babel" ,sbcl-babel)
+ ("cl-fad" ,sbcl-cl-fad)
+ ("ironclad" ,sbcl-ironclad)
+ ("named-readtables" ,sbcl-named-readtables)
+ ("pythonic-string-reader" ,sbcl-pythonic-string-reader)
+ ("swank" ,cl-slime-swank)))
+ (synopsis "Exploratory programming environment and documentation generator")
+ (description
+ "PAX provides an extremely poor man's Explorable Programming
+environment. Narrative primarily lives in so called sections that mix markdown
+docstrings with references to functions, variables, etc, all of which should
+probably have their own docstrings.
+
+The primary focus is on making code easily explorable by using SLIME's
+@command{M-.} (@command{slime-edit-definition}). See how to enable some
+fanciness in Emacs Integration. Generating documentation from sections and all
+the referenced items in Markdown or HTML format is also implemented.
+
+With the simplistic tools provided, one may accomplish similar effects as with
+Literate Programming, but documentation is generated from code, not vice versa
+and there is no support for chunking yet. Code is first, code must look
+pretty, documentation is code.")
+ (home-page "http://quotenil.com/")
+ (license license:expat))))
+
+(define-public cl-mgl-pax
+ (sbcl-package->cl-source-package sbcl-mgl-pax))
+
+(define-public ecl-mgl-pax
+ (sbcl-package->ecl-package sbcl-mgl-pax))
+
+(define-public sbcl-lisp-unit
+ (let ((commit "89653a232626b67400bf9a941f9b367da38d3815"))
+ (package
+ (name "sbcl-lisp-unit")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/OdonataResearchLLC/lisp-unit")
+ (commit commit)))
+ (sha256
+ (base32
+ "0p6gdmgr7p383nvd66c9y9fp2bjk4jx1lpa5p09g43hr9y9pp9ry"))
+ (file-name (git-file-name "lisp-unit" version))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Common Lisp Test framework inspired by JUnit to be simple of use")
+ (description
+ "@command{lisp-unit} is a Common Lisp library that supports unit
+testing. It is an extension of the library written by Chris Riesbeck.")
+ (home-page "https://github.com/OdonataResearchLLC/lisp-unit")
+ (license license:expat))))
+
+(define-public cl-lisp-unit
+ (sbcl-package->cl-source-package sbcl-lisp-unit))
+
+(define-public ecl-lisp-unit
+ (sbcl-package->ecl-package sbcl-lisp-unit))
+
+(define-public sbcl-anaphora
+ (package
+ (name "sbcl-anaphora")
+ (version "0.9.6")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/tokenrove/anaphora")
+ (commit version)))
+ (sha256
+ (base32
+ "19wfrk3asimznkli0x2rfy637hwpdgqyvwj3vhq9x7vjvyf5vv6x"))
+ (file-name (git-file-name "anaphora" version))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("rt" ,sbcl-rt)))
+ (synopsis "The anaphoric macro collection from Hell")
+ (description
+ "Anaphora is the anaphoric macro collection from Hell: it includes many
+new fiends in addition to old friends like @command{aif} and
+@command{awhen}.")
+ (home-page "https://github.com/tokenrove/anaphora")
+ (license license:public-domain)))
+
+(define-public cl-anaphora
+ (sbcl-package->cl-source-package sbcl-anaphora))
+
+(define-public ecl-anaphora
+ (sbcl-package->ecl-package sbcl-anaphora))
+
+(define-public sbcl-lift
+ (let ((commit "7d49a66c62759535624037826891152223d4206c"))
+ (package
+ (name "sbcl-lift")
+ (version (git-version "1.7.1" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/gwkkwg/lift")
+ (commit commit)))
+ (sha256
+ (base32
+ "127v5avpz1i4m0lkaxqrq8hrl69rdazqaxf6s8awf0nd7wj2g4dp"))
+ (file-name (git-file-name "lift" version))
+ (modules '((guix build utils)))
+ (snippet
+ ;; Don't keep the bundled website
+ `(begin
+ (delete-file-recursively "website")
+ #t))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; The tests require a debugger, but we run with the debugger disabled.
+ '(#:tests? #f))
+ (synopsis "LIsp Framework for Testing")
+ (description
+ "The LIsp Framework for Testing (LIFT) is a unit and system test tool for LISP.
+Though inspired by SUnit and JUnit, it's built with Lisp in mind. In LIFT,
+testcases are organized into hierarchical testsuites each of which can have
+its own fixture. When run, a testcase can succeed, fail, or error. LIFT
+supports randomized testing, benchmarking, profiling, and reporting.")
+ (home-page "https://github.com/gwkkwg/lift")
+ (license license:expat))))
+
+(define-public cl-lift
+ (sbcl-package->cl-source-package sbcl-lift))
+
+(define-public ecl-lift
+ (sbcl-package->ecl-package sbcl-lift))
+
+(define-public sbcl-let-plus
+ (let ((commit "5f14af61d501ecead02ec6b5a5c810efc0c9fdbb"))
+ (package
+ (name "sbcl-let-plus")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sharplispers/let-plus")
+ (commit commit)))
+ (sha256
+ (base32
+ "0i050ca2iys9f5mb7dgqgqdxfnc3b0rnjdwv95sqd490vkiwrsaj"))
+ (file-name (git-file-name "let-plus" version))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("anaphora" ,sbcl-anaphora)))
+ (native-inputs
+ `(("lift" ,sbcl-lift)))
+ (synopsis "Destructuring extension of let*")
+ (description
+ "This library implements the let+ macro, which is a dectructuring
+extension of let*. It features:
+
+@itemize
+@item Clean, consistent syntax and small implementation (less than 300 LOC,
+not counting tests)
+@item Placeholder macros allow editor hints and syntax highlighting
+@item @command{&ign} for ignored values (in forms where that makes sense)
+@item Very easy to extend
+@end itemize\n")
+ (home-page "https://github.com/sharplispers/let-plus")
+ (license license:boost1.0))))
+
+(define-public cl-let-plus
+ (sbcl-package->cl-source-package sbcl-let-plus))
+
+(define-public ecl-let-plus
+ (sbcl-package->ecl-package sbcl-let-plus))
+
+(define-public sbcl-cl-colors
+ (let ((commit "827410584553f5c717eec6182343b7605f707f75"))
+ (package
+ (name "sbcl-cl-colors")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/tpapp/cl-colors")
+ (commit commit)))
+ (sha256
+ (base32
+ "0l446lday4hybsm9bq3jli97fvv8jb1d33abg79vbylpwjmf3y9a"))
+ (file-name (git-file-name "cl-colors" version))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("let-plus" ,sbcl-let-plus)))
+ (synopsis "Simple color library for Common Lisp")
+ (description
+ "This is a very simple color library for Common Lisp, providing
+
+@itemize
+@item Types for representing colors in HSV and RGB spaces.
+@item Simple conversion functions between the above types (and also
+hexadecimal representation for RGB).
+@item Some predefined colors (currently X11 color names – of course the
+library does not depend on X11).Because color in your terminal is nice.
+@end itemize
+
+This library is no longer supported by its author.")
+ (home-page "https://github.com/tpapp/cl-colors")
+ (license license:boost1.0))))
+
+(define-public cl-colors
+ (sbcl-package->cl-source-package sbcl-cl-colors))
+
+(define-public ecl-cl-colors
+ (sbcl-package->ecl-package sbcl-cl-colors))
+
+(define-public sbcl-cl-ansi-text
+ (let ((commit "53badf7878f27f22f2d4a2a43e6df458e43acbe9"))
+ (package
+ (name "sbcl-cl-ansi-text")
+ (version (git-version "1.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/pnathan/cl-ansi-text")
+ (commit commit)))
+ (sha256
+ (base32
+ "11i27n0dbz5lmygiw65zzr8lx0rac6b6yysqranphn31wls6ja3v"))
+ (file-name (git-file-name "cl-ansi-text" version))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-colors" ,sbcl-cl-colors)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (synopsis "ANSI terminal color implementation for Common Lisp")
+ (description
+ "@command{cl-ansi-text} provides utilities which enable printing to an
+ANSI terminal with colored text. It provides the macro @command{with-color}
+which causes everything printed in the body to be displayed with the provided
+color. It further provides functions which will print the argument with the
+named color.")
+ (home-page "https://github.com/pnathan/cl-ansi-text")
+ (license license:llgpl))))
+
+(define-public cl-ansi-text
+ (sbcl-package->cl-source-package sbcl-cl-ansi-text))
+
+(define-public ecl-cl-ansi-text
+ (sbcl-package->ecl-package sbcl-cl-ansi-text))
+
+(define-public sbcl-prove-asdf
+ (let ((commit "4f9122bd393e63c5c70c1fba23070622317cfaa0"))
+ (package
+ (name "sbcl-prove-asdf")
+ (version (git-version "1.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/prove")
+ (commit commit)))
+ (sha256
+ (base32
+ "07sbfw459z8bbjvx1qlmfa8qk2mvbjnnzi2mi0x72blaj8bkl4vc"))
+ (file-name (git-file-name "prove" version))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:asd-file "prove-asdf.asd"))
+ (synopsis "Test requirement for the Common Lisp 'prove' library")
+ (description
+ "Test requirement for the Common Lisp @command{prove} library.")
+ (home-page "https://github.com/fukamachi/prove")
+ (license license:expat))))
+
+(define-public cl-prove-asdf
+ (sbcl-package->cl-source-package sbcl-prove-asdf))
+
+(define-public ecl-prove-asdf
+ (sbcl-package->ecl-package sbcl-prove-asdf))
+
+(define-public sbcl-prove
+ (package
+ (inherit sbcl-prove-asdf)
+ (name "sbcl-prove")
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("cl-ansi-text" ,sbcl-cl-ansi-text)))
+ (native-inputs
+ `(("prove-asdf" ,sbcl-prove-asdf)))
+ (arguments
+ `(#:asd-file "prove.asd"))
+ (synopsis "Yet another unit testing framework for Common Lisp")
+ (description
+ "This project was originally called @command{cl-test-more}.
+@command{prove} is yet another unit testing framework for Common Lisp. The
+advantages of @command{prove} are:
+
+@itemize
+@item Various simple functions for testing and informative error messages
+@item ASDF integration
+@item Extensible test reporters
+@item Colorizes the report if it's available (note for SLIME)
+@item Reports test durations
+@end itemize\n")))
+
+(define-public cl-prove
+ (sbcl-package->cl-source-package sbcl-prove))
+
+(define-public ecl-prove
+ (sbcl-package->ecl-package sbcl-prove))
+
+(define-public sbcl-proc-parse
+ (let ((commit "ac3636834d561bdc2686c956dbd82494537285fd"))
+ (package
+ (name "sbcl-proc-parse")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/proc-parse")
+ (commit commit)))
+ (sha256
+ (base32
+ "06rnl0h4cx6xv2wj3jczmmcxqn2703inmmvg1s4npbghmijsybfh"))
+ (file-name (git-file-name "proc-parse" version))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("babel" ,sbcl-babel)))
+ (native-inputs
+ `(("prove" ,sbcl-prove)
+ ("prove-asdf" ,sbcl-prove-asdf)))
+ (arguments
+ ;; TODO: Tests don't find "proc-parse-test", why?
+ `(#:tests? #f))
+ (synopsis "Procedural vector parser")
+ (description
+ "This is a string/octets parser library for Common Lisp with speed and
+readability in mind. Unlike other libraries, the code is not a
+pattern-matching-like, but a char-by-char procedural parser.")
+ (home-page "https://github.com/fukamachi/proc-parse")
+ (license license:bsd-2))))
+
+(define-public cl-proc-parse
+ (sbcl-package->cl-source-package sbcl-proc-parse))
+
+(define-public ecl-proc-parse
+ (sbcl-package->ecl-package sbcl-proc-parse))
+
+(define-public sbcl-parse-float
+ (let ((commit "2aae569f2a4b2eb3bfb5401a959425dcf151b09c"))
+ (package
+ (name "sbcl-parse-float")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/soemraws/parse-float")
+ (commit commit)))
+ (sha256
+ (base32
+ "08xw8cchhmqcc0byng69m3f5a2izc9y2290jzz2k0qrbibp1fdk7"))
+ (file-name (git-file-name "proc-parse" version))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("babel" ,sbcl-babel)))
+ (native-inputs
+ `(("prove" ,sbcl-prove)
+ ("prove-asdf" ,sbcl-prove-asdf)))
+ (arguments
+ ;; TODO: Tests don't find "proc-parse-test", why?
+ `(#:tests? #f))
+ (synopsis "Parse a floating point value from a string in Common Lisp")
+ (description
+ "This package exports the following function to parse floating-point
+values from a string in Common Lisp.")
+ (home-page "https://github.com/soemraws/parse-float")
+ (license license:public-domain))))
+
+(define-public cl-parse-float
+ (sbcl-package->cl-source-package sbcl-parse-float))
+
+(define-public ecl-parse-float
+ (sbcl-package->ecl-package sbcl-parse-float))
+
+(define-public sbcl-ascii-strings
+ (let ((revision "1")
+ (changeset "5048480a61243e6f1b02884012c8f25cdbee6d97"))
+ (package
+ (name "sbcl-ascii-strings")
+ (version (string-append "0-" revision "." (string-take changeset 7)))
+ (source
+ (origin
+ (method hg-fetch)
+ (uri (hg-reference
+ (url "https://bitbucket.org/vityok/cl-string-match/")
+ (changeset changeset)))
+ (sha256
+ (base32
+ "01wn5qx562w43ssy92xlfgv79w7p0nv0wbl76mpmba131n9ziq2y"))
+ (file-name (git-file-name "cl-string-match" version))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("babel" ,sbcl-babel)))
+ (arguments
+ `(#:asd-file "ascii-strings.asd"))
+ (synopsis "Operations on ASCII strings")
+ (description
+ "Operations on ASCII strings. Essentially this can be any kind of
+single-byte encoded strings.")
+ (home-page "https://bitbucket.org/vityok/cl-string-match/")
+ (license license:bsd-3))))
+
+(define-public cl-ascii-strings
+ (sbcl-package->cl-source-package sbcl-ascii-strings))
+
+(define-public ecl-ascii-strings
+ (sbcl-package->ecl-package sbcl-ascii-strings))
+
+(define-public sbcl-simple-scanf
+ (package
+ (inherit sbcl-ascii-strings)
+ (name "sbcl-simple-scanf")
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("iterate" ,sbcl-iterate)
+ ("proc-parse" ,sbcl-proc-parse)
+ ("parse-float" ,sbcl-parse-float)))
+ (arguments
+ `(#:asd-file "simple-scanf.asd"))
+ (synopsis "Simple scanf-like functionality implementation")
+ (description
+ "A simple scanf-like functionality implementation.")))
+
+(define-public cl-simple-scanf
+ (sbcl-package->cl-source-package sbcl-simple-scanf))
+
+(define-public ecl-simple-scanf
+ (sbcl-package->ecl-package sbcl-simple-scanf))
+
+(define-public sbcl-cl-string-match
+ (package
+ (inherit sbcl-ascii-strings)
+ (name "sbcl-cl-string-match")
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("ascii-strings" ,sbcl-ascii-strings)
+ ("yacc" ,sbcl-cl-yacc)
+ ("jpl-util" ,sbcl-jpl-util)
+ ("jpl-queues" ,sbcl-jpl-queues)
+ ("mgl-pax" ,sbcl-mgl-pax)
+ ("iterate" ,sbcl-iterate)))
+ ;; TODO: Tests are not evaluated properly.
+ (native-inputs
+ ;; For testing:
+ `(("lisp-unit" ,sbcl-lisp-unit)
+ ("simple-scanf" ,sbcl-simple-scanf)))
+ (arguments
+ `(#:tests? #f
+ #:asd-file "cl-string-match.asd"))
+ (synopsis "Portable, dependency-free set of utilities to manipulate strings in Common Lisp")
+ (description
+ "@command{cl-strings} is a small, portable, dependency-free set of
+utilities that make it even easier to manipulate text in Common Lisp. It has
+100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.")))
+
+(define-public cl-string-match
+ (sbcl-package->cl-source-package sbcl-cl-string-match))
+
+(define-public ecl-cl-string-match
+ (sbcl-package->ecl-package sbcl-cl-string-match))
+
+(define-public sbcl-ptester
+ (package
+ (name "sbcl-ptester")
+ (version "20160929")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "http://beta.quicklisp.org/archive/ptester/"
+ (date->string (string->date version "~Y~m~d") "~Y-~m-~d")
+ "/ptester-"
+ version
+ "-git.tgz"))
+ (sha256
+ (base32
+ "04rlq1zljhxc65pm31bah3sq3as24l0sdivz440s79qlnnyh13hz"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "http://quickdocs.org/ptester/")
+ (synopsis "Portable test harness package")
+ (description
+ "@command{ptester} is a portable testing framework based on Franz's
+tester module.")
+ (license license:lgpl3+)))
+
+(define-public cl-ptester
+ (sbcl-package->cl-source-package sbcl-ptester))
+
+(define-public ecl-ptester
+ (sbcl-package->ecl-package sbcl-ptester))
+
+(define-public sbcl-puri
+ (package
+ (name "sbcl-puri")
+ (version "20180228")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "http://beta.quicklisp.org/archive/puri/"
+ (date->string (string->date version "~Y~m~d") "~Y-~m-~d")
+ "/puri-"
+ version
+ "-git.tgz"))
+ (sha256
+ (base32
+ "1s4r5adrjy5asry45xbcbklxhdjydvf6n55z897nvyw33bigrnbz"))))
+ (build-system asdf-build-system/sbcl)
+ ;; REVIEW: Webiste down?
+ (native-inputs
+ `(("ptester" ,sbcl-ptester)))
+ (home-page "http://files.kpe.io/puri/")
+ (synopsis "Portable URI Library")
+ (description
+ "This is portable Universal Resource Identifier library for Common Lisp
+programs. It parses URI according to the RFC 2396 specification")
+ (license license:lgpl3+)))
+
+(define-public cl-puri
+ (sbcl-package->cl-source-package sbcl-puri))
+
+(define-public ecl-puri
+ (sbcl-package->ecl-package sbcl-puri))
+
+(define-public sbcl-queues
+ (let ((commit "47d4da65e9ea20953b74aeeab7e89a831b66bc94"))
+ (package
+ (name "sbcl-queues")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/oconnore/queues")
+ (commit commit)))
+ (file-name (git-file-name "queues" version))
+ (sha256
+ (base32
+ "0wdhfnzi4v6d97pggzj2aw55si94w4327br94jrmyvwf351wqjvv"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/oconnore/queues")
+ (synopsis "Common Lisp queue library")
+ (description
+ "This is a simple queue library for Common Lisp with features such as
+non-consing thread safe queues and fibonacci priority queues.")
+ (license license:expat))))
+
+(define-public cl-queues
+ (sbcl-package->cl-source-package sbcl-queues))
+
+(define-public ecl-queues
+ (sbcl-package->ecl-package sbcl-queues))
+
+(define-public sbcl-queues.simple-queue
+ (package
+ (inherit sbcl-queues)
+ (name "sbcl-queues.simple-queue")
+ (inputs
+ `(("sbcl-queues" ,sbcl-queues)))
+ (arguments
+ `(#:asd-file "queues.simple-queue.asd"))
+ (synopsis "Simple queue implementation")
+ (description
+ "This is a simple queue library for Common Lisp with features such as
+non-consing thread safe queues and fibonacci priority queues.")
+ (license license:expat)))
+
+(define-public cl-queues.simple-queue
+ (sbcl-package->cl-source-package sbcl-queues.simple-queue))
+
+(define-public ecl-queues.simple-queue
+ (sbcl-package->ecl-package sbcl-queues.simple-queue))
+
+(define-public sbcl-queues.simple-cqueue
+ (package
+ (inherit sbcl-queues)
+ (name "sbcl-queues.simple-cqueue")
+ (inputs
+ `(("sbcl-queues" ,sbcl-queues)
+ ("sbcl-queues.simple-queue" ,sbcl-queues.simple-queue)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)))
+ (arguments
+ `(#:asd-file "queues.simple-cqueue.asd"))
+ (synopsis "Thread safe queue implementation")
+ (description
+ "This is a simple queue library for Common Lisp with features such as
+non-consing thread safe queues and fibonacci priority queues.")
+ (license license:expat)))
+
+(define-public cl-queues.simple-cqueue
+ (sbcl-package->cl-source-package sbcl-queues.simple-cqueue))
+
+(define-public ecl-queues.simple-cqueue
+ (sbcl-package->ecl-package sbcl-queues.simple-cqueue))
+
+(define-public sbcl-queues.priority-queue
+ (package
+ (inherit sbcl-queues)
+ (name "sbcl-queues.priority-queue")
+ (inputs
+ `(("sbcl-queues" ,sbcl-queues)))
+ (arguments
+ `(#:asd-file "queues.priority-queue.asd"))
+ (synopsis "Priority queue (Fibonacci) implementation")
+ (description
+ "This is a simple queue library for Common Lisp with features such as
+non-consing thread safe queues and fibonacci priority queues.")
+ (license license:expat)))
+
+(define-public cl-queues.priority-queue
+ (sbcl-package->cl-source-package sbcl-queues.priority-queue))
+
+(define-public ecl-queues.priority-queue
+ (sbcl-package->ecl-package sbcl-queues.priority-queue))
+
+(define-public sbcl-queues.priority-cqueue
+ (package
+ (inherit sbcl-queues)
+ (name "sbcl-queues.priority-cqueue")
+ (inputs
+ `(("sbcl-queues" ,sbcl-queues)
+ ("sbcl-queues.priority-queue" ,sbcl-queues.priority-queue)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)))
+ (arguments
+ `(#:asd-file "queues.priority-cqueue.asd"))
+ (synopsis "Thread safe fibonacci priority queue implementation")
+ (description
+ "This is a simple queue library for Common Lisp with features such as
+non-consing thread safe queues and fibonacci priority queues.")
+ (license license:expat)))
+
+(define-public cl-queues.priority-cqueue
+ (sbcl-package->cl-source-package sbcl-queues.priority-cqueue))
+
+(define-public ecl-queues.priority-cqueue
+ (sbcl-package->ecl-package sbcl-queues.priority-cqueue))
+
+(define sbcl-cffi-bootstrap
+ (package
+ (name "sbcl-cffi-bootstrap")
+ (version "0.19.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/cffi/cffi.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cffi-bootstrap" version))
+ (sha256
+ (base32 "09sfgc6r7ihmbkwfpvkq5fxc7h45cabpvgbvs47i5cvnmv3k72xy"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("libffi" ,libffi)
+ ("alexandria" ,sbcl-alexandria)
+ ("babel" ,sbcl-babel)
+ ("trivial-features" ,sbcl-trivial-features)))
+ (native-inputs
+ `(("pkg-config" ,pkg-config)))
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "libffi/libffi.lisp"
+ (("libffi.so.6" all) (string-append
+ (assoc-ref inputs "libffi")
+ "/lib/" all)))
+ (substitute* "toolchain/c-toolchain.lisp"
+ (("\"cc\"") (format #f "~S" (which "gcc")))))))
+ #:asd-system-name "cffi"
+ #:tests? #f))
+ (home-page "https://common-lisp.net/project/cffi/")
+ (synopsis "Common Foreign Function Interface for Common Lisp")
+ (description "The Common Foreign Function Interface (CFFI)
+purports to be a portable foreign function interface for Common Lisp.
+The CFFI library is composed of a Lisp-implementation-specific backend
+in the CFFI-SYS package, and a portable frontend in the CFFI
+package.")
+ (license license:expat)))
+
+(define-public sbcl-cffi-toolchain
+ (package
+ (inherit sbcl-cffi-bootstrap)
+ (name "sbcl-cffi-toolchain")
+ (inputs
+ `(("libffi" ,libffi)
+ ("sbcl-cffi" ,sbcl-cffi-bootstrap)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-cffi-bootstrap)
+ ((#:asd-system-name _) #f)
+ ((#:tests? _) #t)))))
+
+(define-public sbcl-cffi-libffi
+ (package
+ (inherit sbcl-cffi-toolchain)
+ (name "sbcl-cffi-libffi")
+ (inputs
+ `(("cffi" ,sbcl-cffi-bootstrap)
+ ("cffi-grovel" ,sbcl-cffi-grovel)
+ ("trivial-features" ,sbcl-trivial-features)
+ ("libffi" ,libffi)))))
+
+(define-public sbcl-cffi-grovel
+ (package
+ (inherit sbcl-cffi-toolchain)
+ (name "sbcl-cffi-grovel")
+ (inputs
+ `(("libffi" ,libffi)
+ ("cffi" ,sbcl-cffi-bootstrap)
+ ("cffi-toolchain" ,sbcl-cffi-toolchain)
+ ("alexandria" ,sbcl-alexandria)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-cffi-toolchain)
+ ((#:phases phases)
+ `(modify-phases ,phases
+ (add-after 'build 'install-headers
+ (lambda* (#:key outputs #:allow-other-keys)
+ (install-file "grovel/common.h"
+ (string-append
+ (assoc-ref outputs "out")
+ "/include/grovel"))))))))))
+
+(define-public sbcl-cffi
+ (package
+ (inherit sbcl-cffi-toolchain)
+ (name "sbcl-cffi")
+ (inputs (package-inputs sbcl-cffi-bootstrap))
+ (native-inputs
+ `(("cffi-grovel" ,sbcl-cffi-grovel)
+ ("cffi-libffi" ,sbcl-cffi-libffi)
+ ("rt" ,sbcl-rt)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ,@(package-native-inputs sbcl-cffi-bootstrap)))))
+
+(define-public cl-cffi
+ (sbcl-package->cl-source-package sbcl-cffi))
+
+(define-public sbcl-cl-sqlite
+ (let ((commit "c738e66d4266ef63a1debc4ef4a1b871a068c112"))
+ (package
+ (name "sbcl-cl-sqlite")
+ (version (git-version "0.2" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/dmitryvk/cl-sqlite")
+ (commit commit)))
+ (file-name (git-file-name "cl-sqlite" version))
+ (sha256
+ (base32
+ "1ng45k1hdb84sqjryrfx93g66bsbybmpy301wd0fdybnc5jzr36q"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("iterate" ,sbcl-iterate)
+ ("cffi" ,sbcl-cffi)
+ ("sqlite" ,sqlite)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)))
+ (arguments
+ `(#:tests? #f ; Upstream seems to have issues with tests: https://github.com/dmitryvk/cl-sqlite/issues/7
+ #:asd-file "sqlite.asd"
+ #:asd-system-name "sqlite"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "sqlite-ffi.lisp"
+ (("libsqlite3" all) (string-append
+ (assoc-ref inputs "sqlite")"/lib/" all))))))))
+ (home-page "https://common-lisp.net/project/cl-sqlite/")
+ (synopsis "Common Lisp binding for SQLite")
+ (description
+ "The @command{cl-sqlite} package is an interface to the SQLite embedded
+relational database engine.")
+ (license license:public-domain))))
+
+(define-public cl-sqlite
+ (sbcl-package->cl-source-package sbcl-cl-sqlite))
+
+(define-public sbcl-parenscript
+ (let ((commit "061d8e286c81c3f45c84fb2b11ee7d83f590a8f8"))
+ (package
+ (name "sbcl-parenscript")
+ (version (git-version "2.6" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://gitlab.common-lisp.net/parenscript/parenscript")
+ (commit commit)))
+ (file-name (git-file-name "parenscript" version))
+ (sha256
+ (base32
+ "1kbhgsjbikc73m5cwdp4d4fdafyqcr1b7b630qjrziql0nh6mi3k"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("cl-ppcre" ,sbcl-cl-ppcre)
+ ("anaphora" ,sbcl-anaphora)
+ ("named-readtables" ,sbcl-named-readtables)))
+ (home-page "https://common-lisp.net/project/parenscript/")
+ (synopsis "Translator from a subset of Common Lisp to JavaScript")
+ (description
+ "Parenscript is a translator from an extended subset of Common Lisp to
+JavaScript. Parenscript code can run almost identically on both the
+browser (as JavaScript) and server (as Common Lisp).
+
+Parenscript code is treated the same way as Common Lisp code, making the full
+power of Lisp macros available for JavaScript. This provides a web
+development environment that is unmatched in its ability to reduce code
+duplication and provide advanced meta-programming facilities to web
+developers.
+
+At the same time, Parenscript is different from almost all other \"language
+X\" to JavaScript translators in that it imposes almost no overhead:
+
+@itemize
+@item No run-time dependencies: Any piece of Parenscript code is runnable
+as-is. There are no JavaScript files to include.
+@item Native types: Parenscript works entirely with native JavaScript data
+types. There are no new types introduced, and object prototypes are not
+touched.
+@item Native calling convention: Any JavaScript code can be called without the
+need for bindings. Likewise, Parenscript can be used to make efficient,
+self-contained JavaScript libraries.
+@item Readable code: Parenscript generates concise, formatted, idiomatic
+JavaScript code. Identifier names are preserved. This enables seamless
+debugging in tools like Firebug.
+@item Efficiency: Parenscript introduces minimal overhead for advanced Common
+Lisp features. The generated code is almost as fast as hand-written
+JavaScript.
+@end itemize\n")
+ (license license:bsd-3))))
+
+(define-public cl-parenscript
+ (sbcl-package->cl-source-package sbcl-parenscript))
+
+(define-public ecl-parenscript
+ (sbcl-package->ecl-package sbcl-parenscript))
+
+(define-public sbcl-cl-json
+ (let ((commit "6dfebb9540bfc3cc33582d0c03c9ec27cb913e79"))
+ (package
+ (name "sbcl-cl-json")
+ (version (git-version "0.5" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/hankhero/cl-json")
+ (commit commit)))
+ (file-name (git-file-name "cl-json" version))
+ (sha256
+ (base32
+ "0fx3m3x3s5ji950yzpazz4s0img3l6b3d6l3jrfjv0lr702496lh"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (home-page "https://github.com/hankhero/cl-json")
+ (synopsis "JSON encoder and decoder for Common-Lisp")
+ (description
+ "@command{cl-json} provides an encoder of Lisp objects to JSON format
+and a corresponding decoder of JSON data to Lisp objects. Both the encoder
+and the decoder are highly customizable; at the same time, the default
+settings ensure a very simple mode of operation, similar to that provided by
+@command{yason} or @command{st-json}.")
+ (license license:expat))))
+
+(define-public cl-json
+ (sbcl-package->cl-source-package sbcl-cl-json))
+
+(define-public ecl-cl-json
+ (sbcl-package->ecl-package sbcl-cl-json))
+
+(define-public sbcl-unix-opts
+ (package
+ (name "sbcl-unix-opts")
+ (version "0.1.7")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/libre-man/unix-opts")
+ (commit version)))
+ (file-name (git-file-name "unix-opts" version))
+ (sha256
+ (base32
+ "08djdi1ard09fijb7w9bdmhmwd98b1hzmcnjw9fqjiqa0g3b44rr"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/hankhero/cl-json")
+ (synopsis "Unix-style command line options parser")
+ (description
+ "This is a minimalistic parser of command line options. The main
+advantage of the library is the ability to concisely define command line
+options once and then use this definition for parsing and extraction of
+command line arguments, as well as printing description of command line
+options (you get --help for free). This way you don't need to repeat
+yourself. Also, @command{unix-opts} doesn't depend on anything and allows to
+precisely control behavior of the parser via Common Lisp restarts.")
+ (license license:expat)))
+
+(define-public cl-unix-opts
+ (sbcl-package->cl-source-package sbcl-unix-opts))
+
+(define-public ecl-unix-opts
+ (sbcl-package->ecl-package sbcl-unix-opts))
+
+(define-public sbcl-trivial-garbage
+ (package
+ (name "sbcl-trivial-garbage")
+ (version "0.21")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/trivial-garbage/trivial-garbage.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "trivial-garbage" version))
+ (sha256
+ (base32 "0122jicfg7pca1wxw8zak1n92h5friqy60988ns0ysksj3fphw9n"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("rt" ,sbcl-rt)))
+ (home-page "https://common-lisp.net/project/trivial-garbage/")
+ (synopsis "Portable GC-related APIs for Common Lisp")
+ (description "@command{trivial-garbage} provides a portable API to
+finalizers, weak hash-tables and weak pointers on all major implementations of
+the Common Lisp programming language.")
+ (license license:public-domain)))
+
+(define-public cl-trivial-garbage
+ (sbcl-package->cl-source-package sbcl-trivial-garbage))
+
+(define-public ecl-trivial-garbage
+ (sbcl-package->ecl-package sbcl-trivial-garbage))
+
+(define-public sbcl-closer-mop
+ (let ((commit "fac29ce90e3a46e1fc6cf182190e193526fa9dbc"))
+ (package
+ (name "sbcl-closer-mop")
+ (version (git-version "1.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/pcostanza/closer-mop")
+ (commit commit)))
+ (sha256
+ (base32 "0hvh77y869h8fg9di5snyg85fxq6fdh9gj1igmx1g6j6j5x915dl"))
+ (file-name (git-file-name "closer-mop" version ))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/pcostanza/closer-mop")
+ (synopsis "Rectifies absent or incorrect CLOS MOP features")
+ (description "Closer to MOP is a compatibility layer that rectifies many
+of the absent or incorrect CLOS MOP features across a broad range of Common
+Lisp implementations.")
+ (license license:expat))))
+
+(define-public cl-closer-mop
+ (sbcl-package->cl-source-package sbcl-closer-mop))
+
+(define-public ecl-closer-mop
+ (sbcl-package->ecl-package sbcl-closer-mop))
+
+(define sbcl-cl-cffi-gtk-boot0
+ (let ((commit "29443c5aaca975709df8025c4649366d882033cb"))
+ (package
+ (name "sbcl-cl-cffi-gtk-boot0")
+ (version (git-version "0.11.2" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Ferada/cl-cffi-gtk/")
+ (commit commit)))
+ (file-name (git-file-name "cl-cffi-gtk" version))
+ (sha256
+ (base32
+ "0f6s92sf8xyzh1yksqx8bsy1sv0zmy0c13j3b8bavaba5hlxpxah"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("iterate" ,sbcl-iterate)
+ ("cffi" ,sbcl-cffi)
+ ("trivial-features" ,sbcl-trivial-features)))
+ (home-page "https://github.com/Ferada/cl-cffi-gtk/")
+ (synopsis "Common Lisp binding for GTK+3")
+ (description
+ "@command{cl-cffi-gtk} is a Lisp binding to GTK+ 3 (GIMP Toolkit) which
+is a library for creating graphical user interfaces.")
+ (license license:lgpl3))))
+
+(define-public sbcl-cl-cffi-gtk-glib
+ (package
+ (inherit sbcl-cl-cffi-gtk-boot0)
+ (name "sbcl-cl-cffi-gtk-glib")
+ (inputs
+ `(("glib" ,glib)
+ ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
+ (arguments
+ `(#:asd-file "glib/cl-cffi-gtk-glib.asd"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "glib/glib.init.lisp"
+ (("libglib|libgthread" all) (string-append
+ (assoc-ref inputs "glib") "/lib/" all))))))))))
+
+(define-public sbcl-cl-cffi-gtk-gobject
+ (package
+ (inherit sbcl-cl-cffi-gtk-boot0)
+ (name "sbcl-cl-cffi-gtk-gobject")
+ (inputs
+ `(("glib" ,glib)
+ ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
+ ("trivial-garbage" ,sbcl-trivial-garbage)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("closer-mop" ,sbcl-closer-mop)
+ ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
+ (arguments
+ `(#:asd-file "gobject/cl-cffi-gtk-gobject.asd"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "gobject/gobject.init.lisp"
+ (("libgobject" all) (string-append
+ (assoc-ref inputs "glib") "/lib/" all))))))))))
+
+(define-public sbcl-cl-cffi-gtk-gio
+ (package
+ (inherit sbcl-cl-cffi-gtk-boot0)
+ (name "sbcl-cl-cffi-gtk-gio")
+ (inputs
+ `(("glib" ,glib)
+ ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
+ ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
+ ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
+ (arguments
+ `(#:asd-file "gio/cl-cffi-gtk-gio.asd"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "gio/gio.init.lisp"
+ (("libgio" all)
+ (string-append
+ (assoc-ref inputs "glib") "/lib/" all))))))))))
+
+(define-public sbcl-cl-cffi-gtk-cairo
+ (package
+ (inherit sbcl-cl-cffi-gtk-boot0)
+ (name "sbcl-cl-cffi-gtk-cairo")
+ (inputs
+ `(("cairo" ,cairo)
+ ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
+ ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
+ (arguments
+ `(#:asd-file "cairo/cl-cffi-gtk-cairo.asd"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "cairo/cairo.init.lisp"
+ (("libcairo" all)
+ (string-append
+ (assoc-ref inputs "cairo") "/lib/" all))))))))))
+
+(define-public sbcl-cl-cffi-gtk-pango
+ (package
+ (inherit sbcl-cl-cffi-gtk-boot0)
+ (name "sbcl-cl-cffi-gtk-pango")
+ (inputs
+ `(("pango" ,pango)
+ ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
+ ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
+ ("cl-cffi-gtk-cairo" ,sbcl-cl-cffi-gtk-cairo)
+ ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
+ (arguments
+ `(#:asd-file "pango/cl-cffi-gtk-pango.asd"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "pango/pango.init.lisp"
+ (("libpango" all)
+ (string-append
+ (assoc-ref inputs "pango") "/lib/" all))))))))))
+
+(define-public sbcl-cl-cffi-gtk-gdk-pixbuf
+ (package
+ (inherit sbcl-cl-cffi-gtk-boot0)
+ (name "sbcl-cl-cffi-gtk-gdk-pixbuf")
+ (inputs
+ `(("gdk-pixbuf" ,gdk-pixbuf)
+ ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
+ ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
+ (arguments
+ `(#:asd-file "gdk-pixbuf/cl-cffi-gtk-gdk-pixbuf.asd"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "gdk-pixbuf/gdk-pixbuf.init.lisp"
+ (("libgdk_pixbuf" all)
+ (string-append
+ (assoc-ref inputs "gdk-pixbuf") "/lib/" all))))))))))
+
+(define-public sbcl-cl-cffi-gtk-gdk
+ (package
+ (inherit sbcl-cl-cffi-gtk-boot0)
+ (name "sbcl-cl-cffi-gtk-gdk")
+ (inputs
+ `(("gtk" ,gtk+)
+ ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
+ ("cl-cffi-gtk-gio" ,sbcl-cl-cffi-gtk-gio)
+ ("cl-cffi-gtk-gdk-pixbuf" ,sbcl-cl-cffi-gtk-gdk-pixbuf)
+ ("cl-cffi-gtk-cairo" ,sbcl-cl-cffi-gtk-cairo)
+ ("cl-cffi-gtk-pango" ,sbcl-cl-cffi-gtk-pango)
+ ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
+ (arguments
+ `(#:asd-file "gdk/cl-cffi-gtk-gdk.asd"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "gdk/gdk.init.lisp"
+ (("libgdk" all)
+ (string-append
+ (assoc-ref inputs "gtk") "/lib/" all)))
+ (substitute* "gdk/gdk.package.lisp"
+ (("libgtk" all)
+ (string-append
+ (assoc-ref inputs "gtk") "/lib/" all))))))))))
+
+(define-public sbcl-cl-cffi-gtk
+ (package
+ (inherit sbcl-cl-cffi-gtk-boot0)
+ (name "sbcl-cl-cffi-gtk")
+ (inputs
+ `(("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
+ ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
+ ("cl-cffi-gtk-gio" ,sbcl-cl-cffi-gtk-gio)
+ ("cl-cffi-gtk-gdk" ,sbcl-cl-cffi-gtk-gdk)
+ ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (arguments
+ `(#:asd-file "gtk/cl-cffi-gtk.asd"
+ #:test-asd-file "test/cl-cffi-gtk-test.asd"
+ ;; TODO: Tests fail with memory fault.
+ ;; See https://github.com/Ferada/cl-cffi-gtk/issues/24.
+ #:tests? #f))))
+
+(define-public cl-cffi-gtk
+ (sbcl-package->cl-source-package sbcl-cl-cffi-gtk))
+
+(define-public sbcl-cl-webkit
+ (let ((commit "cd2a9008e0c152e54755e8a7f07b050fe36bab31"))
+ (package
+ (name "sbcl-cl-webkit")
+ (version (git-version "2.4" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/jmercouris/cl-webkit")
+ (commit commit)))
+ (file-name (git-file-name "cl-webkit" version))
+ (sha256
+ (base32
+ "0f5lyn9i7xrn3g1bddga377mcbawkbxydijpg389q4n04gqj0vwf"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("cffi" ,sbcl-cffi)
+ ("cl-cffi-gtk" ,sbcl-cl-cffi-gtk)
+ ("webkitgtk" ,webkitgtk)))
+ (arguments
+ `(#:asd-file "webkit2/cl-webkit2.asd"
+ #:asd-system-name "cl-webkit2"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "webkit2/webkit2.init.lisp"
+ (("libwebkit2gtk" all)
+ (string-append
+ (assoc-ref inputs "webkitgtk") "/lib/" all))))))))
+ (home-page "https://github.com/jmercouris/cl-webkit")
+ (synopsis "Binding to WebKitGTK+ for Common Lisp")
+ (description
+ "@command{cl-webkit} is a binding to WebKitGTK+ for Common Lisp,
+currently targeting WebKit version 2. The WebKitGTK+ library adds web
+browsing capabilities to an application, leveraging the full power of the
+WebKit browsing engine.")
+ (license license:expat))))
+
+(define-public cl-webkit
+ (sbcl-package->cl-source-package sbcl-cl-webkit))
+
+(define-public sbcl-lparallel
+ (package
+ (name "sbcl-lparallel")
+ (version "2.8.4")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/lmj/lparallel/")
+ (commit (string-append "lparallel-" version))))
+ (file-name (git-file-name "lparallel" version))
+ (sha256
+ (base32
+ "0g0aylrbbrqsz0ahmwhvnk4cmc2931fllbpcfgzsprwnqqd7vwq9"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("trivial-garbage" ,sbcl-trivial-garbage)))
+ (home-page "https://lparallel.org/")
+ (synopsis "Parallelism for Common Lisp")
+ (description
+ "@command{lparallel} is a library for parallel programming in Common
+Lisp, featuring:
+
+@itemize
+@item a simple model of task submission with receiving queue,
+@item constructs for expressing fine-grained parallelism,
+@item asynchronous condition handling across thread boundaries,
+@item parallel versions of map, reduce, sort, remove, and many others,
+@item promises, futures, and delayed evaluation constructs,
+@item computation trees for parallelizing interconnected tasks,
+@item bounded and unbounded FIFO queues,
+@item high and low priority tasks,
+@item task killing by category,
+@item integrated timeouts.
+@end itemize\n")
+ (license license:expat)))
+
+(define-public cl-lparallel
+ (sbcl-package->cl-source-package sbcl-lparallel))
+
+(define-public ecl-lparallel
+ (sbcl-package->ecl-package sbcl-lparallel))
+
+(define-public sbcl-cl-markup
+ (let ((commit "e0eb7debf4bdff98d1f49d0f811321a6a637b390"))
+ (package
+ (name "sbcl-cl-markup")
+ (version (git-version "0.1" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/arielnetworks/cl-markup/")
+ (commit commit)))
+ (file-name (git-file-name "cl-markup" version))
+ (sha256
+ (base32
+ "10l6k45971dl13fkdmva7zc6i453lmq9j4xax2ci6pjzlc6xjhp7"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/arielnetworks/cl-markup/")
+ (synopsis "Markup generation library for Common Lisp")
+ (description
+ "A modern markup generation library for Common Lisp that features:
+
+@itemize
+@item Fast (even faster through compiling the code)
+@item Safety
+@item Support for multiple document types (markup, xml, html, html5, xhtml)
+@item Output with doctype
+@item Direct output to stream
+@end itemize\n")
+ (license license:lgpl3+))))
+
+(define-public cl-markup
+ (sbcl-package->cl-source-package sbcl-cl-markup))
+
+(define-public ecl-cl-markup
+ (sbcl-package->ecl-package sbcl-cl-markup))
+
+(define-public sbcl-cl-css
+ (let ((commit "8fe654c8f0cf95b300718101cce4feb517f78e2f"))
+ (package
+ (name "sbcl-cl-css")
+ (version (git-version "0.1" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/inaimathi/cl-css/")
+ (commit commit)))
+ (file-name (git-file-name "cl-css" version))
+ (sha256
+ (base32
+ "1lc42zi2sw11fl2589sc19nr5sd2p0wy7wgvgwaggxa5f3ajhsmd"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/inaimathi/cl-css/")
+ (synopsis "Non-validating, inline CSS generator for Common Lisp")
+ (description
+ "This is a dead-simple, non validating, inline CSS generator for Common
+Lisp. Its goals are axiomatic syntax, simple implementation to support
+portability, and boilerplate reduction in CSS.")
+ (license license:expat))))
+
+(define-public cl-css
+ (sbcl-package->cl-source-package sbcl-cl-css))
+
+(define-public ecl-cl-css
+ (sbcl-package->ecl-package sbcl-cl-css))
+
+(define-public sbcl-portable-threads
+ (let ((commit "c0e61a1faeb0583c80fd3f20b16cc4c555226920"))
+ (package
+ (name "sbcl-portable-threads")
+ (version (git-version "2.3" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/binghe/portable-threads/")
+ (commit commit)))
+ (file-name (git-file-name "portable-threads" version))
+ (sha256
+ (base32
+ "03fmxyarc0xf4kavwkfa0a2spkyfrz6hbgbi9y4q7ny5aykdyfaq"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(;; Tests seem broken.
+ #:tests? #f))
+ (home-page "https://github.com/binghe/portable-threads")
+ (synopsis "Portable threads (and scheduled and periodic functions) API for Common Lisp")
+ (description
+ "Portable Threads (and Scheduled and Periodic Functions) API for Common
+Lisp (from GBBopen project).")
+ (license license:asl2.0))))
+
+(define-public cl-portable-threads
+ (sbcl-package->cl-source-package sbcl-portable-threads))
+
+(define-public ecl-portable-threada
+ (sbcl-package->ecl-package sbcl-portable-threads))
+
+(define-public sbcl-usocket-boot0
+ ;; usocket's test rely on usocket-server which depends on usocket itself.
+ ;; We break this cyclic dependency with -boot0 that packages usocket.
+ (let ((commit "86e7efbfe50101931edf4b67cdcfa7e221ecfde9"))
+ (package
+ (name "sbcl-usocket-boot0")
+ (version (git-version "0.7.1" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/usocket/usocket/")
+ (commit commit)))
+ (file-name (git-file-name "usocket" version))
+ (sha256
+ (base32
+ "1lk6ipakrib7kdgzw44hrgmls9akp5pz4h35yynw0k5zwmmq6374"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("split-sequence" ,sbcl-split-sequence)))
+ (arguments
+ `(#:tests? #f
+ #:asd-system-name "usocket"))
+ (home-page "https://common-lisp.net/project/usocket/")
+ (synopsis "Universal socket library for Common Lisp (server side)")
+ (description
+ "This library strives to provide a portable TCP/IP and UDP/IP socket
+interface for as many Common Lisp implementations as possible, while keeping
+the abstraction and portability layer as thin as possible.")
+ (license license:expat))))
+
+(define-public sbcl-usocket-server
+ (package
+ (inherit sbcl-usocket-boot0)
+ (name "sbcl-usocket-server")
+ (inputs
+ `(("usocket" ,sbcl-usocket-boot0)
+ ("portable-threads" ,sbcl-portable-threads)))
+ (arguments
+ '(#:asd-system-name "usocket-server"))
+ (synopsis "Universal socket library for Common Lisp (server side)")))
+
+(define-public cl-usocket-server
+ (sbcl-package->cl-source-package sbcl-usocket-server))
+
+(define-public ecl-socket-server
+ (sbcl-package->ecl-package sbcl-usocket-server))
+
+(define-public sbcl-usocket
+ (package
+ (inherit sbcl-usocket-boot0)
+ (name "sbcl-usocket")
+ (arguments
+ ;; FIXME: Tests need network access?
+ `(#:tests? #f))
+ (native-inputs
+ ;; Testing only.
+ `(("usocket-server" ,sbcl-usocket-server)
+ ("rt" ,sbcl-rt)))))
+
+(define-public cl-usocket
+ (sbcl-package->cl-source-package sbcl-usocket))
+
+(define-public ecl-socket
+ (sbcl-package->ecl-package sbcl-usocket))
+
+(define-public sbcl-s-xml
+ (package
+ (name "sbcl-s-xml")
+ (version "3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri "https://common-lisp.net/project/s-xml/s-xml.tgz")
+ (sha256
+ (base32
+ "061qcr0dzshsa38s5ma4ay924cwak2nq9gy59dw6v9p0qb58nzjf"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://common-lisp.net/project/s-xml/")
+ (synopsis "Simple XML parser implemented in Common Lisp")
+ (description
+ "S-XML is a simple XML parser implemented in Common Lisp. This XML
+parser implementation has the following features:
+
+@itemize
+@item It works (handling many common XML usages).
+@item It is very small (the core is about 700 lines of code, including
+comments and whitespace).
+@item It has a core API that is simple, efficient and pure functional, much
+like that from SSAX (see also http://ssax.sourceforge.net).
+@item It supports different DOM models: an XSML-based one, an LXML-based one
+and a classic xml-element struct based one.
+@item It is reasonably time and space efficient (internally avoiding garbage
+generatation as much as possible).
+@item It does support CDATA.
+@item It should support the same character sets as your Common Lisp
+implementation.
+@item It does support XML name spaces.
+@end itemize
+
+This XML parser implementation has the following limitations:
+
+@itemize
+@item It does not support any special tags (like processing instructions).
+@item It is not validating, even skips DTD's all together.
+@end itemize\n")
+ (license license:lgpl3+)))
+
+(define-public cl-s-xml
+ (sbcl-package->cl-source-package sbcl-s-xml))
+
+(define-public ecl-s-xml
+ (sbcl-package->ecl-package sbcl-s-xml))
+
+(define-public sbcl-s-xml-rpc
+ (package
+ (name "sbcl-s-xml-rpc")
+ (version "7")
+ (source
+ (origin
+ (method url-fetch)
+ (uri "https://common-lisp.net/project/s-xml-rpc/s-xml-rpc.tgz")
+ (sha256
+ (base32
+ "02z7k163d51v0pzk8mn1xb6h5s6x64gjqkslhwm3a5x26k2gfs11"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("s-xml" ,sbcl-s-xml)))
+ (home-page "https://common-lisp.net/project/s-xml-rpc/")
+ (synopsis "Implementation of XML-RPC in Common Lisp for both client and server")
+ (description
+ "S-XML-RPC is an implementation of XML-RPC in Common Lisp for both
+client and server.")
+ (license license:lgpl3+)))
+
+(define-public cl-s-xml-rpc
+ (sbcl-package->cl-source-package sbcl-s-xml-rpc))
+
+(define-public ecl-s-xml-rpc
+ (sbcl-package->ecl-package sbcl-s-xml-rpc))
+
+(define-public sbcl-trivial-clipboard
+ (let ((commit "5af3415d1484e6d69a1b5c178f24680d9fd01796"))
+ (package
+ (name "sbcl-trivial-clipboard")
+ (version (git-version "0.0.0.0" "2" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/snmsts/trivial-clipboard")
+ (commit commit)))
+ (file-name (git-file-name "trivial-clipboard" version))
+ (sha256
+ (base32
+ "1gb515z5yq6h5548pb1fwhmb0hhq1ssyb78pvxh4alq799xipxs9"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("xclip" ,xclip)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/text.lisp"
+ (("\\(executable-find \"xclip\"\\)")
+ (string-append "(executable-find \""
+ (assoc-ref inputs "xclip")
+ "/bin/xclip\")"))))))))
+ (home-page "https://github.com/snmsts/trivial-clipboard")
+ (synopsis "Access system clipboard in Common Lisp")
+ (description
+ "@command{trivial-clipboard} gives access to the system clipboard.")
+ (license license:expat))))
+
+(define-public cl-trivial-clipboard
+ (sbcl-package->cl-source-package sbcl-trivial-clipboard))
+
+(define-public ecl-trivial-clipboard
+ (sbcl-package->ecl-package sbcl-trivial-clipboard))
+
+(define-public sbcl-trivial-backtrace
+ (let ((commit "ca81c011b86424a381a7563cea3b924f24e6fbeb")
+ (revision "1"))
+ (package
+ (name "sbcl-trivial-backtrace")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/gwkkwg/trivial-backtrace.git")
+ (commit commit)))
+ (file-name (git-file-name "trivial-backtrace" version))
+ (sha256
+ (base32 "10p41p43skj6cimdg8skjy7372s8v2xpkg8djjy0l8rm45i654k1"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("sbcl-lift" ,sbcl-lift)))
+ (home-page "https://common-lisp.net/project/trivial-backtrace/")
+ (synopsis "Portable simple API to work with backtraces in Common Lisp")
+ (description
+ "On of the many things that didn't quite get into the Common Lisp
+standard was how to get a Lisp to output its call stack when something has
+gone wrong. As such, each Lisp has developed its own notion of what to
+display, how to display it, and what sort of arguments can be used to
+customize it. @code{trivial-backtrace} is a simple solution to generating a
+backtrace portably.")
+ (license license:expat))))
+
+(define-public cl-trivial-backtrace
+ (sbcl-package->cl-source-package sbcl-trivial-backtrace))
+
+(define-public sbcl-rfc2388
+ (let ((commit "591bcf7e77f2c222c43953a80f8c297751dc0c4e")
+ (revision "1"))
+ (package
+ (name "sbcl-rfc2388")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/jdz/rfc2388.git")
+ (commit commit)))
+ (file-name (git-file-name "rfc2388" version))
+ (sha256
+ (base32 "0phh5n3clhl9ji8jaxrajidn22d3f0aq87mlbfkkxlnx2pnw694k"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/jdz/rfc2388/")
+ (synopsis "An implementation of RFC 2388 in Common Lisp")
+ (description
+ "This package contains an implementation of RFC 2388, which is used to
+process form data posted with HTTP POST method using enctype
+\"multipart/form-data\".")
+ (license license:bsd-2))))
+
+(define-public cl-rfc2388
+ (sbcl-package->cl-source-package sbcl-rfc2388))
+
+(define-public sbcl-md5
+ (package
+ (name "sbcl-md5")
+ (version "2.0.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://github.com/pmai/md5/archive/release-" version ".tar.gz"))
+ (sha256
+ (base32 "19yl9n0pjdz5gw4qi711lka97xcd9f81ylg434hk7jwn9f2s6w11"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/pmai/md5")
+ (synopsis
+ "Common Lisp implementation of the MD5 Message-Digest Algorithm (RFC 1321)")
+ (description
+ "This package implements The MD5 Message-Digest Algorithm, as defined in
+RFC 1321 by R. Rivest, published April 1992.")
+ (license license:public-domain)))
+
+(define-public cl-md5
+ (sbcl-package->cl-source-package sbcl-md5))
+
+(define-public sbcl-cl+ssl
+ (let ((commit "141ae91416bc40f1618dc07e48429b84388aa599")
+ (revision "1"))
+ (package
+ (name "sbcl-cl+ssl")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/cl-plus-ssl/cl-plus-ssl.git")
+ (commit commit)))
+ (file-name (git-file-name "cl+ssl" version))
+ (sha256
+ (base32 "1s0hg1h9sf8q89v0yrxmzg5f5sng29rgx3n21r9h9yql8351myan"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/reload.lisp"
+ (("libssl.so" all)
+ (string-append
+ (assoc-ref inputs "openssl") "/lib/" all))))))))
+ (inputs
+ `(("openssl" ,openssl)
+ ("sbcl-cffi" ,sbcl-cffi)
+ ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)
+ ("sbcl-flexi-streams" ,sbcl-flexi-streams)
+ ("sbcl-bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("sbcl-trivial-garbage" ,sbcl-trivial-garbage)
+ ("sbcl-alexandria" ,sbcl-alexandria)
+ ("sbcl-trivial-features" ,sbcl-trivial-features)))
+ (home-page "http://common-lisp.net/project/cl-plus-ssl/")
+ (synopsis "Common Lisp bindings to OpenSSL")
+ (description
+ "This library is a fork of SSL-CMUCL. The original SSL-CMUCL source
+code was written by Eric Marsden and includes contributions by Jochen Schmidt.
+Development into CL+SSL was done by David Lichteblau.")
+ (license license:expat))))
+
+(define-public cl-cl+ssl
+ (sbcl-package->cl-source-package sbcl-cl+ssl))
+
+(define-public sbcl-kmrcl
+ (let ((version "1.109.0")
+ (commit "5260068b2eb735af6796740c2db4955afac21636")
+ (revision "1"))
+ (package
+ (name "sbcl-kmrcl")
+ (version (git-version version revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "http://git.kpe.io/kmrcl.git/")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1va7xjgzfv674bpsli674i7zj3f7wg5kxic41kz18r6hh4n52dfv"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; Tests fail with: :FORCE and :FORCE-NOT arguments not allowed in a
+ ;; nested call to ASDF/OPERATE:OPERATE unless identically to toplevel
+ '(#:tests? #f))
+ (inputs
+ `(("sbcl-rt" ,sbcl-rt)))
+ (home-page "http://files.kpe.io/kmrcl/")
+ (synopsis "General utilities for Common Lisp programs")
+ (description
+ "KMRCL is a collection of utilities used by a number of Kevin
+Rosenberg's CL packages.")
+ (license license:llgpl))))
+
+(define-public cl-kmrcl
+ (sbcl-package->cl-source-package sbcl-kmrcl))
+
+(define-public sbcl-cl-base64
+ (let ((version "3.3.3"))
+ (package
+ (name "sbcl-cl-base64")
+ (version version)
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "http://git.kpe.io/cl-base64.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-base64" version))
+ (sha256
+ (base32 "1dw6j7n6gsd2qa0p0rbsjxj00acxx3i9ca1qkgl0liy8lpnwkypl"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; Tests fail with: :FORCE and :FORCE-NOT arguments not allowed
+ ;; in a nested call to ASDF/OPERATE:OPERATE unless identically
+ ;; to toplevel
+ '(#:tests? #f))
+ (inputs
+ `(("sbcl-ptester" ,sbcl-ptester)
+ ("sbcl-kmrcl" ,sbcl-kmrcl)))
+ (home-page "http://files.kpe.io/cl-base64/")
+ (synopsis
+ "Common Lisp package to encode and decode base64 with URI support")
+ (description
+ "This package provides highly optimized base64 encoding and decoding.
+Besides conversion to and from strings, integer conversions are supported.
+Encoding with Uniform Resource Identifiers is supported by using a modified
+encoding table that uses only URI-compatible characters.")
+ (license license:bsd-3))))
+
+(define-public cl-base64
+ (sbcl-package->cl-source-package sbcl-cl-base64))
+
+(define-public sbcl-chunga
+ (package
+ (name "sbcl-chunga")
+ (version "1.1.7")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/edicl/chunga.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0jzn3nyb3f22gm983rfk99smqs3mhb9ivjmasvhq9qla5cl9pyhd"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)))
+ (home-page "https://edicl.github.io/chunga/")
+ (synopsis "Portable chunked streams for Common Lisp")
+ (description
+ "Chunga implements streams capable of chunked encoding on demand as
+defined in RFC 2616.")
+ (license license:bsd-2)))
+
+(define-public cl-chunga
+ (sbcl-package->cl-source-package sbcl-chunga))
+
+(define-public sbcl-cl-who
+ (let ((version "1.1.4")
+ (commit "2c08caa4bafba720409af9171feeba3f32e86d32")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-who")
+ (version (git-version version revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/edicl/cl-who.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0yjb6sr3yazm288m318kqvj9xk8rm9n1lpimgf65ymqv0i5agxsb"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("sbcl-flexi-streams" ,sbcl-flexi-streams)))
+ (home-page "https://edicl.github.io/cl-who/")
+ (synopsis "Yet another Lisp markup language")
+ (description
+ "There are plenty of Lisp Markup Languages out there - every Lisp
+programmer seems to write at least one during his career - and CL-WHO (where
+WHO means \"with-html-output\" for want of a better acronym) is probably just
+as good or bad as the next one.")
+ (license license:bsd-2))))
+
+(define-public cl-cl-who
+ (sbcl-package->cl-source-package sbcl-cl-who))
+
+(define-public sbcl-chipz
+ (let ((version "0.8")
+ (commit "75dfbc660a5a28161c57f115adf74c8a926bfc4d")
+ (revision "1"))
+ (package
+ (name "sbcl-chipz")
+ (version (git-version version revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/froydnj/chipz.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0plx4rs39zbs4gjk77h4a2q11zpy75fh9v8hnxrvsf8fnakajhwg"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("sbcl-flexi-streams" ,sbcl-flexi-streams)))
+ (home-page "http://method-combination.net/lisp/chipz/")
+ (synopsis
+ "Common Lisp library for decompressing deflate, zlib, gzip, and bzip2
+data")
+ (description
+ "DEFLATE data, defined in RFC1951, forms the core of popular
+compression formats such as zlib (RFC 1950) and gzip (RFC 1952). As such,
+Chipz also provides for decompressing data in those formats as well. BZIP2 is
+the format used by the popular compression tool bzip2.")
+ ;; The author describes it as "MIT-like"
+ (license license:expat))))
+
+(define-public cl-chipz
+ (sbcl-package->cl-source-package sbcl-chipz))
+
+(define-public sbcl-drakma
+ (let ((version "2.0.4")
+ (commit "7647c0ae842ff2058624e53979c7f297760c97a7")
+ (revision "1"))
+ (package
+ (name "sbcl-drakma")
+ (version (git-version version revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/edicl/drakma.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1c4i9wakhj5pxfyyykxshdmv3180sbkrx6fcyynikmc0jd0rh84r"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("sbcl-puri" ,sbcl-puri)
+ ("sbcl-cl-base64" ,sbcl-cl-base64)
+ ("sbcl-chunga" ,sbcl-chunga)
+ ("sbcl-flexi-streams" ,sbcl-flexi-streams)
+ ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
+ ("sbcl-chipz" ,sbcl-chipz)
+ ("sbcl-usocket" ,sbcl-usocket)
+ ("sbcl-cl+ssl" ,sbcl-cl+ssl)))
+ (native-inputs
+ `(("sbcl-fiveam" ,sbcl-fiveam)))
+ (home-page "https://edicl.github.io/drakma/")
+ (synopsis "HTTP client written in Common Lisp")
+ (description
+ "Drakma is a full-featured HTTP client implemented in Common Lisp. It
+knows how to handle HTTP/1.1 chunking, persistent connections, re-usable
+sockets, SSL, continuable uploads, file uploads, cookies, and more.")
+ (license license:bsd-2))))
+
+(define-public cl-drakma
+ (sbcl-package->cl-source-package sbcl-drakma))
+
+(define-public sbcl-hunchentoot
+ (package
+ (name "sbcl-hunchentoot")
+ (version "1.2.38")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/edicl/hunchentoot.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "hunchentoot" version))
+ (sha256
+ (base32 "1anpcad7w045m4rsjs1f3xdhjwx5cppq1h0vlb3q7dz81fi3i6yq"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("sbcl-cl-who" ,sbcl-cl-who)
+ ("sbcl-drakma" ,sbcl-drakma)))
+ (inputs
+ `(("sbcl-chunga" ,sbcl-chunga)
+ ("sbcl-cl-base64" ,sbcl-cl-base64)
+ ("sbcl-cl-fad" ,sbcl-cl-fad)
+ ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
+ ("sbcl-flexi-streams" ,sbcl-flexi-streams)
+ ("sbcl-cl+ssl" ,sbcl-cl+ssl)
+ ("sbcl-md5" ,sbcl-md5)
+ ("sbcl-rfc2388" ,sbcl-rfc2388)
+ ("sbcl-trivial-backtrace" ,sbcl-trivial-backtrace)
+ ("sbcl-usocket" ,sbcl-usocket)))
+ (home-page "https://edicl.github.io/hunchentoot/")
+ (synopsis "Web server written in Common Lisp")
+ (description
+ "Hunchentoot is a web server written in Common Lisp and at the same
+time a toolkit for building dynamic websites. As a stand-alone web server,
+Hunchentoot is capable of HTTP/1.1 chunking (both directions), persistent
+connections (keep-alive), and SSL.")
+ (license license:bsd-2)))
+
+(define-public cl-hunchentoot
+ (sbcl-package->cl-source-package sbcl-hunchentoot))
+
+(define-public sbcl-trivial-types
+ (package
+ (name "sbcl-trivial-types")
+ (version "0.0.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/m2ym/trivial-types.git")
+ (commit "ee869f2b7504d8aa9a74403641a5b42b16f47d88")))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1s4cp9bdlbn8447q7w7f1wkgwrbvfzp20mgs307l5pxvdslin341"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/m2ym/trivial-types")
+ (synopsis "Trivial type definitions for Common Lisp")
+ (description
+ "TRIVIAL-TYPES provides missing but important type definitions such as
+PROPER-LIST, ASSOCIATION-LIST, PROPERTY-LIST and TUPLE.")
+ (license license:llgpl)))
+
+(define-public cl-trivial-types
+ (sbcl-package->cl-source-package sbcl-trivial-types))
+
+(define-public sbcl-cl-syntax
+ (package
+ (name "sbcl-cl-syntax")
+ (version "0.0.3")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/m2ym/cl-syntax.git")
+ (commit "03f0c329bbd55b8622c37161e6278366525e2ccc")))
+ (file-name (git-file-name "cl-syntax" version))
+ (sha256
+ (base32 "17ran8xp77asagl31xv8w819wafh6whwfc9p6dgx22ca537gyl4y"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-file "cl-syntax.asd"
+ #:asd-system-name "cl-syntax"))
+ (inputs `(("sbcl-trivial-types" ,sbcl-trivial-types)
+ ("sbcl-named-readtables" ,sbcl-named-readtables)))
+ (home-page "https://github.com/m2ym/cl-syntax")
+ (synopsis "Reader Syntax Coventions for Common Lisp and SLIME")
+ (description
+ "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp and SLIME.")
+ (license license:llgpl)))
+
+(define-public cl-syntax
+ (sbcl-package->cl-source-package sbcl-cl-syntax))
+
+(define-public sbcl-cl-annot
+ (let ((commit "c99e69c15d935eabc671b483349a406e0da9518d")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-annot")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/m2ym/cl-annot.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1wq1gs9jjd5m6iwrv06c2d7i5dvqsfjcljgbspfbc93cg5xahk4n"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-file "cl-annot.asd"
+ #:asd-system-name "cl-annot"))
+ (inputs
+ `(("sbcl-alexandria" ,sbcl-alexandria)))
+ (home-page "https://github.com/m2ym/cl-annot")
+ (synopsis "Python-like Annotation Syntax for Common Lisp.")
+ (description
+ "@code{cl-annot} is an general annotation library for Common Lisp.")
+ (license license:llgpl))))
+
+(define-public cl-annot
+ (sbcl-package->cl-source-package sbcl-cl-annot))
+
+(define-public sbcl-cl-syntax-annot
+ (package
+ (name "sbcl-cl-syntax-annot")
+ (version "0.0.3")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/m2ym/cl-syntax.git")
+ (commit "03f0c329bbd55b8622c37161e6278366525e2ccc")))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "17ran8xp77asagl31xv8w819wafh6whwfc9p6dgx22ca537gyl4y"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-file "cl-syntax-annot.asd"
+ #:asd-system-name "cl-syntax-annot"))
+ (inputs
+ `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
+ ("sbcl-cl-annot" ,sbcl-cl-annot)))
+ (home-page "https://github.com/m2ym/cl-syntax")
+ (synopsis "Reader Syntax Coventions for Common Lisp and SLIME")
+ (description
+ "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp and
+SLIME.")
+ (license license:llgpl)))
+
+(define-public cl-syntax-annot
+ (sbcl-package->cl-source-package sbcl-cl-syntax-annot))
+
+(define-public sbcl-cl-utilities
+ (let ((commit "dce2d2f6387091ea90357a130fa6d13a6776884b")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-utilities")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method url-fetch)
+ (uri
+ (string-append
+ "https://gitlab.common-lisp.net/cl-utilities/cl-utilities/-/"
+ "archive/" commit "/cl-utilities-" commit ".tar.gz"))
+ (sha256
+ (base32 "1r46v730yf96nk2vb24qmagv9x96xvd08abqwhf02ghgydv1a7z2"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-file "cl-utilities.asd"
+ #:asd-system-name "cl-utilities"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "rotate-byte.lisp"
+ (("in-package :cl-utilities)" all)
+ "in-package :cl-utilities)\n\n#+sbcl\n(require :sb-rotate-byte)")))))))
+ (home-page "http://common-lisp.net/project/cl-utilities")
+ (synopsis "A collection of semi-standard utilities")
+ (description
+ "On Cliki.net <http://www.cliki.net/Common%20Lisp%20Utilities>, there
+is a collection of Common Lisp Utilities, things that everybody writes since
+they're not part of the official standard. There are some very useful things
+there; the only problems are that they aren't implemented as well as you'd
+like (some aren't implemented at all) and they aren't conveniently packaged
+and maintained. It takes quite a bit of work to carefully implement utilities
+for common use, commented and documented, with error checking placed
+everywhere some dumb user might make a mistake.")
+ (license license:public-domain))))
+
+(define-public cl-utilities
+ (sbcl-package->cl-source-package sbcl-cl-utilities))
+
+(define-public sbcl-map-set
+ (let ((commit "7b4b545b68b8")
+ (revision "1"))
+ (package
+ (name "sbcl-map-set")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://bitbucket.org/tarballs_are_good/map-set/get/"
+ commit ".tar.gz"))
+ (sha256
+ (base32 "1sx5j5qdsy5fklspfammwb16kjrhkggdavm922a9q86jm5l0b239"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://bitbucket.org/tarballs_are_good/map-set")
+ (synopsis "Set-like data structure")
+ (description
+ "Implementation of a set-like data structure with constant time
+addition, removal, and random selection.")
+ (license license:bsd-3))))
+
+(define-public cl-map-set
+ (sbcl-package->cl-source-package sbcl-map-set))
+
+(define-public sbcl-quri
+ (let ((commit "76b75103f21ead092c9f715512fa82441ef61185")
+ (revision "1"))
+ (package
+ (name "sbcl-quri")
+ (version (git-version "0.1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/quri.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1ccbxsgzdibmzq33mmbmmz9vwl6l03xh6nbpsh1hkdvdcl7q0a60"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; Tests fail with: Component QURI-ASD::QURI-TEST not found,
+ ;; required by #<SYSTEM "quri">. Why?
+ '(#:tests? #f))
+ (native-inputs `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+ ("sbcl-prove" ,sbcl-prove)))
+ (inputs `(("sbcl-babel" ,sbcl-babel)
+ ("sbcl-split-sequence" ,sbcl-split-sequence)
+ ("sbcl-cl-utilities" ,sbcl-cl-utilities)
+ ("sbcl-alexandria" ,sbcl-alexandria)))
+ (home-page "https://github.com/fukamachi/quri")
+ (synopsis "Yet another URI library for Common Lisp")
+ (description
+ "QURI (pronounced \"Q-ree\") is yet another URI library for Common
+Lisp. It is intended to be a replacement of PURI.")
+ (license license:bsd-3))))
+
+(define-public cl-quri
+ (sbcl-package->cl-source-package sbcl-quri))
+
+(define-public sbcl-myway
+ (let ((commit "286230082a11f879c18b93f17ca571c5f676bfb7")
+ (revision "1"))
+ (package
+ (name "sbcl-myway")
+ (version (git-version "0.1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/myway.git")
+ (commit commit)))
+ (file-name (git-file-name "myway" version))
+ (sha256
+ (base32 "0briia9bk3lbr0frnx39d1qg6i38dm4j6z9w3yga3d40k6df4a90"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; Tests fail with: Component MYWAY-ASD::MYWAY-TEST not found, required
+ ;; by #<SYSTEM "myway">. Why?
+ '(#:tests? #f))
+ (native-inputs
+ `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+ ("sbcl-prove" ,sbcl-prove)))
+ (inputs
+ `(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
+ ("sbcl-quri" ,sbcl-quri)
+ ("sbcl-map-set" ,sbcl-map-set)))
+ (home-page "https://github.com/fukamachi/myway")
+ (synopsis "Sinatra-compatible URL routing library for Common Lisp")
+ (description "My Way is a Sinatra-compatible URL routing library.")
+ (license license:llgpl))))
+
+(define-public cl-myway
+ (sbcl-package->cl-source-package sbcl-myway))
+
+(define-public sbcl-xsubseq
+ (let ((commit "5ce430b3da5cda3a73b9cf5cee4df2843034422b")
+ (revision "1"))
+ (package
+ (name "sbcl-xsubseq")
+ (version (git-version "0.0.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/xsubseq")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1xz79q0p2mclf3sqjiwf6izdpb6xrsr350bv4mlmdlm6rg5r99px"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; Tests fail with: Component XSUBSEQ-ASD::XSUBSEQ-TEST not found,
+ ;; required by #<SYSTEM "xsubseq">. Why?
+ '(#:tests? #f))
+ (native-inputs
+ `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+ ("sbcl-prove" ,sbcl-prove)))
+ (home-page "https://github.com/fukamachi/xsubseq")
+ (synopsis "Efficient way to use \"subseq\"s in Common Lisp")
+ (description
+ "XSubseq provides functions to be able to handle \"subseq\"s more
+effieiently.")
+ (license license:bsd-2))))
+
+(define-public cl-xsubseq
+ (sbcl-package->cl-source-package sbcl-xsubseq))
+
+(define-public sbcl-smart-buffer
+ (let ((commit "09b9a9a0b3abaa37abe9a730f5aac2643dca4e62")
+ (revision "1"))
+ (package
+ (name "sbcl-smart-buffer")
+ (version (git-version "0.0.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/smart-buffer")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0qz1zzxx0wm5ff7gpgsq550a59p0qj594zfmm2rglj97dahj54l7"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; Tests fail with: Component SMART-BUFFER-ASD::SMART-BUFFER-TEST not
+ ;; found, required by #<SYSTEM "smart-buffer">. Why?
+ `(#:tests? #f))
+ (native-inputs
+ `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+ ("sbcl-prove" ,sbcl-prove)))
+ (inputs
+ `(("sbcl-xsubseq" ,sbcl-xsubseq)
+ ("sbcl-flexi-streams" ,sbcl-flexi-streams)))
+ (home-page "https://github.com/fukamachi/smart-buffer")
+ (synopsis "Smart octets buffer")
+ (description
+ "Smart-buffer provides an output buffer which changes the destination
+depending on content size.")
+ (license license:bsd-3))))
+
+(define-public cl-smart-buffer
+ (sbcl-package->cl-source-package sbcl-smart-buffer))
+
+(define-public sbcl-fast-http
+ (let ((commit "f9e7597191bae380503e20724fd493a24d024935")
+ (revision "1"))
+ (package
+ (name "sbcl-fast-http")
+ (version (git-version "0.2.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/fast-http")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0qdmwv2zm0sizxdb8nnclgwl0nfjcbjaimbakavikijw7lr9b4jp"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; Tests fail with: Component FAST-HTTP-ASD::FAST-HTTP-TEST not found,
+ ;; required by #<SYSTEM "fast-http">. Why?
+ `(#:tests? #f))
+ (native-inputs
+ `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+ ("sbcl-prove" ,sbcl-prove)))
+ (inputs
+ `(("sbcl-alexandria" ,sbcl-alexandria)
+ ("sbcl-proc-parse" ,sbcl-proc-parse)
+ ("sbcl-xsubseq" ,sbcl-xsubseq)
+ ("sbcl-smart-buffer" ,sbcl-smart-buffer)
+ ("sbcl-cl-utilities" ,sbcl-cl-utilities)))
+ (home-page "https://github.com/fukamachi/fast-http")
+ (synopsis "HTTP request/response parser for Common Lisp")
+ (description
+ "@code{fast-http} is a HTTP request/response protocol parser for Common
+Lisp.")
+ ;; Author specified the MIT license
+ (license license:expat))))
+
+(define-public cl-fast-http
+ (sbcl-package->cl-source-package sbcl-fast-http))
+
+(define-public sbcl-static-vectors
+ (let ((commit "0681eac1f49370cde03e64b077251e8abf47d702")
+ (revision "1"))
+ (package
+ (name "sbcl-static-vectors")
+ (version (git-version "1.8.3" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sionescu/static-vectors.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "138nlsq14hv8785ycjm6jw3i6ablhq8vcwys7q09y80arcgrg6r3"))))
+ (native-inputs
+ `(("sbcl-fiveam" ,sbcl-fiveam)))
+ (inputs
+ `(("sbcl-cffi-grovel" ,sbcl-cffi-grovel)
+ ("sbcl-cffi" ,sbcl-cffi)))
+ (build-system asdf-build-system/sbcl)
+ (home-page "http://common-lisp.net/projects/iolib/")
+ (synopsis "Allocate SIMPLE-ARRAYs in static memory")
+ (description
+ "With @code{static-vectors}, you can create vectors allocated in static
+memory.")
+ (license license:expat))))
+
+(define-public cl-static-vectors
+ (sbcl-package->cl-source-package sbcl-static-vectors))
+
+(define-public sbcl-marshal
+ (let ((commit "eff1b15f2b0af2f26f71ad6a4dd5c4beab9299ec")
+ (revision "1"))
+ (package
+ (name "sbcl-marshal")
+ (version (git-version "1.3.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/wlbr/cl-marshal.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "08qs6fhk38xpkkjkpcj92mxx0lgy4ygrbbzrmnivdx281syr0gwh"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/wlbr/cl-marshal")
+ (synopsis "Simple (de)serialization of Lisp datastructures")
+ (description
+ "Simple and fast marshalling of Lisp datastructures. Convert any object
+into a string representation, put it on a stream an revive it from there.
+Only minimal changes required to make your CLOS objects serializable.")
+ (license license:expat))))
+
+(define-public cl-marshal
+ (sbcl-package->cl-source-package sbcl-marshal))
+
+(define-public sbcl-checkl
+ (let ((commit "80328800d047fef9b6e32dfe6bdc98396aee3cc9")
+ (revision "1"))
+ (package
+ (name "sbcl-checkl")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/rpav/CheckL.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0bpisihx1gay44xmyr1dmhlwh00j0zzi04rp9fy35i95l2r4xdlx"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; Error while trying to load definition for system checkl-test from
+ ;; pathname [...]/checkl-test.asd: The function CHECKL:DEFINE-TEST-OP
+ ;; is undefined.
+ '(#:tests? #f))
+ (native-inputs
+ `(("sbcl-fiveam" ,sbcl-fiveam)))
+ (inputs
+ `(("sbcl-marshal" ,sbcl-marshal)))
+ (home-page "https://github.com/rpav/CheckL/")
+ (synopsis "Dynamic testing for Common Lisp")
+ (description
+ "CheckL lets you write tests dynamically, it checks resulting values
+against the last run.")
+ ;; The author specifies both LLGPL and "BSD", but the "BSD" license
+ ;; isn't specified anywhere, so I don't know which kind. LLGPL is the
+ ;; stronger of the two and so I think only listing this should suffice.
+ (license license:llgpl))))
+
+(define-public cl-checkl
+ (sbcl-package->cl-source-package sbcl-checkl))
+
+(define-public sbcl-fast-io
+ (let ((commit "dc3a71db7e9b756a88781ae9c342fe9d4bbab51c")
+ (revision "1"))
+ (package
+ (name "sbcl-fast-io")
+ (version (git-version "1.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/rpav/fast-io.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1jsp6xvi26ln6fdy5j5zi05xvan8jsqdhisv552dy6xg6ws8i1yq"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; Error while trying to load definition for system fast-io-test from
+ ;; pathname [...]/fast-io-test.asd: The function CHECKL:DEFINE-TEST-OP
+ ;; is undefined.
+ '(#:tests? #f))
+ (native-inputs
+ `(("sbcl-fiveam" ,sbcl-fiveam)
+ ("sbcl-checkl" ,sbcl-checkl)))
+ (inputs
+ `(("sbcl-alexandria" ,sbcl-alexandria)
+ ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)
+ ("sbcl-static-vectors" ,sbcl-static-vectors)))
+ (home-page "https://github.com/rpav/fast-io")
+ (synopsis "Fast octet-vector/stream I/O for Common Lisp")
+ (description
+ "Fast-io is about improving performance to octet-vectors and octet
+streams (though primarily the former, while wrapping the latter).")
+ ;; Author specifies this as NewBSD which is an alias
+ (license license:bsd-3))))
+
+(define-public cl-fast-io
+ (sbcl-package->cl-source-package sbcl-fast-io))
+
+(define-public sbcl-jonathan
+ (let ((commit "1f448b4f7ac8265e56e1c02b32ce383e65316300")
+ (revision "1"))
+ (package
+ (name "sbcl-jonathan")
+ (version (git-version "0.1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Rudolph-Miller/jonathan.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "14x4iwz3mbag5jzzzr4sb6ai0m9r4q4kyypbq32jmsk2dx1hi807"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; Tests fail with: Component JONATHAN-ASD::JONATHAN-TEST not found,
+ ;; required by #<SYSTEM "jonathan">. Why?
+ `(#:tests? #f))
+ (native-inputs
+ `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+ ("sbcl-prove" ,sbcl-prove)))
+ (inputs
+ `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
+ ("sbcl-cl-syntax-annot" ,sbcl-cl-syntax-annot)
+ ("sbcl-fast-io" ,sbcl-fast-io)
+ ("sbcl-proc-parse" ,sbcl-proc-parse)
+ ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)))
+ (home-page "http://rudolph-miller.github.io/jonathan/overview.html")
+ (synopsis "JSON encoder and decoder")
+ (description
+ "High performance JSON encoder and decoder. Currently support: SBCL,
+CCL.")
+ ;; Author specifies the MIT license
+ (license license:expat))))
+
+(define-public cl-jonathan
+ (sbcl-package->cl-source-package sbcl-jonathan))
+
+(define-public sbcl-http-body
+ (let ((commit "dd01dc4f5842e3d29728552e5163acce8386eb73")
+ (revision "1"))
+ (package
+ (name "sbcl-http-body")
+ (version (git-version "0.1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/http-body")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1jd06snjvxcprhapgfq8sx0y5lrldkvhf206ix6d5a23dd6zcmr0"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; Tests fail with: Component HTTP-BODY-ASD::HTTP-BODY-TEST not
+ ;; found, required by #<SYSTEM "http-body">. Why?
+ `(#:tests? #f))
+ (native-inputs
+ `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+ ("sbcl-prove" ,sbcl-prove)))
+ (inputs
+ `(("sbcl-fast-http" ,sbcl-fast-http)
+ ("sbcl-jonathan" ,sbcl-jonathan)
+ ("sbcl-quri" ,sbcl-quri)))
+ (home-page "https://github.com/fukamachi/http-body")
+ (synopsis "HTTP POST data parser")
+ (description
+ "HTTP-Body parses HTTP POST data and returns POST parameters. It
+supports application/x-www-form-urlencoded, application/json, and
+multipart/form-data.")
+ (license license:bsd-2))))
+
+(define-public cl-http-body
+ (sbcl-package->cl-source-package sbcl-http-body))
+
+(define-public sbcl-circular-streams
+ (let ((commit "e770bade1919c5e8533dd2078c93c3d3bbeb38df")
+ (revision "1"))
+ (package
+ (name "sbcl-circular-streams")
+ (version (git-version "0.1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/circular-streams")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1wpw6d5cciyqcf92f7mvihak52pd5s47kk4qq6f0r2z2as68p5rs"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; The tests depend on cl-test-more which is now prove. Prove
+ ;; tests aren't working for some reason.
+ `(#:tests? #f))
+ (inputs
+ `(("sbcl-fast-io" ,sbcl-fast-io)
+ ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)))
+ (home-page "https://github.com/fukamachi/circular-streams")
+ (synopsis "Circularly readable streams for Common Lisp")
+ (description
+ "Circular-Streams allows you to read streams circularly by wrapping real
+streams. Once you reach end-of-file of a stream, it's file position will be
+reset to 0 and you're able to read it again.")
+ (license license:llgpl))))
+
+(define-public cl-circular-streams
+ (sbcl-package->cl-source-package sbcl-circular-streams))
+
+(define-public sbcl-lack-request
+ (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
+ (revision "1"))
+ (package
+ (name "sbcl-lack-request")
+ (version (git-version "0.1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/lack.git")
+ (commit commit)))
+ (file-name (git-file-name "lack-request" version))
+ (sha256
+ (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-file "lack-request.asd"
+ #:asd-system-name "lack-request"
+ #:test-asd-file "t-lack-request.asd"
+ ;; XXX: Component :CLACK-TEST not found
+ #:tests? #f))
+ (native-inputs
+ `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+ ("sbcl-prove" ,sbcl-prove)))
+ (inputs
+ `(("sbcl-quri" ,sbcl-quri)
+ ("sbcl-http-body" ,sbcl-http-body)
+ ("sbcl-circular-streams" ,sbcl-circular-streams)))
+ (home-page "https://github.com/fukamachi/lack")
+ (synopsis "Lack, the core of Clack")
+ (description
+ "Lack is a Common Lisp library which allows web applications to be
+constructed of modular components. It was originally a part of Clack, however
+it's going to be rewritten as an individual project since Clack v2 with
+performance and simplicity in mind.")
+ (license license:llgpl))))
+
+(define-public cl-lack-request
+ (sbcl-package->cl-source-package sbcl-lack-request))
+
+(define-public sbcl-local-time
+ (let ((commit "beac054eef428552b63d4ae7820c32ffef9a3015")
+ (revision "1"))
+ (package
+ (name "sbcl-local-time")
+ (version (git-version "1.0.6" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/dlowe-net/local-time.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0xhkmgxh41dg2wwlsp0h2l41jp144xn4gpxhh0lna6kh0560w2cc"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; TODO: Component :STEFIL not found, required by #<SYSTEM
+ ;; "local-time/test">
+ '(#:tests? #f))
+ (native-inputs
+ `(("stefil" ,sbcl-hu.dwim.stefil)))
+ (inputs
+ `(("sbcl-cl-fad" ,sbcl-cl-fad)))
+ (home-page "https://common-lisp.net/project/local-time/")
+ (synopsis "Time manipulation library for Common Lisp")
+ (description
+ "The LOCAL-TIME library is a Common Lisp library for the manipulation of
+dates and times. It is based almost entirely upon Erik Naggum's paper \"The
+Long Painful History of Time\".")
+ (license license:expat))))
+
+(define-public cl-local-time
+ (sbcl-package->cl-source-package sbcl-local-time))
+
+(define-public sbcl-lack-response
+ (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
+ (revision "1"))
+ (package
+ (name "sbcl-lack-response")
+ (version (git-version "0.1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/lack.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-file "lack-response.asd"
+ #:asd-system-name "lack-response"
+ ;; XXX: no tests for lack-response.
+ #:tests? #f))
+ (native-inputs
+ `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+ ("sbcl-prove" ,sbcl-prove)))
+ (inputs
+ `(("sbcl-quri" ,sbcl-quri)
+ ("sbcl-http-body" ,sbcl-http-body)
+ ("sbcl-circular-streams" ,sbcl-circular-streams)
+ ("sbcl-local-time" ,sbcl-local-time)))
+ (home-page "https://github.com/fukamachi/lack")
+ (synopsis "Lack, the core of Clack")
+ (description
+ "Lack is a Common Lisp library which allows web applications to be
+constructed of modular components. It was originally a part of Clack, however
+it's going to be rewritten as an individual project since Clack v2 with
+performance and simplicity in mind.")
+ (license license:llgpl))))
+
+(define-public cl-lack-response
+ (sbcl-package->cl-source-package sbcl-lack-response))
+
+(define-public sbcl-lack-component
+ (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
+ (revision "1"))
+ (package
+ (name "sbcl-lack-component")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/lack.git")
+ (commit commit)))
+ (file-name (git-file-name "lack-component" version))
+ (sha256
+ (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-file "lack-component.asd"
+ #:asd-system-name "lack-component"
+ #:test-asd-file "t-lack-component.asd"
+ ;; XXX: Component :LACK-TEST not found
+ #:tests? #f))
+ (native-inputs
+ `(("prove-asdf" ,sbcl-prove-asdf)))
+ (home-page "https://github.com/fukamachi/lack")
+ (synopsis "Lack, the core of Clack")
+ (description
+ "Lack is a Common Lisp library which allows web applications to be
+constructed of modular components. It was originally a part of Clack, however
+it's going to be rewritten as an individual project since Clack v2 with
+performance and simplicity in mind.")
+ (license license:llgpl))))
+
+(define-public cl-lack-component
+ (sbcl-package->cl-source-package sbcl-lack-component))
+
+(define-public sbcl-lack-util
+ (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
+ (revision "1"))
+ (package
+ (name "sbcl-lack-util")
+ (version (git-version "0.1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/lack.git")
+ (commit commit)))
+ (file-name (git-file-name "lack-util" version))
+ (sha256
+ (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-file "lack-util.asd"
+ #:asd-system-name "lack-util"
+ #:test-asd-file "t-lack-util.asd"
+ ;; XXX: Component :LACK-TEST not found
+ #:tests? #f))
+ (native-inputs
+ `(("prove-asdf" ,sbcl-prove-asdf)))
+ (inputs
+ `(("sbcl-ironclad" ,sbcl-ironclad)))
+ (home-page "https://github.com/fukamachi/lack")
+ (synopsis "Lack, the core of Clack")
+ (description
+ "Lack is a Common Lisp library which allows web applications to be
+constructed of modular components. It was originally a part of Clack, however
+it's going to be rewritten as an individual project since Clack v2 with
+performance and simplicity in mind.")
+ (license license:llgpl))))
+
+(define-public cl-lack-util
+ (sbcl-package->cl-source-package sbcl-lack-util))
+
+(define-public sbcl-lack-middleware-backtrace
+ (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
+ (revision "1"))
+ (package
+ (name "sbcl-lack-middleware-backtrace")
+ (version (git-version "0.1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/lack.git")
+ (commit commit)))
+ (file-name (git-file-name "lack-middleware-backtrace" version))
+ (sha256
+ (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-file "lack-middleware-backtrace.asd"
+ #:asd-system-name "lack-middleware-backtrace"
+ #:test-asd-file "t-lack-middleware-backtrace.asd"
+ ;; XXX: Component :LACK not found
+ #:tests? #f))
+ (native-inputs
+ `(("prove-asdf" ,sbcl-prove-asdf)))
+ (home-page "https://github.com/fukamachi/lack")
+ (synopsis "Lack, the core of Clack")
+ (description
+ "Lack is a Common Lisp library which allows web applications to be
+constructed of modular components. It was originally a part of Clack, however
+it's going to be rewritten as an individual project since Clack v2 with
+performance and simplicity in mind.")
+ (license license:llgpl))))
+
+(define-public cl-lack-middleware-backtrace
+ (sbcl-package->cl-source-package sbcl-lack-middleware-backtrace))
+
+(define-public sbcl-trivial-mimes
+ (let ((commit "303f8ac0aa6ca0bc139aa3c34822e623c3723fab")
+ (revision "1"))
+ (package
+ (name "sbcl-trivial-mimes")
+ (version (git-version "1.1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Shinmera/trivial-mimes.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "17jxgl47r695bvsb7wi3n2ws5rp1zzgvw0zii8cy5ggw4b4ayv6m"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after
+ 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (let ((anchor "#p\"/etc/mime.types\""))
+ (substitute* "mime-types.lisp"
+ ((anchor all)
+ (string-append
+ anchor "\n"
+ "(asdf:system-relative-pathname :trivial-mimes "
+ "\"../../share/common-lisp/" (%lisp-type)
+ "-source/trivial-mimes/mime.types\")")))))))))
+ (native-inputs
+ `(("stefil" ,sbcl-hu.dwim.stefil)))
+ (inputs
+ `(("sbcl-cl-fad" ,sbcl-cl-fad)))
+ (home-page "http://shinmera.github.io/trivial-mimes/")
+ (synopsis "Tiny Common Lisp library to detect mime types in files")
+ (description
+ "This is a teensy library that provides some functions to determine the
+mime-type of a file.")
+ (license license:artistic2.0))))
+
+(define-public cl-trivial-mimes
+ (sbcl-package->cl-source-package sbcl-trivial-mimes))
+
+(define-public ecl-trivial-mimes
+ (sbcl-package->ecl-package sbcl-trivial-mimes))
+
+(define-public sbcl-lack-middleware-static
+ (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
+ (revision "1"))
+ (package
+ (name "sbcl-lack-middleware-static")
+ (version (git-version "0.1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/lack.git")
+ (commit commit)))
+ (file-name (git-file-name "lack-middleware-static" version))
+ (sha256
+ (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-file "lack-middleware-static.asd"
+ #:asd-system-name "lack-middleware-static"
+ #:test-asd-file "t-lack-middleware-static.asd"
+ ;; XXX: Component :LACK not found
+ #:tests? #f))
+ (native-inputs
+ `(("prove-asdf" ,sbcl-prove-asdf)))
+ (inputs
+ `(("sbcl-ironclad" ,sbcl-ironclad)
+ ("sbcl-trivial-mimes" ,sbcl-trivial-mimes)
+ ("sbcl-local-time" ,sbcl-local-time)))
+ (home-page "https://github.com/fukamachi/lack")
+ (synopsis "Lack, the core of Clack")
+ (description
+ "Lack is a Common Lisp library which allows web applications to be
+constructed of modular components. It was originally a part of Clack, however
+it's going to be rewritten as an individual project since Clack v2 with
+performance and simplicity in mind.")
+ (license license:llgpl))))
+
+(define-public cl-lack-middleware-static
+ (sbcl-package->cl-source-package sbcl-lack-middleware-static))
+
+(define-public sbcl-lack
+ (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
+ (revision "1"))
+ (package
+ (name "sbcl-lack")
+ (version (git-version "0.1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/lack.git")
+ (commit commit)))
+ (file-name (git-file-name "lack" version))
+ (sha256
+ (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:test-asd-file "t-lack.asd"
+ ;; XXX: Component :CLACK not found
+ #:tests? #f))
+ (native-inputs
+ `(("prove-asdf" ,sbcl-prove-asdf)))
+ (inputs
+ `(("sbcl-lack-component" ,sbcl-lack-component)
+ ("sbcl-lack-util" ,sbcl-lack-util)))
+ (home-page "https://github.com/fukamachi/lack")
+ (synopsis "Lack, the core of Clack")
+ (description
+ "Lack is a Common Lisp library which allows web applications to be
+constructed of modular components. It was originally a part of Clack, however
+it's going to be rewritten as an individual project since Clack v2 with
+performance and simplicity in mind.")
+ (license license:llgpl))))
+
+(define-public cl-lack
+ (sbcl-package->cl-source-package sbcl-lack))
+
+(define-public sbcl-ningle
+ (let ((commit "50bd4f09b5a03a7249bd4d78265d6451563b25ad")
+ (revision "1"))
+ (package
+ (name "sbcl-ningle")
+ (version (git-version "0.3.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/ningle.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1bsl8cnxhacb8p92z9n89vhk1ikmij5zavk0m2zvmj7iqm79jzgw"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; TODO: pull in clack-test
+ '(#:tests? #f
+ #:phases
+ (modify-phases %standard-phases
+ (delete 'cleanup-files)
+ (delete 'cleanup)
+ (add-before 'cleanup 'combine-fasls
+ (lambda* (#:key outputs #:allow-other-keys)
+ (let* ((out (assoc-ref outputs "out"))
+ (lib (string-append out "/lib/sbcl"))
+ (ningle-path (string-append lib "/ningle"))
+ (fasl-files (find-files out "\\.fasl$")))
+ (mkdir-p ningle-path)
+ (let ((fasl-path (lambda (name)
+ (string-append ningle-path
+ "/"
+ (basename name)
+ "--system.fasl"))))
+ (for-each (lambda (file)
+ (rename-file file
+ (fasl-path
+ (basename file ".fasl"))))
+ fasl-files))
+ fasl-files)
+ #t)))))
+ (native-inputs
+ `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+ ("sbcl-prove" ,sbcl-prove)))
+ (inputs
+ `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
+ ("sbcl-cl-syntax-annot" ,sbcl-cl-syntax-annot)
+ ("sbcl-myway" ,sbcl-myway)
+ ("sbcl-lack-request" ,sbcl-lack-request)
+ ("sbcl-lack-response" ,sbcl-lack-response)
+ ("sbcl-lack-component" ,sbcl-lack-component)
+ ("sbcl-alexandria" ,sbcl-alexandria)
+ ("sbcl-babel" ,sbcl-babel)))
+ (home-page "http://8arrow.org/ningle/")
+ (synopsis "Super micro framework for Common Lisp")
+ (description
+ "Ningle is a lightweight web application framework for Common Lisp.")
+ (license license:llgpl))))
+
+(define-public cl-ningle
+ (sbcl-package->cl-source-package sbcl-ningle))
+
+(define-public sbcl-clack
+ (let ((commit "e3e032843bb1220ab96263c411aa7f2feb4746e0")
+ (revision "1"))
+ (package
+ (name "sbcl-clack")
+ (version (git-version "2.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/clack.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1ymzs6qyrwhlj6cgqsnpyn6g5cbp7a3s1vgxwna20y2q7y4iacy0"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("sbcl-lack" ,sbcl-lack)
+ ("sbcl-lack-middleware-backtrace" ,sbcl-lack-middleware-backtrace)
+ ("sbcl-bordeaux-threads" ,sbcl-bordeaux-threads)))
+ (home-page "https://github.com/fukamachi/clack")
+ (synopsis "Web Application Environment for Common Lisp")
+ (description
+ "Clack is a web application environment for Common Lisp inspired by
+Python's WSGI and Ruby's Rack.")
+ (license license:llgpl))))
+
+(define-public cl-clack
+ (sbcl-package->cl-source-package sbcl-clack))
+
+(define-public sbcl-log4cl
+ (let ((commit "611e094458504b938d49de904eab141285328c7c")
+ (revision "1"))
+ (package
+ (name "sbcl-log4cl")
+ (build-system asdf-build-system/sbcl)
+ (version "1.1.2")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sharplispers/log4cl")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "08jly0s0g26b56hhpfizxsb4j0yvbh946sd205gr42dkzv8l7dsc"))))
+ ;; FIXME: tests require stefil, sbcl-hu.dwim.stefil wont work
+ (arguments
+ `(#:tests? #f))
+ (inputs `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
+ (synopsis "Common Lisp logging framework, modeled after Log4J")
+ (home-page "https://github.com/7max/log4cl")
+ (description "This is a Common Lisp logging framework that can log at
+various levels and mix text with expressions.")
+ (license license:asl2.0))))
+
+(define-public cl-log4cl
+ (sbcl-package->cl-source-package sbcl-log4cl))
+
+(define-public ecl-log4cl
+ (sbcl-package->ecl-package sbcl-log4cl))
+
+(define-public sbcl-find-port
+ (let ((commit "00c96a25af93a0f8681d34ec548861f2d7485478")
+ (revision "1"))
+ (package
+ (name "sbcl-find-port")
+ (build-system asdf-build-system/sbcl)
+ (version "0.1")
+ (home-page "https://github.com/eudoxia0/find-port")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0d6dzbb45jh0rx90wgs6v020k2xa87mvzas3mvfzvivjvqqlpryq"))))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (inputs
+ `(("sbcl-usocket" ,sbcl-usocket)))
+ (synopsis "Find open ports programmatically in Common Lisp")
+ (description "This is a small Common Lisp library that finds an open
+port within a range.")
+ (license license:expat))))
+
+(define-public cl-find-port
+ (sbcl-package->cl-source-package sbcl-find-port))
+
+(define-public ecl-find-port
+ (sbcl-package->ecl-package sbcl-find-port))
+
+(define-public sbcl-clunit
+ (let ((commit "6f6d72873f0e1207f037470105969384f8380628")
+ (revision "1"))
+ (package
+ (name "sbcl-clunit")
+ (version (git-version "0.2.3" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/tgutu/clunit.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1idf2xnqzlhi8rbrqmzpmb3i1l6pbdzhhajkmhwbp6qjkmxa4h85"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "CLUnit is a Common Lisp unit testing framework")
+ (description
+ "CLUnit is a Common Lisp unit testing framework. It is designed
+to be easy to use so that you can quickly start testing. CLUnit
+provides a rich set of features aimed at improving your unit testing
+experience.")
+ (home-page "http://tgutu.github.io/clunit/")
+ ;; MIT License
+ (license license:expat))))
+
+(define-public cl-clunit
+ (sbcl-package->cl-source-package sbcl-clunit))
+
+(define-public ecl-clunit
+ (sbcl-package->ecl-package sbcl-clunit))
+
+(define-public sbcl-py4cl
+ (let ((commit "4c8a2b0814fd311f978964f825ce012290f60136")
+ (revision "1"))
+ (package
+ (name "sbcl-py4cl")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/bendudson/py4cl.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "15mk7qdqjkj56gdnbyrdyz6r7m1h26ldvn6ch96pmvg5vmr1m45r"))
+ (modules '((guix build utils)))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("sbcl-clunit" ,sbcl-clunit)))
+ (inputs
+ `(("sbcl-trivial-garbage" ,sbcl-trivial-garbage)))
+ (propagated-inputs
+ ;; This package doesn't do anything without python available
+ `(("python" ,python)
+ ;; For multi-dimensional array support
+ ("python-numpy" ,python-numpy)))
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'replace-*base-directory*-var
+ (lambda* (#:key outputs #:allow-other-keys)
+ ;; In the ASD, the author makes an attempt to
+ ;; programatically determine the location of the
+ ;; source-code so lisp can call into "py4cl.py". We can
+ ;; hard-code this since we know where this file will
+ ;; reside.
+ (substitute* "src/callpython.lisp"
+ (("py4cl/config:\\*base-directory\\*")
+ (string-append
+ "\""
+ (assoc-ref outputs "out")
+ "/share/common-lisp/sbcl-source/py4cl/"
+ "\""))))))))
+ (synopsis "Call python from Common Lisp")
+ (description
+ "Py4CL is a bridge between Common Lisp and Python, which enables Common
+Lisp to interact with Python code. It uses streams to communicate with a
+separate python process, the approach taken by cl4py. This is different to
+the CFFI approach used by burgled-batteries, but has the same goal.")
+ (home-page "https://github.com/bendudson/py4cl")
+ ;; MIT License
+ (license license:expat))))
+
+(define-public cl-py4cl
+ (sbcl-package->cl-source-package sbcl-py4cl))
+
+(define-public ecl-py4cl
+ (sbcl-package->ecl-package sbcl-py4cl))
+
+(define-public sbcl-parse-declarations
+ (package
+ (name "sbcl-parse-declarations")
+ (version "1.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://beta.quicklisp.org/archive/parse-declarations/"
+ "2010-10-06/parse-declarations-20101006-darcs.tgz"))
+ (sha256
+ (base32
+ "0r85b0jfacd28kr65kw9c13dx4i6id1dpmby68zjy63mqbnyawrd"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:asd-file "parse-declarations-1.0.asd"
+ #:asd-system-name "parse-declarations-1.0"))
+ (home-page "https://common-lisp.net/project/parse-declarations/")
+ (synopsis "Parse, filter, and build declarations")
+ (description
+ "Parse-Declarations is a Common Lisp library to help writing
+macros which establish bindings. To be semantically correct, such
+macros must take user declarations into account, as these may affect
+the bindings they establish. Yet the ANSI standard of Common Lisp does
+not provide any operators to work with declarations in a convenient,
+high-level way. This library provides such operators.")
+ ;; MIT License
+ (license license:expat)))
+
+(define-public cl-parse-declarations
+ (sbcl-package->cl-source-package sbcl-parse-declarations))
+
+(define-public ecl-parse-declarations
+ (sbcl-package->ecl-package sbcl-parse-declarations))
+
+(define-public sbcl-cl-quickcheck
+ (let ((commit "807b2792a30c883a2fbecea8e7db355b50ba662f")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-quickcheck")
+ (version (git-version "0.0.4" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/mcandre/cl-quickcheck.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "165lhypq5xkcys6hvzb3jq7ywnmqvzaflda29qk2cbs3ggas4767"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis
+ "Common Lisp port of the QuickCheck unit test framework")
+ (description
+ "Common Lisp port of the QuickCheck unit test framework")
+ (home-page "https://github.com/mcandre/cl-quickcheck")
+ ;; MIT
+ (license license:expat))))
+
+(define-public cl-cl-quickcheck
+ (sbcl-package->cl-source-package sbcl-cl-quickcheck))
+
+(define-public ecl-cl-quickcheck
+ (sbcl-package->ecl-package sbcl-cl-quickcheck))
+
+(define-public sbcl-burgled-batteries3
+ (let ((commit "9c0f6667e1a71ddf77e21793a0bea524710fef6e")
+ (revision "1"))
+ (package
+ (name "sbcl-burgled-batteries3")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/snmsts/burgled-batteries3.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0b726kz2xxcg5l930gz035rsdvhxrzmp05iwfwympnb4z4ammicb"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:tests? #f
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'set-*cpython-include-dir*-var
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "grovel-include-dir.lisp"
+ (("\\(defparameter \\*cpython-include-dir\\* \\(detect-python\\)\\)")
+ (string-append
+ "(defparameter *cpython-include-dir* \""
+ (assoc-ref inputs "python")
+ "/include/python3.7m"
+ "\")")))
+ (substitute* "ffi-interface.lisp"
+ (("\\*cpython-lib\\*")
+ (format #f "'(\"~a/lib/libpython3.so\")"
+ (assoc-ref inputs "python"))))
+ #t)))))
+ (native-inputs
+ `(("python" ,python)
+ ("sbcl-cl-fad" ,sbcl-cl-fad)
+ ("sbcl-lift" ,sbcl-lift)
+ ("sbcl-cl-quickcheck" ,sbcl-cl-quickcheck)))
+ (inputs
+ `(("sbcl-cffi" ,sbcl-cffi)
+ ("sbcl-cffi-grovel" ,sbcl-cffi-grovel)
+ ("sbcl-alexandria" , sbcl-alexandria)
+ ("sbcl-parse-declarations-1.0" ,sbcl-parse-declarations)
+ ("sbcl-trivial-garbage" ,sbcl-trivial-garbage)))
+ (synopsis "Bridge between Python and Lisp (FFI bindings, etc.)")
+ (description
+ "This package provides a shim between Python3 (specifically, the
+CPython implementation of Python) and Common Lisp.")
+ (home-page "https://github.com/snmsts/burgled-batteries3")
+ ;; MIT
+ (license license:expat))))
+
+(define-public cl-burgled-batteries3
+ (sbcl-package->cl-source-package sbcl-burgled-batteries3))
+
+(define-public ecl-burgled-batteries3
+ (sbcl-package->ecl-package sbcl-burgled-batteries3))
+
+(define-public sbcl-metabang-bind
+ (let ((commit "c93b7f7e1c18c954c2283efd6a7fdab36746ab5e")
+ (revision "1"))
+ (package
+ (name "sbcl-metabang-bind")
+ (version (git-version "0.8.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/gwkkwg/metabang-bind.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0hd0kr91795v77akpbcyqiss9p0p7ypa9dznrllincnmgvsxlmf0"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("sbcl-lift" ,sbcl-lift)))
+ (synopsis "Macro that generalizes @code{multiple-value-bind} etc.")
+ (description
+ "Bind extends the idea of of let and destructing to provide a uniform
+syntax for all your accessor needs. It combines @code{let},
+@code{destructuring-bind}, @code{with-slots}, @code{with-accessors}, structure
+editing, property or association-lists, and @code{multiple-value-bind} and a
+whole lot more into a single form.")
+ (home-page "https://common-lisp.net/project/metabang-bind/")
+ ;; MIT License
+ (license license:expat))))
+
+(define-public cl-metabang-bind
+ (sbcl-package->cl-source-package sbcl-metabang-bind))
+
+(define-public ecl-metabang-bind
+ (sbcl-package->ecl-package sbcl-metabang-bind))
+
+(define-public sbcl-fare-utils
+ (let ((commit "66e9c6f1499140bc00ccc22febf2aa528cbb5724")
+ (revision "1"))
+ (package
+ (name "sbcl-fare-utils")
+ (version (git-version "1.0.0.5" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri
+ (git-reference
+ (url
+ "https://gitlab.common-lisp.net/frideau/fare-utils.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "01wsr1aap3jdzhn4hrqjbhsjx6qci9dbd3gh4gayv1p49rbg8aqr"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:test-asd-file "test/fare-utils-test.asd"))
+ (native-inputs
+ `(("sbcl-hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
+ (synopsis "Collection of utilities and data structures")
+ (description
+ "fare-utils is a small collection of utilities. It contains a lot of
+basic everyday functions and macros.")
+ (home-page "https://gitlab.common-lisp.net/frideau/fare-utils")
+ ;; MIT License
+ (license license:expat))))
+
+(define-public cl-fare-utils
+ (sbcl-package->cl-source-package sbcl-fare-utils))
+
+(define-public ecl-fare-utils
+ (sbcl-package->ecl-package sbcl-fare-utils))
+
+(define-public sbcl-trivial-utf-8
+ (let ((commit "4d427cfbb1c452436a0efb71c3205c9da67f718f")
+ (revision "1"))
+ (package
+ (name "sbcl-trivial-utf-8")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri
+ (git-reference
+ (url (string-append "https://gitlab.common-lisp.net/"
+ "trivial-utf-8/trivial-utf-8.git"))
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1jz27gz8gvqdmvp3k9bxschs6d5b3qgk94qp2bj6nv1d0jc3m1l1"))))
+ (arguments
+ ;; Guix incorrectly assumes the "8" is part of the version
+ ;; number and lobs it off.
+ `(#:asd-file "trivial-utf-8.asd"
+ #:asd-system-name "trivial-utf-8"))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "UTF-8 input/output library")
+ (description
+ "The Babel library solves a similar problem while understanding more
+encodings. Trivial UTF-8 was written before Babel existed, but for new
+projects you might be better off going with Babel. The one plus that Trivial
+UTF-8 has is that it doesn't depend on any other libraries.")
+ (home-page "https://common-lisp.net/project/trivial-utf-8/")
+ (license license:bsd-3))))
+
+(define-public cl-trivial-utf-8
+ (sbcl-package->cl-source-package sbcl-trivial-utf-8))
+
+(define-public ecl-trivial-utf-8
+ (sbcl-package->ecl-package sbcl-trivial-utf-8))
+
+(define-public sbcl-idna
+ (package
+ (name "sbcl-idna")
+ (build-system asdf-build-system/sbcl)
+ (version "0.2.2")
+ (home-page "https://github.com/antifuchs/idna")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit version)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "00nbr3mffxhlq14gg9d16pa6691s4qh35inyw76v906s77khm5a2"))))
+ (inputs
+ `(("split-sequence" ,sbcl-split-sequence)))
+ (synopsis "IDNA string encoding and decoding routines for Common Lisp")
+ (description "This Common Lisp library provides string encoding and
+decoding routines for IDNA, the International Domain Names in Applications.")
+ (license license:expat)))
+
+(define-public cl-idna
+ (sbcl-package->cl-source-package sbcl-idna))
+
+(define-public ecl-idna
+ (sbcl-package->ecl-package sbcl-idna))
+
+(define-public sbcl-swap-bytes
+ (package
+ (name "sbcl-swap-bytes")
+ (build-system asdf-build-system/sbcl)
+ (version "1.1")
+ (home-page "https://github.com/sionescu/swap-bytes")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1qysbv0jngdfkv53y874qjhcxc4qi8ixaqq6j8bzxh5z0931wv55"))))
+ (inputs
+ `(("trivial-features" ,sbcl-trivial-features)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (arguments
+ ;; TODO: Tests fail, why?
+ `(#:tests? #f))
+ (synopsis "Efficient endianness conversion for Common Lisp")
+ (description "This Common Lisp library provides optimized byte-swapping
+primitives. The library can change endianness of unsigned integers of length
+1/2/4/8. Very useful in implementing various network protocols and file
+formats.")
+ (license license:expat)))
+
+(define-public cl-swap-bytes
+ (sbcl-package->cl-source-package sbcl-swap-bytes))
+
+(define-public ecl-swap-bytes
+ (sbcl-package->ecl-package sbcl-swap-bytes))
+
+(define-public sbcl-iolib.asdf
+ ;; Latest release is from June 2017.
+ (let ((commit "81e20614c0d27f9605bf9766214e236fd31b99b4")
+ (revision "1"))
+ (package
+ (name "sbcl-iolib.asdf")
+ (build-system asdf-build-system/sbcl)
+ (version "0.8.3")
+ (home-page "https://github.com/sionescu/iolib")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1j81r0wm7nfbwl991f26s4npcy7kybzybd3m47rbxy31h0cfcmdm"))))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)))
+ (arguments
+ '(#:asd-file "iolib.asdf.asd"))
+ (synopsis "ASDF component classes for IOLib, a Common Lisp I/O library")
+ (description "IOlib is to be a better and more modern I/O library than
+the standard Common Lisp library. It contains a socket library, a DNS
+resolver, an I/O multiplexer(which supports @code{select(2)}, @code{epoll(4)}
+and @code{kqueue(2)}), a pathname library and file-system utilities.")
+ (license license:expat))))
+
+(define-public sbcl-iolib.conf
+ (package
+ (inherit sbcl-iolib.asdf)
+ (name "sbcl-iolib.conf")
+ (inputs
+ `(("iolib.asdf" ,sbcl-iolib.asdf)))
+ (arguments
+ '(#:asd-file "iolib.conf.asd"))
+ (synopsis "Compile-time configuration for IOLib, a Common Lisp I/O library")))
+
+(define-public sbcl-iolib.common-lisp
+ (package
+ (inherit sbcl-iolib.asdf)
+ (name "sbcl-iolib.common-lisp")
+ (inputs
+ `(("iolib.asdf" ,sbcl-iolib.asdf)
+ ("iolib.conf" ,sbcl-iolib.conf)))
+ (arguments
+ '(#:asd-file "iolib.common-lisp.asd"))
+ (synopsis "Slightly modified Common Lisp for IOLib, a Common Lisp I/O library")))
+
+(define-public sbcl-iolib.base
+ (package
+ (inherit sbcl-iolib.asdf)
+ (name "sbcl-iolib.base")
+ (inputs
+ `(("iolib.asdf" ,sbcl-iolib.asdf)
+ ("iolib.conf" ,sbcl-iolib.conf)
+ ("iolib.common-lisp" ,sbcl-iolib.common-lisp)
+ ("split-sequence" ,sbcl-split-sequence)))
+ (arguments
+ '(#:asd-file "iolib.base.asd"))
+ (synopsis "Base package for IOLib, a Common Lisp I/O library")))
+
+(define-public sbcl-iolib.grovel
+ (package
+ (inherit sbcl-iolib.asdf)
+ (name "sbcl-iolib.grovel")
+ (inputs
+ `(("iolib.asdf" ,sbcl-iolib.asdf)
+ ("iolib.conf" ,sbcl-iolib.conf)
+ ("iolib.base", sbcl-iolib.base)
+ ("cffi", sbcl-cffi)))
+ (arguments
+ '(#:asd-file "iolib.grovel.asd"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'install 'install-header
+ (lambda* (#:key outputs #:allow-other-keys)
+ ;; This header is required by sbcl-iolib.
+ (install-file "src/grovel/grovel-common.h"
+ (string-append (assoc-ref outputs "out")
+ "/lib/sbcl"))
+ #t)))))
+ (synopsis "CFFI Groveller for IOLib, a Common Lisp I/O library")))
+
+(define-public sbcl-iolib
+ (package
+ (inherit sbcl-iolib.asdf)
+ (name "sbcl-iolib")
+ (inputs
+ `(("iolib.asdf" ,sbcl-iolib.asdf)
+ ("iolib.conf" ,sbcl-iolib.conf)
+ ("iolib.grovel" ,sbcl-iolib.grovel)
+ ("iolib.base" ,sbcl-iolib.base)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("idna" ,sbcl-idna)
+ ("swap-bytes" ,sbcl-swap-bytes)
+ ("libfixposix" ,libfixposix)
+ ("cffi" ,sbcl-cffi)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (arguments
+ '(#:asd-file "iolib.asd"
+ #:asd-system-name "iolib"
+ #:test-asd-file "iolib.tests.asd"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/syscalls/ffi-functions-unix.lisp"
+ (("\\(:default \"libfixposix\"\\)")
+ (string-append
+ "(:default \""
+ (assoc-ref inputs "libfixposix") "/lib/libfixposix\")")))
+ ;; Socket tests need Internet access, disable them.
+ (substitute* "iolib.tests.asd"
+ (("\\(:file \"sockets\" :depends-on \\(\"pkgdcl\" \"defsuites\"\\)\\)")
+ "")))))))
+ (synopsis "Common Lisp I/O library")))
+
+(define-public cl-iolib
+ (sbcl-package->cl-source-package sbcl-iolib))
+
+(define sbcl-iolib+multiplex
+ (package
+ (inherit sbcl-iolib)
+ (name "sbcl-iolib+multiplex")
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-iolib)
+ ((#:asd-system-name _) "iolib/multiplex")))))
+
+(define sbcl-iolib+syscalls
+ (package
+ (inherit sbcl-iolib)
+ (name "sbcl-iolib+syscalls")
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-iolib)
+ ((#:asd-system-name _) "iolib/syscalls")))))
+
+(define sbcl-iolib+streams
+ (package
+ (inherit sbcl-iolib)
+ (name "sbcl-iolib+streams")
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-iolib)
+ ((#:asd-system-name _) "iolib/streams")))))
+
+(define sbcl-iolib+sockets
+ (package
+ (inherit sbcl-iolib)
+ (name "sbcl-iolib+sockets")
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-iolib)
+ ((#:asd-system-name _) "iolib/sockets")))))
+
+(define-public sbcl-ieee-floats
+ (let ((commit "566b51a005e81ff618554b9b2f0b795d3b29398d")
+ (revision "1"))
+ (package
+ (name "sbcl-ieee-floats")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "20170924" revision commit))
+ (home-page "https://github.com/marijnh/ieee-floats/")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1xyj49j9x3lc84cv3dhbf9ja34ywjk1c46dklx425fxw9mkwm83m"))))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (synopsis "IEEE 754 binary representation for floats in Common Lisp")
+ (description "This is a Common Lisp library that allows to convert
+floating point values to IEEE 754 binary representation.")
+ (license license:bsd-3))))
+
+(define-public cl-ieee-floats
+ (sbcl-package->cl-source-package sbcl-ieee-floats))
+
+(define sbcl-closure-common
+ (let ((commit "e3c5f5f454b72b01b89115e581c3c52a7e201e5c")
+ (revision "1"))
+ (package
+ (name "sbcl-closure-common")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "20101006" revision commit))
+ (home-page "https://common-lisp.net/project/cxml/")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sharplispers/closure-common")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0k5r2qxn122pxi301ijir3nayi9sg4d7yiy276l36qmzwhp4mg5n"))))
+ (inputs
+ `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)
+ ("babel" ,sbcl-babel)))
+ (synopsis "Support Common Lisp library for CXML")
+ (description "Closure-common is an internal helper library. The name
+Closure is a reference to the web browser it was originally written for.")
+ ;; TODO: License?
+ (license #f))))
+
+(define-public sbcl-cxml+xml
+ (let ((commit "00b22bf4c4cf11c993d5866fae284f95ab18e6bf")
+ (revision "1"))
+ (package
+ (name "sbcl-cxml+xml")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.0.0" revision commit))
+ (home-page "https://common-lisp.net/project/cxml/")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sharplispers/cxml")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "13kif7rf3gqdycsk9zq0d7y0g9y81krkl0z87k0p2fkbjfgrph37"))))
+ (inputs
+ `(("closure-common" ,sbcl-closure-common)
+ ("puri" ,sbcl-puri)
+ ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
+ (arguments
+ `(#:asd-file "cxml.asd"
+ #:asd-system-name "cxml/xml"))
+ (synopsis "Common Lisp XML parser")
+ (description "CXML implements a namespace-aware, validating XML 1.0
+parser as well as the DOM Level 2 Core interfaces. Two parser interfaces are
+offered, one SAX-like, the other similar to StAX.")
+ (license license:llgpl))))
+
+(define sbcl-cxml+dom
+ (package
+ (inherit sbcl-cxml+xml)
+ (name "sbcl-cxml+dom")
+ (inputs
+ `(("closure-common" ,sbcl-closure-common)
+ ("puri" ,sbcl-puri)
+ ("cxml+xml" ,sbcl-cxml+xml)))
+ (arguments
+ `(#:asd-file "cxml.asd"
+ #:asd-system-name "cxml/dom"))))
+
+(define sbcl-cxml+klacks
+ (package
+ (inherit sbcl-cxml+xml)
+ (name "sbcl-cxml+klacks")
+ (inputs
+ `(("closure-common" ,sbcl-closure-common)
+ ("puri" ,sbcl-puri)
+ ("cxml+xml" ,sbcl-cxml+xml)))
+ (arguments
+ `(#:asd-file "cxml.asd"
+ #:asd-system-name "cxml/klacks"))))
+
+(define sbcl-cxml+test
+ (package
+ (inherit sbcl-cxml+xml)
+ (name "sbcl-cxml+test")
+ (inputs
+ `(("closure-common" ,sbcl-closure-common)
+ ("puri" ,sbcl-puri)
+ ("cxml+xml" ,sbcl-cxml+xml)))
+ (arguments
+ `(#:asd-file "cxml.asd"
+ #:asd-system-name "cxml/test"))))
+
+(define-public sbcl-cxml
+ (package
+ (inherit sbcl-cxml+xml)
+ (name "sbcl-cxml")
+ (inputs
+ `(("closure-common" ,sbcl-closure-common)
+ ("puri" ,sbcl-puri)
+ ("trivial-gray-streams" ,sbcl-trivial-gray-streams)
+ ("cxml+dom" ,sbcl-cxml+dom)
+ ("cxml+klacks" ,sbcl-cxml+klacks)
+ ("cxml+test" ,sbcl-cxml+test)))
+ (arguments
+ `(#:asd-file "cxml.asd"
+ #:asd-system-name "cxml"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'build 'install-dtd
+ (lambda* (#:key outputs #:allow-other-keys)
+ (install-file "catalog.dtd"
+ (string-append
+ (assoc-ref outputs "out")
+ "/lib/" (%lisp-type)))))
+ (add-after 'create-asd 'remove-component
+ ;; XXX: The original .asd has no components, but our build system
+ ;; creates an entry nonetheless. We need to remove it for the
+ ;; generated .asd to load properly. See trivia.trivial for a
+ ;; similar problem.
+ (lambda* (#:key outputs #:allow-other-keys)
+ (let* ((out (assoc-ref outputs "out"))
+ (asd (string-append out "/lib/sbcl/cxml.asd")))
+ (substitute* asd
+ ((" :components
+")
+ ""))
+ (substitute* asd
+ ((" *\\(\\(:compiled-file \"cxml--system\"\\)\\)")
+ ""))))))))))
+
+(define-public cl-cxml
+ (sbcl-package->cl-source-package sbcl-cxml))
+
+(define-public sbcl-cl-reexport
+ (let ((commit "312f3661bbe187b5f28536cd7ec2956e91366c3b")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-reexport")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.1" revision commit))
+ (home-page "https://github.com/takagi/cl-reexport")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1cwpn1m3wrl0fl9plznn7p464db646gnfc8zkyk97dyxski2aq0x"))))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)))
+ (arguments
+ ;; TODO: Tests fail because cl-test-more is missing, but I can't find it online.
+ `(#:tests? #f))
+ (synopsis "HTTP cookie manager for Common Lisp")
+ (description "cl-cookie is a Common Lisp library featuring parsing of
+cookie headers, cookie creation, cookie jar creation and more.")
+ (license license:llgpl))))
+
+(define-public cl-reexport
+ (sbcl-package->cl-source-package sbcl-cl-reexport))
+
+(define-public sbcl-cl-cookie
+ (let ((commit "cea55aed8b9ad25fafd13defbcb9fe8f41b29546")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-cookie")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.9.10" revision commit))
+ (home-page "https://github.com/fukamachi/cl-cookie")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "090g7z75h98zvc1ldx0vh4jn4086dhjm2w30jcwkq553qmyxwl8h"))))
+ (inputs
+ `(("proc-parse" ,sbcl-proc-parse)
+ ("alexandria" ,sbcl-alexandria)
+ ("quri" ,sbcl-quri)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("local-time" ,sbcl-local-time)))
+ (native-inputs
+ `(("prove-asdf" ,sbcl-prove-asdf)
+ ("prove" ,sbcl-prove)))
+ (arguments
+ ;; TODO: Tests fail because cl-cookie depends on cl-cookie-test.
+ `(#:tests? #f))
+ (synopsis "HTTP cookie manager for Common Lisp")
+ (description "cl-cookie is a Common Lisp library featuring parsing of
+cookie headers, cookie creation, cookie jar creation and more.")
+ (license license:bsd-2))))
+
+(define-public cl-cookie
+ (sbcl-package->cl-source-package sbcl-cl-cookie))
+
+(define-public sbcl-dexador
+ (let ((commit "a2714d126cc94bc7a9a6e1e3c08de455b3a66378")
+ (revision "1"))
+ (package
+ (name "sbcl-dexador")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.9.10" revision commit))
+ (home-page "https://github.com/fukamachi/dexador")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0nbqgn4v3l2z6m1k1bdxfnqpfrk84nxdmz7csz11zzcfs4flkv79"))))
+ (inputs
+ `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)
+ ("babel" ,sbcl-babel)
+ ("usocket" ,sbcl-usocket)
+ ("fast-http" ,sbcl-fast-http)
+ ("quri" ,sbcl-quri)
+ ("fast-io" ,sbcl-fast-io)
+ ("chunga" ,sbcl-chunga)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("cl-cookie" ,sbcl-cl-cookie)
+ ("trivial-mimes" ,sbcl-trivial-mimes)
+ ("chipz" ,sbcl-chipz)
+ ("cl-base64" ,sbcl-cl-base64)
+ ("cl-reexport" ,sbcl-cl-reexport)
+ ("cl+ssl" ,sbcl-cl+ssl)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("alexandria" ,sbcl-alexandria)))
+ (native-inputs
+ `(("prove" ,sbcl-prove)
+ ("prove-asdf" ,sbcl-prove-asdf)
+ ("lack-request" ,sbcl-lack-request)
+ ("clack" ,sbcl-clack)
+ ("babel" ,sbcl-babel)
+ ("alexandria" ,sbcl-alexandria)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("local-time" ,sbcl-local-time)))
+ (arguments
+ ;; TODO: Circular dependency: tests depend on clack-test which depends on dexador.
+ `(#:tests? #f
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-permissions
+ (lambda _ (make-file-writable "t/data/test.gz") #t)))))
+ (synopsis "Yet another HTTP client for Common Lisp")
+ (description "Dexador is yet another HTTP client for Common Lisp with
+neat APIs and connection-pooling. It is meant to supersede Drakma.")
+ (license license:expat))))
+
+(define-public cl-dexador
+ (package
+ (inherit (sbcl-package->cl-source-package sbcl-dexador))
+ (arguments
+ `(#:phases
+ ;; asdf-build-system/source has its own phases and does not inherit
+ ;; from asdf-build-system/sbcl phases.
+ (modify-phases %standard-phases/source
+ (add-after 'unpack 'fix-permissions
+ (lambda _ (make-file-writable "t/data/test.gz") #t)))))))
+
+(define-public ecl-dexador
+ (sbcl-package->ecl-package sbcl-dexador))
+
+(define-public sbcl-lisp-namespace
+ (let ((commit "28107cafe34e4c1c67490fde60c7f92dc610b2e0")
+ (revision "1"))
+ (package
+ (name "sbcl-lisp-namespace")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.1" revision commit))
+ (home-page "https://github.com/guicho271828/lisp-namespace")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1jw2wykp06z2afb9nm1lgfzll5cjlj36pnknjx614057zkkxq4iy"))))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (arguments
+ `(#:test-asd-file "lisp-namespace.test.asd"
+ ;; XXX: Component LISP-NAMESPACE-ASD::LISP-NAMESPACE.TEST not found
+ #:tests? #f))
+ (synopsis "LISP-N, or extensible namespaces in Common Lisp")
+ (description "Common Lisp already has major 2 namespaces, function
+namespace and value namespace (or variable namespace), but there are actually
+more — e.g., class namespace.
+This library offers macros to deal with symbols from any namespace.")
+ (license license:llgpl))))
+
+(define-public cl-lisp-namespace
+ (sbcl-package->cl-source-package sbcl-lisp-namespace))
+
+(define-public sbcl-trivial-cltl2
+ (let ((commit "8eec8407df833e8f27df8a388bc10913f16d9e83")
+ (revision "1"))
+ (package
+ (name "sbcl-trivial-cltl2")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.1.1" revision commit))
+ (home-page "https://github.com/Zulu-Inuoe/trivial-cltl2")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1dyyxz17vqv8hlfwq287gl8xxbvcnq798ajb7p5jdjz91wqf4bgk"))))
+ (synopsis "Simple CLtL2 compatibility layer for Common Lisp")
+ (description "This library is a portable compatibility layer around
+\"Common Lisp the Language, 2nd
+Edition\" (@url{https://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node102.html})
+and it exports symbols from implementation-specific packages.")
+ (license license:llgpl))))
+
+(define-public cl-trivial-cltl2
+ (sbcl-package->cl-source-package sbcl-trivial-cltl2))
+
+(define-public sbcl-introspect-environment
+ (let ((commit "fff42f8f8fd0d99db5ad6c5812e53de7d660020b")
+ (revision "1"))
+ (package
+ (name "sbcl-introspect-environment")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.1" revision commit))
+ (home-page "https://github.com/Bike/introspect-environment")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1i305n0wfmpac63ni4i3vixnnkl8daw5ncxy0k3dv92krgx6qzhp"))))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (synopsis "Common Lisp environment introspection portability layer")
+ (description "This library is a small interface to portable but
+nonstandard introspection of Common Lisp environments. It is intended to
+allow a bit more compile-time introspection of environments in Common Lisp.
+
+Quite a bit of information is available at the time a macro or compiler-macro
+runs; inlining info, type declarations, that sort of thing. This information
+is all standard - any Common Lisp program can @code{(declare (integer x))} and
+such.
+
+This info ought to be accessible through the standard @code{&environment}
+parameters, but it is not. Several implementations keep the information for
+their own purposes but do not make it available to user programs, because
+there is no standard mechanism to do so.
+
+This library uses implementation-specific hooks to make information available
+to users. This is currently supported on SBCL, CCL, and CMUCL. Other
+implementations have implementations of the functions that do as much as they
+can and/or provide reasonable defaults.")
+ (license license:wtfpl2))))
+
+(define-public cl-introspect-environment
+ (sbcl-package->cl-source-package sbcl-introspect-environment))
+
+(define-public sbcl-type-i
+ (let ((commit "dea233f45f94064105ec09f0767de338f67dcbe2")
+ (revision "1"))
+ (package
+ (name "sbcl-type-i")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.1" revision commit))
+ (home-page "https://github.com/guicho271828/type-i")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "039g5pbrhh65s0bhr9314gmd2nwc2y5lp2377c5qrc2lxky89qs3"))))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("introspect-environment" ,sbcl-introspect-environment)
+ ("trivia.trivial" ,sbcl-trivia.trivial)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (arguments
+ `(#:test-asd-file "type-i.test.asd"))
+ (synopsis "Type inference utility on unary predicates for Common Lisp")
+ (description "This library tries to provide a way to detect what kind of
+type the given predicate is trying to check. This is different from inferring
+the return type of a function.")
+ (license license:llgpl))))
+
+(define-public cl-type-i
+ (sbcl-package->cl-source-package sbcl-type-i))
+
+(define-public sbcl-optima
+ (let ((commit "373b245b928c1a5cce91a6cb5bfe5dd77eb36195")
+ (revision "1"))
+ (package
+ (name "sbcl-optima")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "1.0" revision commit))
+ (home-page "https://github.com/m2ym/optima")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1yw4ymq7ms89342kkvb3aqxgv0w38m9kd8ikdqxxzyybnkjhndal"))))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("closer-mop" ,sbcl-closer-mop)))
+ (native-inputs
+ `(("eos" ,sbcl-eos)))
+ (arguments
+ ;; XXX: Circular dependencies: tests depend on optima.ppcre which depends on optima.
+ `(#:tests? #f
+ #:test-asd-file "optima.test.asd"))
+ (synopsis "Optimized pattern matching library for Common Lisp")
+ (description "Optima is a fast pattern matching library which uses
+optimizing techniques widely used in the functional programming world.")
+ (license license:expat))))
+
+(define-public cl-optima
+ (sbcl-package->cl-source-package sbcl-optima))
+
+(define-public sbcl-fare-quasiquote
+ (package
+ (name "sbcl-fare-quasiquote")
+ (build-system asdf-build-system/sbcl)
+ (version "20171130")
+ (home-page "http://common-lisp.net/project/fare-quasiquote")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "http://beta.quicklisp.org/archive/fare-quasiquote/"
+ (date->string (string->date version "~Y~m~d") "~Y-~m-~d")
+ "/fare-quasiquote-"
+ version
+ "-git.tgz"))
+ (sha256
+ (base32
+ "00brmh7ndsi0c97nibi8cy10j3l4gmkyrfrr5jr5lzkfb7ngyfqa"))))
+ (inputs
+ `(("fare-utils" ,sbcl-fare-utils)))
+ (arguments
+ ;; XXX: Circular dependencies: Tests depend on subsystems, which depend on the main systems.
+ `(#:tests? #f
+ #:phases
+ (modify-phases %standard-phases
+ ;; XXX: Require 1.0.0 version of fare-utils, and we package some
+ ;; commits after 1.0.0.5, but ASDF fails to read the
+ ;; "-REVISION-COMMIT" part generated by Guix.
+ (add-after 'unpack 'patch-requirement
+ (lambda _
+ (substitute* "fare-quasiquote.asd"
+ (("\\(:version \"fare-utils\" \"1.0.0\"\\)") "\"fare-utils\"")))))))
+ (synopsis "Pattern-matching friendly implementation of quasiquote for Common Lisp")
+ (description "The main purpose of this n+2nd reimplementation of
+quasiquote is enable matching of quasiquoted patterns, using Optima or
+Trivia.")
+ (license license:expat)))
+
+(define-public cl-fare-quasiquote
+ (sbcl-package->cl-source-package sbcl-fare-quasiquote))
+
+(define-public sbcl-fare-quasiquote-optima
+ (package
+ (inherit sbcl-fare-quasiquote)
+ (name "sbcl-fare-quasiquote-optima")
+ (inputs
+ `(("optima" ,sbcl-optima)
+ ("fare-quasiquote" ,sbcl-fare-quasiquote)))
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'patch-requirement
+ (lambda _
+ (substitute* "fare-quasiquote-optima.asd"
+ (("\\(:version \"optima\" \"1\\.0\"\\)")
+ "\"optima\""))
+ #t)))))))
+
+(define-public cl-fare-quasiquote-optima
+ (sbcl-package->cl-source-package sbcl-fare-quasiquote-optima))
+
+(define-public sbcl-fare-quasiquote-readtable
+ (package
+ (inherit sbcl-fare-quasiquote)
+ (name "sbcl-fare-quasiquote-readtable")
+ (inputs
+ `(("fare-quasiquote" ,sbcl-fare-quasiquote)
+ ("named-readtables" ,sbcl-named-readtables)))
+ (description "The main purpose of this n+2nd reimplementation of
+quasiquote is enable matching of quasiquoted patterns, using Optima or
+Trivia.
+
+This package uses fare-quasiquote with named-readtable.")))
+
+(define-public cl-fare-quasiquote-readtable
+ (sbcl-package->cl-source-package sbcl-fare-quasiquote-readtable))
+
+;; TODO: Add support for component-less system in asdf-build-system/sbcl.
+(define-public cl-fare-quasiquote-extras
+ (package
+ (inherit cl-fare-quasiquote)
+ (name "cl-fare-quasiquote-extras")
+ (build-system asdf-build-system/source)
+ (propagated-inputs
+ `(("fare-quasiquote" ,cl-fare-quasiquote)
+ ("fare-quasiquote-optima" ,cl-fare-quasiquote-optima)
+ ("fare-quasiquote-readtable" ,cl-fare-quasiquote-readtable)))
+ (description "This library combines @code{fare-quasiquote-readtable} and
+@code{fare-quasiquote-optima}.")))
+
+(define-public sbcl-trivia.level0
+ (let ((commit "902e0c65602bbfe96ae82e679330b3771ddc7603")
+ (revision "1"))
+ (package
+ (name "sbcl-trivia.level0")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.0.0" revision commit))
+ (home-page "https://github.com/guicho271828/trivia")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "11qbab30qqnfy9mx3x9fvgcw1jbvh1qn2cqv3p8xdn2m8981jvhr"))))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)))
+ (synopsis "Pattern matching in Common Lisp")
+ (description "Trivia is a pattern matching compiler that is compatible
+with Optima, another pattern matching library for Common Lisp. It is meant to
+be faster and more extensible than Optima.")
+ (license license:llgpl))))
+
+(define-public sbcl-trivia.level1
+ (package
+ (inherit sbcl-trivia.level0)
+ (name "sbcl-trivia.level1")
+ (inputs
+ `(("trivia.level0" ,sbcl-trivia.level0)))
+ (description "Trivia is a pattern matching compiler that is compatible
+with Optima, another pattern matching library for Common Lisp. It is meant to
+be faster and more extensible than Optima.
+
+This system contains the core patterns of Trivia.")))
+
+(define-public sbcl-trivia.level2
+ (package
+ (inherit sbcl-trivia.level0)
+ (name "sbcl-trivia.level2")
+ (inputs
+ `(("trivia.level1" ,sbcl-trivia.level1)
+ ("lisp-namespace" ,sbcl-lisp-namespace)
+ ("trivial-cltl2" ,sbcl-trivial-cltl2)
+ ("closer-mop" ,sbcl-closer-mop)))
+ (description "Trivia is a pattern matching compiler that is compatible
+with Optima, another pattern matching library for Common Lisp. It is meant to
+be faster and more extensible than Optima.
+
+This system contains a non-optimized pattern matcher compatible with Optima,
+with extensible optimizer interface.")))
+
+(define-public sbcl-trivia.trivial
+ (package
+ (inherit sbcl-trivia.level0)
+ (name "sbcl-trivia.trivial")
+ (inputs
+ `(("trivia.level2" ,sbcl-trivia.level2)))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (replace 'create-asd-file
+ (lambda* (#:key outputs inputs #:allow-other-keys)
+ (let* ((out (assoc-ref outputs "out"))
+ (lib (string-append out "/lib/" (%lisp-type)))
+ (level2 (assoc-ref inputs "trivia.level2")))
+ (mkdir-p lib)
+ (install-file "trivia.trivial.asd" lib)
+ ;; XXX: This .asd does not have any component and the build
+ ;; system fails to work in this case. We should update the
+ ;; build system to handle component-less .asd.
+ ;; TODO: How do we append to file in Guile? It seems that
+ ;; (open-file ... "a") gets a "Permission denied".
+ (substitute* (string-append lib "/trivia.trivial.asd")
+ (("\"\\)")
+ (string-append "\")
+
+(progn (asdf/source-registry:ensure-source-registry)
+ (setf (gethash
+ \"trivia.level2\"
+ asdf/source-registry:*source-registry*)
+ #p\""
+ level2
+ "/share/common-lisp/sbcl-bundle-systems/trivia.level2.asd\"))")))))))))
+ (description "Trivia is a pattern matching compiler that is compatible
+with Optima, another pattern matching library for Common Lisp. It is meant to
+be faster and more extensible than Optima.
+
+This system contains the base level system of Trivia with a trivial optimizer.")))
+
+(define-public sbcl-trivia.balland2006
+ (package
+ (inherit sbcl-trivia.level0)
+ (name "sbcl-trivia.balland2006")
+ (inputs
+ `(("trivia.trivial" ,sbcl-trivia.trivial)
+ ("iterate" ,sbcl-iterate)
+ ("type-i" ,sbcl-type-i)
+ ("alexandria" ,sbcl-alexandria)))
+ (arguments
+ ;; Tests are done in trivia itself.
+ `(#:tests? #f))
+ (description "Trivia is a pattern matching compiler that is compatible
+with Optima, another pattern matching library for Common Lisp. It is meant to
+be faster and more extensible than Optima.
+
+This system contains the base level system of Trivia with a trivial optimizer.")))
+
+(define-public sbcl-trivia.ppcre
+ (package
+ (inherit sbcl-trivia.level0)
+ (name "sbcl-trivia.ppcre")
+ (inputs
+ `(("trivia.trivial" ,sbcl-trivia.trivial)
+ ("cl-ppcre" ,sbcl-cl-ppcre)))
+ (description "Trivia is a pattern matching compiler that is compatible
+with Optima, another pattern matching library for Common Lisp. It is meant to
+be faster and more extensible than Optima.
+
+This system contains the PPCRE extension.")))
+
+(define-public sbcl-trivia.quasiquote
+ (package
+ (inherit sbcl-trivia.level0)
+ (name "sbcl-trivia.quasiquote")
+ (inputs
+ `(("trivia.trivial" ,sbcl-trivia.trivial)
+ ("fare-quasiquote" ,sbcl-fare-quasiquote)
+ ("fare-quasiquote-readtable" ,sbcl-fare-quasiquote-readtable)))
+ (description "Trivia is a pattern matching compiler that is compatible
+with Optima, another pattern matching library for Common Lisp. It is meant to
+be faster and more extensible than Optima.
+
+This system contains the fare-quasiquote extension.")))
+
+(define-public sbcl-trivia.cffi
+ (package
+ (inherit sbcl-trivia.level0)
+ (name "sbcl-trivia.cffi")
+ (inputs
+ `(("cffi" ,sbcl-cffi)
+ ("trivia.trivial" ,sbcl-trivia.trivial)))
+ (description "Trivia is a pattern matching compiler that is compatible
+with Optima, another pattern matching library for Common Lisp. It is meant to
+be faster and more extensible than Optima.
+
+This system contains the CFFI foreign slot access extension.")))
+
+(define-public sbcl-trivia
+ (package
+ (inherit sbcl-trivia.level0)
+ (name "sbcl-trivia")
+ (inputs
+ `(("trivia.balland2006" ,sbcl-trivia.balland2006)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)
+ ("trivia.ppcre" ,sbcl-trivia.ppcre)
+ ("trivia.quasiquote" ,sbcl-trivia.quasiquote)
+ ("trivia.cffi" ,sbcl-trivia.cffi)
+ ("optima" ,sbcl-optima)))
+ (arguments
+ `(#:test-asd-file "trivia.test.asd"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'create-asd 'remove-component
+ ;; XXX: The original .asd has no components, but our build system
+ ;; creates an entry nonetheless. We need to remove it for the
+ ;; generated .asd to load properly. See trivia.trivial for a
+ ;; similar problem.
+ (lambda* (#:key outputs #:allow-other-keys)
+ (let* ((out (assoc-ref outputs "out"))
+ (asd (string-append out "/lib/" (%lisp-type) "/trivia.asd")))
+ (substitute* asd
+ ((" :components
+")
+ ""))
+ (substitute* asd
+ ((" *\\(\\(:compiled-file \"trivia--system\"\\)\\)")
+ ""))))))))
+ (description "Trivia is a pattern matching compiler that is compatible
+with Optima, another pattern matching library for Common Lisp. It is meant to
+be faster and more extensible than Optima.")))
+
+(define-public cl-trivia
+ (sbcl-package->cl-source-package sbcl-trivia))
+
+(define-public sbcl-mk-string-metrics
+ (package
+ (name "sbcl-mk-string-metrics")
+ (version "0.1.2")
+ (home-page "https://github.com/cbaggers/mk-string-metrics/")
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit version)))
+ (sha256
+ (base32 "0bg0bv2mfd4k0g3x72x563hvmrx18xavaffr6xk5rh4if5j7kcf6"))
+ (file-name (git-file-name name version))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Calculate various string metrics efficiently in Common Lisp")
+ (description "This library implements efficient algorithms that calculate
+various string metrics in Common Lisp:
+
+@itemize
+@item Damerau-Levenshtein distance
+@item Hamming distance
+@item Jaccard similarity coefficient
+@item Jaro distance
+@item Jaro-Winkler distance
+@item Levenshtein distance
+@item Normalized Damerau-Levenshtein distance
+@item Normalized Levenshtein distance
+@item Overlap coefficient
+@end itemize\n")
+ (license license:x11)))
+
+(define-public cl-mk-string-metrics
+ (sbcl-package->cl-source-package sbcl-mk-string-metrics))
+
+(define-public sbcl-cl-str
+ (let ((commit "3d5ec86e3a0199e5973aacde951086dfd754b5e5"))
+ (package
+ (name "sbcl-cl-str")
+ (version (git-version "0.8" "1" commit))
+ (home-page "https://github.com/vindarel/cl-str")
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (sha256
+ (base32 "0szzzbygw9h985yxz909vvqrp69pmpcpahn7hn350lnyjislk9ga"))
+ (file-name (git-file-name name version))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("cl-ppcre" ,sbcl-cl-ppcre)
+ ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)))
+ (native-inputs
+ `(("prove" ,sbcl-prove)
+ ("prove-asdf" ,sbcl-prove-asdf)))
+ (arguments
+ `(#:asd-file "str.asd"
+ #:asd-system-name "str"
+ #:test-asd-file "str.test.asd"))
+ (synopsis "Modern, consistent and terse Common Lisp string manipulation library")
+ (description "A modern and consistent Common Lisp string manipulation
+library that focuses on modernity, simplicity and discoverability:
+@code{(str:trim s)} instead of @code{(string-trim '(#\\Space ...) s)}), or
+@code{str:concat strings} instead of an unusual format construct; one
+discoverable library instead of many; consistency and composability, where
+@code{s} is always the last argument, which makes it easier to feed pipes and
+arrows.")
+ (license license:expat))))
+
+(define-public cl-str
+ (sbcl-package->cl-source-package sbcl-cl-str))
+
+(define-public sbcl-cl-xmlspam
+ (let ((commit "ea06abcca2a73a9779bcfb09081e56665f94e22a"))
+ (package
+ (name "sbcl-cl-xmlspam")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.0.0" "1" commit))
+ (home-page "https://github.com/rogpeppe/cl-xmlspam")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (string-append name "-" version))
+ (sha256
+ (base32
+ "0w4rqvrgdgk3fwfq3kx4r7wwdr2bv3b6n3bdqwsiriw9psqzpz2s"))))
+ (inputs
+ `(("cxml" ,sbcl-cxml)
+ ("cl-ppcre" ,sbcl-cl-ppcre)))
+ (synopsis "Concise, regexp-like pattern matching on streaming XML for Common Lisp")
+ (description "CXML does an excellent job at parsing XML elements, but what
+do you do when you have a XML file that's larger than you want to fit in
+memory, and you want to extract some information from it? Writing code to deal
+with SAX events, or even using Klacks, quickly becomes tedious.
+@code{cl-xmlspam} (for XML Stream PAttern Matcher) is designed to make it easy
+to write code that mirrors the structure of the XML that it's parsing. It
+also makes it easy to shift paradigms when necessary - the usual Lisp control
+constructs can be used interchangeably with pattern matching, and the full
+power of CXML is available when necessary.")
+ (license license:bsd-3))))
+
+;; TODO: dbus uses ASDF's package-inferred-system which is not supported by
+;; asdf-build-system/sbcl as of 2019-08-02. We should fix
+;; asdf-build-system/sbcl.
+(define-public cl-dbus
+ (let ((commit "24b452df3a45ca5dc95015500f34baad175c981a")
+ (revision "1"))
+ (package
+ (name "cl-dbus")
+ (build-system asdf-build-system/source)
+ (version (git-version "20190408" revision commit))
+ (home-page "https://github.com/death/dbus")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0fw2q866yddbf23nk9pxphm9gsasx35vjyss82xzvndnjmzlqfl5"))))
+ ;; Inputs must be propagated or else packages depending on this won't have the necessary packages.
+ (propagated-inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("trivial-garbage" ,sbcl-trivial-garbage)
+ ("babel" ,sbcl-babel)
+ ("iolib" ,sbcl-iolib)
+ ("iolib+multiplex" ,(@@ (gnu packages lisp) sbcl-iolib+multiplex))
+ ("iolib+syscalls" ,(@@ (gnu packages lisp) sbcl-iolib+syscalls))
+ ("iolib+streams" ,(@@ (gnu packages lisp) sbcl-iolib+streams))
+ ("iolib+sockets" ,(@@ (gnu packages lisp) sbcl-iolib+sockets))
+ ("ieee-floats" ,sbcl-ieee-floats)
+ ("flexi-streams" ,sbcl-flexi-streams)
+ ("cl-xmlspam" ,sbcl-cl-xmlspam)
+ ("ironclad" ,sbcl-ironclad)))
+ (synopsis "D-Bus client library for Common Lisp")
+ (description "This is a Common Lisp library that allows to publish D-Bus
+objects as well as send and notify other objects connected to a bus.")
+ (license license:bsd-2))))
+
+(define-public sbcl-cl-hooks
+ (let ((commit "5b638083f3b4f1221a52631d9c8a0a265565cac7")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-hooks")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.2.1" revision commit))
+ (home-page "https://github.com/scymtym/architecture.hooks")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0bg3l0a28lw5gqqjp6p6b5nhwqk46sgkb7184w5qbfngw1hk8x9y"))))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("let-plus" ,sbcl-let-plus)
+ ("trivial-garbage" ,sbcl-trivial-garbage)
+ ("closer-mop" ,sbcl-closer-mop)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (synopsis "Hooks extension point mechanism (as in Emacs) for Common Lisp")
+ (description "A hook, in the present context, is a certain kind of
+extension point in a program that allows interleaving the execution of
+arbitrary code with the execution of a the program without introducing any
+coupling between the two. Hooks are used extensively in the extensible editor
+Emacs.
+
+In the Common LISP Object System (CLOS), a similar kind of extensibility is
+possible using the flexible multi-method dispatch mechanism. It may even seem
+that the concept of hooks does not provide any benefits over the possibilities
+of CLOS. However, there are some differences:
+
+@itemize
+
+@item There can be only one method for each combination of specializers and
+qualifiers. As a result this kind of extension point cannot be used by
+multiple extensions independently.
+@item Removing code previously attached via a @code{:before}, @code{:after} or
+@code{:around} method can be cumbersome.
+@item There could be other or even multiple extension points besides @code{:before}
+and @code{:after} in a single method.
+@item Attaching codes to individual objects using eql specializers can be
+cumbersome.
+@item Introspection of code attached a particular extension point is
+cumbersome since this requires enumerating and inspecting the methods of a
+generic function.
+@end itemize
+
+This library tries to complement some of these weaknesses of method-based
+extension-points via the concept of hooks.")
+ (license license:llgpl))))
+
+(define-public cl-hooks
+ (sbcl-package->cl-source-package sbcl-cl-hooks))
+
+(define-public ecl-cl-hooks
+ (sbcl-package->ecl-package sbcl-cl-hooks))
+
+(define-public sbcl-s-sysdeps
+ (let ((commit "d28246b5dffef9e73a0e0e6cfbc4e878006fe34d")
+ (revision "1"))
+ (package
+ (name "sbcl-s-sysdeps")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "1" revision commit))
+ (home-page "https://github.com/svenvc/s-sysdeps")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "14b69b81yrxmjlvmm3lfxk04x5v7hqz4fql121334wh72czznfh9"))))
+ (synopsis "Common Lisp abstraction layer over platform dependent functionality")
+ (description "@code{s-sysdeps} is an abstraction layer over platform
+dependent functionality. This simple package is used as a building block in a
+number of other open source projects.
+
+@code{s-sysdeps} abstracts:
+
+@itemize
+@item managing processes,
+@item implementing a standard TCP/IP server,
+@item opening a client TCP/IP socket stream,
+@item working with process locks.
+@end itemize\n")
+ (license license:llgpl))))
+
+(define-public cl-s-sysdeps
+ (sbcl-package->cl-source-package sbcl-s-sysdeps))
+
+(define-public ecl-s-sysdeps
+ (sbcl-package->ecl-package sbcl-s-sysdeps))
+
+(define-public sbcl-cl-prevalence
+ (let ((commit "c163c227ed85d430b82cb1e3502f72d4f88e3cfa")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-prevalence")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "5" revision commit))
+ (home-page "https://github.com/40ants/cl-prevalence")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1i9zj1q2ahgwch56an21yzbgkynz0kab9fyxkq9mg8p3xrv38jjn"))))
+ (inputs
+ `(("s-sysdeps" ,sbcl-s-sysdeps)
+ ("s-xml" ,sbcl-s-xml)))
+ (synopsis "Implementation of object prevalence for Common Lisp")
+ (description "This Common Lisp library implements object prevalence (see
+@url{https://en.wikipedia.org/wiki/System_prevalence}). It allows
+for (de)serializing to and from s-exps as well as XML. Serialization of arbitrary
+classes and cyclic data structures are supported.")
+ (license license:llgpl))))
+
+(define-public cl-prevalence
+ (sbcl-package->cl-source-package sbcl-cl-prevalence))
+
+(define-public ecl-cl-prevalence
+ (sbcl-package->ecl-package sbcl-cl-prevalence))
+
+(define-public sbcl-series
+ (let ((commit "da9061b336119d1e5214aff9117171d494d5a58a")
+ (revision "1"))
+ (package
+ (name "sbcl-series")
+ (version (git-version "2.2.11" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "git://git.code.sf.net/p/series/series")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "07hk2lhfx42zk018pxqvn4gs77vd4n4g8m4xxbqaxgca76mifwfw"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; Disable the tests, they are apparently buggy and I didn't find
+ ;; a simple way to make them run and pass.
+ '(#:tests? #f))
+ (synopsis "Series data structure for Common Lisp")
+ (description
+ "This Common Lisp library provides a series data structure much like
+a sequence, with similar kinds of operations. The difference is that in many
+situations, operations on series may be composed functionally and yet execute
+iteratively, without the need to construct intermediate series values
+explicitly. In this manner, series provide both the clarity of a functional
+programming style and the efficiency of an iterative programming style.")
+ (home-page "http://series.sourceforge.net/")
+ (license license:expat))))
+
+(define-public cl-series
+ (sbcl-package->cl-source-package sbcl-series))
+
+(define-public ecl-series
+ (sbcl-package->ecl-package sbcl-series))
+
+(define-public sbcl-periods
+ (let ((commit "983d4a57325db3c8def942f163133cec5391ec28")
+ (revision "1"))
+ (package
+ (name "sbcl-periods")
+ (version (git-version "0.0.2" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/jwiegley/periods.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0z30jr3lxz3cmi019fsl4lgcgwf0yqpn95v9zkkkwgymdrkd4lga"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("local-time" ,sbcl-local-time)))
+ (synopsis "Common Lisp library for manipulating date/time objects")
+ (description
+ "Periods is a Common Lisp library providing a set of utilities for
+manipulating times, distances between times, and both contiguous and
+discontiguous ranges of time.")
+ (home-page "https://github.com/jwiegley/periods")
+ (license license:bsd-3))))
+
+(define-public cl-periods
+ (sbcl-package->cl-source-package sbcl-periods))
+
+(define-public ecl-periods
+ (sbcl-package->ecl-package sbcl-periods))
+
+(define-public sbcl-periods-series
+ (package
+ (inherit sbcl-periods)
+ (name "sbcl-periods-series")
+ (inputs
+ `(("periods" ,sbcl-periods)
+ ("series" ,sbcl-series)))
+ (arguments
+ '(#:asd-file "periods-series.asd"
+ #:asd-system-name "periods-series"))
+ (description
+ "Periods-series is an extension of the periods Common Lisp library
+providing functions compatible with the series Common Lisp library.")))
+
+(define-public cl-periods-series
+ (sbcl-package->cl-source-package sbcl-periods-series))
+
+(define-public ecl-periods-series
+ (sbcl-package->ecl-package sbcl-periods-series))
+
+(define-public sbcl-metatilities-base
+ (let ((commit "6eaa9e3ff0939a93a92109dd0fcd218de85417d5")
+ (revision "1"))
+ (package
+ (name "sbcl-metatilities-base")
+ (version (git-version "0.6.6" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/gwkkwg/metatilities-base.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0xpa86pdzlnf4v5g64j3ifaplx71sx2ha8b7vvakswi652679ma0"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("lift" ,sbcl-lift)))
+ (synopsis "Core of the metatilities Common Lisp library")
+ (description
+ "Metatilities-base is the core of the metatilities Common Lisp library
+which implements a set of utilities.")
+ (home-page "https://common-lisp.net/project/metatilities-base/")
+ (license license:expat))))
+
+(define-public cl-metatilities-base
+ (sbcl-package->cl-source-package sbcl-metatilities-base))
+
+(define-public ecl-metatilities-base
+ (sbcl-package->ecl-package sbcl-metatilities-base))
+
+(define-public sbcl-cl-containers
+ (let ((commit "810927e19d933bcf38ffeb7a23ce521efc432d45")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-containers")
+ (version (git-version "0.12.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/gwkkwg/cl-containers.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1s9faxw7svhbjpkhfrz2qxgjm3cvyjb8wpyb4m8dx4i5g7vvprkv"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("lift" ,sbcl-lift)))
+ (inputs
+ `(("metatilities-base" ,sbcl-metatilities-base)))
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'relax-version-checks
+ (lambda _
+ (substitute* "cl-containers.asd"
+ (("\\(:version \"metatilities-base\" \"0\\.6\\.6\"\\)")
+ "\"metatilities-base\""))
+ (substitute* "cl-containers-test.asd"
+ (("\\(:version \"lift\" \"1\\.7\\.0\"\\)")
+ "\"lift\""))
+ #t)))))
+ (synopsis "Container library for Common Lisp")
+ (description
+ "Common Lisp ships with a set of powerful built in data structures
+including the venerable list, full featured arrays, and hash-tables.
+CL-containers enhances and builds on these structures by adding containers
+that are not available in native Lisp (for example: binary search trees,
+red-black trees, sparse arrays and so on), and by providing a standard
+interface so that they are simpler to use and so that changing design
+decisions becomes significantly easier.")
+ (home-page "https://common-lisp.net/project/cl-containers/")
+ (license license:expat))))
+
+(define-public cl-containers
+ (sbcl-package->cl-source-package sbcl-cl-containers))
+
+(define-public ecl-cl-containers
+ (sbcl-package->ecl-package sbcl-cl-containers))
+
+(define-public sbcl-xlunit
+ (let ((commit "3805d34b1d8dc77f7e0ee527a2490194292dd0fc")
+ (revision "1"))
+ (package
+ (name "sbcl-xlunit")
+ (version (git-version "0.6.3" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "http://git.kpe.io/xlunit.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0argfmp9nghs4sihyj3f8ch9qfib2b7ll07v5m9ziajgzsfl5xw3"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-tests
+ (lambda _
+ (substitute* "xlunit.asd"
+ ((" :force t") ""))
+ #t)))))
+ (synopsis "Unit testing package for Common Lisp")
+ (description
+ "The XLUnit package is a toolkit for building test suites. It is based
+on the XPTest package by Craig Brozensky and the JUnit package by Kent Beck.")
+ (home-page "http://quickdocs.org/xlunit/")
+ (license license:bsd-3))))
+
+(define-public cl-xlunit
+ (sbcl-package->cl-source-package sbcl-xlunit))
+
+(define-public ecl-xlunit
+ (sbcl-package->ecl-package sbcl-xlunit))
+
+(define-public sbcl-fprog
+ (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636")
+ (revision "1"))
+ (package
+ (name "sbcl-fprog")
+ (version (git-version "1.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/jwiegley/cambl.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "103mry04j2k9vznsxm7wcvccgxkil92cdrv52miwcmxl8daa4jiz"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Functional programming utilities for Common Lisp")
+ (description
+ "@code{fprog} is a Common Lisp library allowing iteration over
+immutable lists sharing identical sublists.")
+ (home-page "https://github.com/jwiegley/cambl")
+ (license license:bsd-3))))
+
+(define-public cl-fprog
+ (sbcl-package->cl-source-package sbcl-fprog))
+
+(define-public ecl-fprog
+ (sbcl-package->ecl-package sbcl-fprog))
+
+(define-public sbcl-cambl
+ (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636")
+ (revision "1"))
+ (package
+ (inherit sbcl-fprog)
+ (name "sbcl-cambl")
+ (version (git-version "4.0.0" revision commit))
+ (native-inputs
+ `(("xlunit" ,sbcl-xlunit)))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-containers" ,sbcl-cl-containers)
+ ("local-time" ,sbcl-local-time)
+ ("periods" ,sbcl-periods)
+ ("fprog" ,sbcl-fprog)))
+ (synopsis "Commoditized amounts and balances for Common Lisp")
+ (description
+ "CAMBL is a Common Lisp library providing a convenient facility for
+working with commoditized values. It does not allow compound units (and so is
+not suited for scientific operations) but does work rather nicely for the
+purpose of financial calculations."))))
+
+(define-public cl-cambl
+ (sbcl-package->cl-source-package sbcl-cambl))
+
+(define-public ecl-cambl
+ (sbcl-package->ecl-package sbcl-cambl))
+
+(define-public sbcl-cl-ledger
+ (let ((commit "08e0be41795e804cd36142e51756ad0b1caa377b")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-ledger")
+ (version (git-version "4.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/ledger/cl-ledger.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1via0qf6wjcyxnfbmfxjvms0ik9j8rqbifgpmnhrzvkhrq9pv8h1"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("cambl" ,sbcl-cambl)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("local-time" ,sbcl-local-time)
+ ("periods-series" ,sbcl-periods-series)))
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-system-definition
+ (lambda _
+ (substitute* "cl-ledger.asd"
+ ((" :build-operation program-op") "")
+ ((" :build-pathname \"cl-ledger\"") "")
+ ((" :entry-point \"ledger::main\"") ""))
+ #t)))))
+ (synopsis "Common Lisp port of the Ledger accounting system")
+ (description
+ "CL-Ledger is a Common Lisp port of the Ledger double-entry accounting
+system.")
+ (home-page "https://github.com/ledger/cl-ledger")
+ (license license:bsd-3))))
+
+(define-public cl-ledger
+ (sbcl-package->cl-source-package sbcl-cl-ledger))
+
+(define-public ecl-cl-ledger
+ (sbcl-package->ecl-package sbcl-cl-ledger))
+
+(define-public sbcl-bst
+ (let ((commit "34f9c7e8e0a9f2c952fe310ab36cb630d5d9c15a")
+ (revision "1"))
+ (package
+ (name "sbcl-bst")
+ (version (git-version "1.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/glv2/bst.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1amxns7hvvh4arwbh8ciwfzplg127vh37dnbamv1m1kmmnmihfc8"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("fiveam" ,sbcl-fiveam)))
+ (synopsis "Binary search tree for Common Lisp")
+ (description
+ "BST is a Common Lisp library for working with binary search trees that
+can contain any kind of values.")
+ (home-page "https://github.com/glv2/bst")
+ (license license:gpl3))))
+
+(define-public cl-bst
+ (sbcl-package->cl-source-package sbcl-bst))
+
+(define-public ecl-bst
+ (sbcl-package->ecl-package sbcl-bst))
+
+(define-public sbcl-cl-octet-streams
+ (package
+ (name "sbcl-cl-octet-streams")
+ (version "1.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/glv2/cl-octet-streams.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1d7mn6ydv0j2x4r7clpc9ijjwrnfpxmvhifv8n5j7jh7s744sf8d"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (inputs
+ `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
+ (synopsis "In-memory octet streams for Common Lisp")
+ (description
+ "CL-octet-streams is a library implementing in-memory octet
+streams for Common Lisp. It was inspired by the trivial-octet-streams and
+cl-plumbing libraries.")
+ (home-page "https://github.com/glv2/cl-octet-streams")
+ (license license:gpl3+)))
+
+(define-public cl-octet-streams
+ (sbcl-package->cl-source-package sbcl-cl-octet-streams))
+
+(define-public ecl-cl-octet-streams
+ (sbcl-package->ecl-package sbcl-cl-octet-streams))
+
+(define-public sbcl-lzlib
+ (let ((commit "0de1db7129fef9a58a059d35a2fa2ecfc5b47b47")
+ (revision "1"))
+ (package
+ (name "sbcl-lzlib")
+ (version (git-version "1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/glv2/cl-lzlib.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "12ny7vj52fgnd8hb8fc8mry92vq4c1x72x2350191m4476j95clz"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (inputs
+ `(("cffi" ,sbcl-cffi)
+ ("cl-octet-streams" ,sbcl-cl-octet-streams)
+ ("lzlib" ,lzlib)))
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/lzlib.lisp"
+ (("liblz\\.so")
+ (string-append (assoc-ref inputs "lzlib") "/lib/liblz.so")))
+ #t)))))
+ (synopsis "Common Lisp library for lzip (de)compression")
+ (description
+ "This Common Lisp library provides functions for lzip (LZMA)
+compression/decompression using bindings to the lzlib C library.")
+ (home-page "https://github.com/glv2/cl-lzlib")
+ (license license:gpl3+))))
+
+(define-public cl-lzlib
+ (sbcl-package->cl-source-package sbcl-lzlib))
+
+(define-public ecl-lzlib
+ (sbcl-package->ecl-package sbcl-lzlib))
+
+(define-public sbcl-chanl
+ (let ((commit "2362b57550c2c9238cc882d03553aaa1040b7340")
+ (revision "0"))
+ (package
+ (name "sbcl-chanl")
+ (version (git-version "0.4.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/zkat/chanl.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0ag3wz7yrqwp0s5069wwda98z3rrqd25spg8sa8rdqghj084w28w"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (inputs
+ `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
+ (synopsis "Portable channel-based concurrency for Common Lisp")
+ (description "Common Lisp library for channel-based concurrency. In
+a nutshell, you create various threads sequentially executing tasks you need
+done, and use channel objects to communicate and synchronize the state of these
+threads.")
+ (home-page "https://github.com/zkat/chanl")
+ (license (list license:expat license:bsd-3)))))
+
+(define-public cl-chanl
+ (sbcl-package->cl-source-package sbcl-chanl))
+
+(define-public ecl-chanl
+ (let ((base (sbcl-package->ecl-package sbcl-chanl)))
+ (package
+ (inherit base)
+ (arguments
+ (substitute-keyword-arguments (package-arguments base)
+ ;; The CHANL.ACTORS package uses the :ARGUMENTS option of
+ ;; DEFINE-METHOD-COMBINATION, which is not implemented in ECL yet
+ ;; (see https://gitlab.com/embeddable-common-lisp/ecl/issues/305).
+ ;; So let's disable it for now, as it allows compiling the library
+ ;; and using the rest of it.
+ ((#:phases phases '%standard-phases)
+ `(modify-phases ,phases
+ (add-after 'unpack 'disable-chanl-actors
+ (lambda _
+ (substitute* "chanl.asd"
+ (("\\(:file \"actors\"\\)") ""))
+ #t))))
+ ;; Disable the tests for now, as the SEND-SEQUENCE test seems to
+ ;; never end.
+ ((#:tests? _ #f) #f))))))
+
+(define-public sbcl-cl-store
+ (let ((commit "cd01f2610d3360dc01ab972bd9317407aaea7745")
+ (revision "0"))
+ (package
+ (name "sbcl-cl-store")
+ (version (git-version "0.8.11" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/skypher/cl-store.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "05b7kh5af2ax7vlmphpac4vbqr84j5ivppj96qzb64fxpjpqglm4"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("rt" ,sbcl-rt)))
+ (synopsis "Common Lisp library to serialize data")
+ (description
+ "CL-STORE is a portable serialization package which should give you the
+ability to store all Common Lisp data types into streams.")
+ (home-page "http://www.common-lisp.net/project/cl-store/")
+ (license license:expat))))
+
+(define-public cl-store
+ (sbcl-package->cl-source-package sbcl-cl-store))
+
+(define-public ecl-cl-store
+ (sbcl-package->ecl-package sbcl-cl-store))
+
+(define-public sbcl-cl-gobject-introspection
+ (let ((commit "7b703e2384945ea0ac39d9b766de434a08d81560")
+ (revision "0"))
+ (package
+ (name "sbcl-cl-gobject-introspection")
+ (version (git-version "0.3" revision commit))
+ (home-page "https://github.com/andy128k/cl-gobject-introspection")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1zcqd2qj14f6b38vys8gr89s6cijsp9r8j43xa8lynilwva7bwyh"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cffi" ,sbcl-cffi)
+ ("iterate" ,sbcl-iterate)
+ ("trivial-garbage" ,sbcl-trivial-garbage)
+ ("glib" ,glib)
+ ("gobject-introspection" ,gobject-introspection)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (arguments
+ ;; TODO: Tests fail, see
+ ;; https://github.com/andy128k/cl-gobject-introspection/issues/70.
+ '(#:tests? #f
+ #:phases
+ (modify-phases %standard-phases
+ (add-after (quote unpack) (quote fix-paths)
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/init.lisp"
+ (("libgobject-2\\.0\\.so")
+ (string-append (assoc-ref inputs "glib") "/lib/libgobject-2.0.so"))
+ (("libgirepository-1\\.0\\.so")
+ (string-append (assoc-ref inputs "gobject-introspection")
+ "/lib/libgirepository-1.0.so")))
+ #t)))))
+ (synopsis "Common Lisp bindings to GObject Introspection")
+ (description
+ "This library is a bridge between Common Lisp and GObject
+Introspection, which enables Common Lisp programs to access the full interface
+of C+GObject libraries without the need of writing dedicated bindings.")
+ (license (list license:bsd-3
+ ;; Tests are under a different license.
+ license:llgpl)))))
+
+(define-public cl-gobject-introspection
+ (sbcl-package->cl-source-package sbcl-cl-gobject-introspection))
+
+(define-public sbcl-string-case
+ (let ((commit "718c761e33749e297cd2809c7ba3ade1985c49f7")
+ (revision "0"))
+ (package
+ (name "sbcl-string-case")
+ (version (git-version "0.0.2" revision commit))
+ (home-page "https://github.com/pkhuong/string-case")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1n5i3yh0h5s636rcnwn7jwqy3rjflikra04lymimhpcshhjsk0md"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Efficient string= case in Common Lisp")
+ (description
+ "@code{string-case} is a Common Lisp macro that generates specialised decision
+trees to dispatch on string equality.")
+ (license license:bsd-3))))
+
+(define-public cl-string-case
+ (sbcl-package->cl-source-package sbcl-string-case))
+
+(define-public ecl-string-case
+ (sbcl-package->ecl-package sbcl-string-case))
+
+(define-public sbcl-global-vars
+ (let ((commit "c749f32c9b606a1457daa47d59630708ac0c266e")
+ (revision "0"))
+ (package
+ (name "sbcl-global-vars")
+ (version (git-version "1.0.0" revision commit))
+ (home-page "https://github.com/lmj/global-vars")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "06m3xc8l3pgsapl8fvsi9wf6y46zs75cp9zn7zh6dc65v4s5wz3d"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Efficient global variables in Common Lisp")
+ (description
+ "In Common Lisp, a special variable that is never dynamically bound
+typically serves as a stand-in for a global variable. The @code{global-vars}
+library provides true global variables that are implemented by some compilers.
+An attempt to rebind a global variable properly results in a compiler error.
+That is, a global variable cannot be dynamically bound.
+
+Global variables therefore allow us to communicate an intended usage that
+differs from special variables. Global variables are also more efficient than
+special variables, especially in the presence of threads.")
+ (license license:expat))))
+
+(define-public cl-global-vars
+ (sbcl-package->cl-source-package sbcl-global-vars))
+
+(define-public ecl-global-vars
+ (sbcl-package->ecl-package sbcl-global-vars))
+
+(define-public sbcl-trivial-file-size
+ (let ((commit "1c1d672a01a446ba0391dbb4ffc40be3b0476f23")
+ (revision "0"))
+ (package
+ (name "sbcl-trivial-file-size")
+ (version (git-version "0.0.0" revision commit))
+ (home-page "https://github.com/ruricolist/trivial-file-size")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "17pp86c9zs4y7i1sh7q9gbfw9iqv6655k7fz8qbj9ly1ypgxp4qs"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (synopsis "Size of a file in bytes in Common Lisp")
+ (description
+ "The canonical way to determine the size of a file in bytes, using Common Lisp,
+is to open the file with an element type of (unsigned-byte 8) and then
+calculate the length of the stream. This is less than ideal. In most cases
+it is better to get the size of the file from its metadata, using a system
+call.
+
+This library exports a single function, file-size-in-octets. It returns the
+size of a file in bytes, using system calls when possible.")
+ (license license:expat))))
+
+(define-public cl-trivial-file-size
+ (sbcl-package->cl-source-package sbcl-trivial-file-size))
+
+(define-public ecl-trivial-file-size
+ (sbcl-package->ecl-package sbcl-trivial-file-size))
+
+(define-public sbcl-trivial-macroexpand-all
+ (let ((commit "933270ac7107477de1bc92c1fd641fe646a7a8a9")
+ (revision "0"))
+ (package
+ (name "sbcl-trivial-macroexpand-all")
+ (version (git-version "0.0.0" revision commit))
+ (home-page "https://github.com/cbaggers/trivial-macroexpand-all")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "191hnn4b5j4i3crydmlzbm231kj0h7l8zj6mzj69r1npbzkas4bd"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (synopsis "Portable macroexpand-all for Common Lisp")
+ (description
+ "This library provides a macroexpand-all function that calls the
+implementation specific equivalent.")
+ (license license:unlicense))))
+
+(define-public cl-trivial-macroexpand-all
+ (sbcl-package->cl-source-package sbcl-trivial-macroexpand-all))
+
+(define-public ecl-trivial-macroexpand-all
+ (sbcl-package->ecl-package sbcl-trivial-macroexpand-all))
+
+(define-public sbcl-serapeum
+ (let ((commit "65837f8a0d65b36369ec8d000fff5c29a395b5fe")
+ (revision "0"))
+ (package
+ (name "sbcl-serapeum")
+ (version (git-version "0.0.0" revision commit))
+ (home-page "https://github.com/ruricolist/serapeum")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0clwf81r2lvk1rbfvk91s9zmbkas9imf57ilqclw12mxaxlfsnbw"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("trivia" ,sbcl-trivia)
+ ("trivia.quasiquote" ,sbcl-trivia.quasiquote)
+ ("split-sequence" ,sbcl-split-sequence)
+ ("string-case" ,sbcl-string-case)
+ ("parse-number" ,sbcl-parse-number)
+ ("trivial-garbage" ,sbcl-trivial-garbage)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("named-readtables" ,sbcl-named-readtables)
+ ("fare-quasiquote-extras" ,cl-fare-quasiquote-extras)
+ ("parse-declarations-1.0" ,sbcl-parse-declarations)
+ ("global-vars" ,sbcl-global-vars)
+ ("trivial-file-size" ,sbcl-trivial-file-size)
+ ("trivial-macroexpand-all" ,sbcl-trivial-macroexpand-all)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)
+ ("local-time" ,sbcl-local-time)))
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'disable-failing-tests
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "serapeum.asd"
+ ;; Guix does not have Quicklisp, and probably never will.
+ (("\\(:file \"quicklisp\"\\)") ""))
+ #t)))))
+ (synopsis "Common Lisp utility library beyond Alexandria")
+ (description
+ "Serapeum is a conservative library of Common Lisp utilities. It is a
+supplement, not a competitor, to Alexandria.")
+ (license license:expat))))
+
+(define-public cl-serapeum
+ (sbcl-package->cl-source-package sbcl-serapeum))
+
+(define-public sbcl-arrows
+ (let ((commit "df7cf0067e0132d9697ac8b1a4f1b9c88d4f5382")
+ (revision "0"))
+ (package
+ (name "sbcl-arrows")
+ (version (git-version "0.2.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://gitlab.com/Harleqin/arrows.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "042k9vkssrqx9nhp14wdzm942zgdxvp35mba0p2syz98i75im2yy"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
+ (synopsis "Clojure-like arrow macros for Common Lisp")
+ (description
+ "This library implements the @code{->} and @code{->>} macros from
+Clojure, as well as several expansions on the idea.")
+ (home-page "https://gitlab.com/Harleqin/arrows")
+ (license license:public-domain))))
+
+(define-public cl-arrows
+ (sbcl-package->cl-source-package sbcl-arrows))
+
+(define-public ecl-arrows
+ (sbcl-package->ecl-package sbcl-arrows))
+
+(define-public sbcl-simple-parallel-tasks
+ (let ((commit "db460f7a3f7bbfe2d3a2223ed21e162068d04dda")
+ (revision "0"))
+ (package
+ (name "sbcl-simple-parallel-tasks")
+ (version (git-version "1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/glv2/simple-parallel-tasks.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0amw3qk23wnlyrsgzszs6rs7y4zvxv8dr03rnqhc60mnm8ds4dd5"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (inputs
+ `(("chanl" ,sbcl-chanl)))
+ (synopsis "Common Lisp library to evaluate some forms in parallel")
+ (description "This is a simple Common Lisp library to evaluate some
+forms in parallel.")
+ (home-page "https://github.com/glv2/simple-parallel-tasks")
+ (license license:gpl3))))
+
+(define-public cl-simple-parallel-tasks
+ (sbcl-package->cl-source-package sbcl-simple-parallel-tasks))
+
+(define-public ecl-simple-parallel-tasks
+ (sbcl-package->ecl-package sbcl-simple-parallel-tasks))
+
+(define-public sbcl-cl-heap
+ (package
+ (name "sbcl-cl-heap")
+ (version "0.1.6")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://common-lisp.net/project/cl-heap/releases/"
+ "cl-heap_" version ".tar.gz"))
+ (sha256
+ (base32
+ "163hb07p2nxz126rpq3cj5dyala24n0by5i5786n2qcr1w0bak4i"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("xlunit" ,sbcl-xlunit)))
+ (arguments
+ `(#:test-asd-file "cl-heap-tests.asd"))
+ (synopsis "Heap and priority queue data structures for Common Lisp")
+ (description
+ "CL-HEAP provides various implementations of heap data structures (a
+binary heap and a Fibonacci heap) as well as an efficient priority queue.")
+ (home-page "https://common-lisp.net/project/cl-heap/")
+ (license license:gpl3+)))
+
+(define-public cl-heap
+ (sbcl-package->cl-source-package sbcl-cl-heap))
+
+(define-public ecl-cl-heap
+ (sbcl-package->ecl-package sbcl-cl-heap))
+
+(define-public sbcl-curry-compose-reader-macros
+ (let ((commit "beaa92dedf392726c042184bfd6149fa8d9e6ac2")
+ (revision "0"))
+ (package
+ (name "sbcl-curry-compose-reader-macros")
+ (version (git-version "1.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri
+ (git-reference
+ (url "https://github.com/eschulte/curry-compose-reader-macros.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0rv9bl8xrad5wfcg5zs1dazvnpmvqz6297lbn8bywsrcfnlf7h98"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("named-readtables" ,sbcl-named-readtables)))
+ (synopsis "Reader macros for partial application and composition")
+ (description
+ "This Common Lisp library provides reader macros for concise expression
+of function partial application and composition.")
+ (home-page "https://eschulte.github.io/curry-compose-reader-macros/")
+ (license license:public-domain))))
+
+(define-public cl-curry-compose-reader-macros
+ (sbcl-package->cl-source-package sbcl-curry-compose-reader-macros))
+
+(define-public ecl-curry-compose-reader-macros
+ (sbcl-package->ecl-package sbcl-curry-compose-reader-macros))
+
+(define-public sbcl-yason
+ (package
+ (name "sbcl-yason")
+ (version "0.7.7")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/phmarek/yason.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0479rbjgbj80jpk5bby18inlv1kfp771a82rlcq5psrz65qqa9bj"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
+ (synopsis "Common Lisp JSON parser/encoder")
+ (description
+ "YASON is a Common Lisp library for encoding and decoding data in the
+JSON interchange format.")
+ (home-page "https://github.com/phmarek/yason")
+ (license license:bsd-3)))
+
+(define-public cl-yason
+ (sbcl-package->cl-source-package sbcl-yason))
+
+(define-public ecl-yason
+ (sbcl-package->ecl-package sbcl-yason))
+
+(define-public sbcl-stefil
+ (let ((commit "0398548ec95dceb50fc2c2c03e5fb0ce49b86c7a")
+ (revision "0"))
+ (package
+ (name "sbcl-stefil")
+ (version (git-version "0.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://gitlab.common-lisp.net/stefil/stefil.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0bqz64q2szzhf91zyqyssmvrz7da6442rs01808pf3wrdq28bclh"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("iterate" ,sbcl-iterate)
+ ("metabang-bind" ,sbcl-metabang-bind)))
+ (propagated-inputs
+ ;; Swank doesn't have a pre-compiled package, therefore we must
+ ;; propagate its sources.
+ `(("swank" ,cl-slime-swank)))
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'drop-unnecessary-dependency
+ (lambda _
+ (substitute* "package.lisp"
+ ((":stefil-system") ""))
+ #t)))))
+ (home-page "https://common-lisp.net/project/stefil/index-old.shtml")
+ (synopsis "Simple test framework")
+ (description
+ "Stefil is a simple test framework for Common Lisp, with a focus on
+interactive development.")
+ (license license:public-domain))))
+
+(define-public cl-stefil
+ (sbcl-package->cl-source-package sbcl-stefil))
+
+(define-public sbcl-graph
+ (let ((commit "78bf9ec930d8eae4f0861b5be76765fb1e45e24f")
+ (revision "0"))
+ (package
+ (name "sbcl-graph")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri
+ (git-reference
+ (url "https://github.com/eschulte/graph.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1qpij4xh8bqwc2myahpilcbh916v7vg0acz2fij14d3y0jm02h0g"))
+ (patches (search-patches "sbcl-graph-asdf-definitions.patch"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("stefil" ,sbcl-stefil)))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-heap" ,sbcl-cl-heap)
+ ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
+ ("metabang-bind" ,sbcl-metabang-bind)
+ ("named-readtables" ,sbcl-named-readtables)))
+ (arguments
+ '(#:test-asd-file "graph.test.asd"))
+ (synopsis "Graph data structure and algorithms for Common Lisp")
+ (description
+ "The GRAPH Common Lisp library provides a data structures to represent
+graphs, as well as some graph manipulation and analysis algorithms (shortest
+path, maximum flow, minimum spanning tree, etc.).")
+ (home-page "https://eschulte.github.io/graph/")
+ (license license:gpl3+))))
+
+(define-public cl-graph
+ (sbcl-package->cl-source-package sbcl-graph))
+
+(define-public sbcl-graph-dot
+ (package
+ (inherit sbcl-graph)
+ (name "sbcl-graph-dot")
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
+ ("graph" ,sbcl-graph)
+ ("metabang-bind" ,sbcl-metabang-bind)
+ ("named-readtables" ,sbcl-named-readtables)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-graph)
+ ((#:asd-file _ "") "graph.dot.asd")
+ ((#:asd-system-name _ #f) "graph-dot")))
+ (synopsis "Serialize graphs to and from DOT format")))
+
+(define-public sbcl-graph-json
+ (package
+ (inherit sbcl-graph)
+ (name "sbcl-graph-json")
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
+ ("graph" ,sbcl-graph)
+ ("metabang-bind" ,sbcl-metabang-bind)
+ ("named-readtables" ,sbcl-named-readtables)
+ ("yason" ,sbcl-yason)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments sbcl-graph)
+ ((#:asd-file _ "") "graph.json.asd")
+ ((#:asd-system-name _ #f) "graph-json")))
+ (synopsis "Serialize graphs to and from JSON format")))
diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index 9a83a1598a..dc44a9d133 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -31,13 +31,17 @@
;;; You should have received a copy of the GNU General Public License
;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>.
+;;; This file only contains Common Lisp compilers and tooling.
+;;; Common Lisp libraries go to lisp-xyz.scm.
+;;; Common Lisp applications should go to the most appropriate file,
+;;; e.g. StumpWM is in wm.scm.
+
(define-module (gnu packages lisp)
#:use-module (gnu packages)
#:use-module ((guix licenses) #:prefix license:)
#:use-module (guix packages)
#:use-module (guix download)
#:use-module (guix git-download)
- #:use-module (guix hg-download)
#:use-module (guix utils)
#:use-module (guix build-system gnu)
#:use-module (guix build-system ant)
@@ -47,7 +51,6 @@
#:use-module (gnu packages base)
#:use-module (gnu packages bdw-gc)
#:use-module (gnu packages bison)
- #:use-module (gnu packages c)
#:use-module (gnu packages compression)
#:use-module (gnu packages ed)
#:use-module (gnu packages flex)
@@ -65,23 +68,13 @@
#:use-module (gnu packages libsigsegv)
#:use-module (gnu packages linux)
#:use-module (gnu packages perl)
- #:use-module (gnu packages pkg-config)
- #:use-module (gnu packages python)
- #:use-module (gnu packages python-xyz)
#:use-module (gnu packages readline)
#:use-module (gnu packages sdl)
- #:use-module (gnu packages sqlite)
#:use-module (gnu packages tex)
#:use-module (gnu packages texinfo)
- #:use-module (gnu packages tls)
#:use-module (gnu packages version-control)
#:use-module (gnu packages xorg)
- #:use-module (gnu packages databases)
- #:use-module (gnu packages gtk)
- #:use-module (gnu packages webkit)
- #:use-module (gnu packages xdisorg)
- #:use-module (ice-9 match)
- #:use-module (srfi srfi-19))
+ #:use-module (ice-9 match))
(define (asdf-substitutions lisp)
;; Prepend XDG_DATA_DIRS/LISP-bundle-systems to ASDF's
@@ -699,928 +692,6 @@ libraries for Machine Learning, Neural Nets and statistical estimation.")
(home-page "http://lush.sourceforge.net/")
(license license:lgpl2.1+)))
-(define-public sbcl-alexandria
- (let ((revision "1")
- (commit "3b849bc0116ea70f215ee6b2fbf354e862aaa9dd"))
- (package
- (name "sbcl-alexandria")
- (version (git-version "1.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://gitlab.common-lisp.net/alexandria/alexandria.git")
- (commit commit)))
- (sha256
- (base32
- "04amwvx2vl691f0plcfbqqwxgib9zimih7jrn5zl7mbwvrxy022b"))
- (file-name (git-file-name name version))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- `(("rt" ,sbcl-rt)))
- (synopsis "Collection of portable utilities for Common Lisp")
- (description
- "Alexandria is a collection of portable utilities. It does not contain
-conceptual extensions to Common Lisp. It is conservative in scope, and
-portable between implementations.")
- (home-page "https://common-lisp.net/project/alexandria/")
- (license license:public-domain))))
-
-(define-public cl-alexandria
- (sbcl-package->cl-source-package sbcl-alexandria))
-
-(define-public ecl-alexandria
- (sbcl-package->ecl-package sbcl-alexandria))
-
-(define-public sbcl-net.didierverna.asdf-flv
- (package
- (name "sbcl-net.didierverna.asdf-flv")
- (version "2.1")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/didierverna/asdf-flv")
- (commit (string-append "version-" version))))
- (file-name (git-file-name "asdf-flv" version))
- (sha256
- (base32 "1fi2y4baxan103jbg4idjddzihy03kwnj2mzbwrknw4d4x7xlgwj"))))
- (build-system asdf-build-system/sbcl)
- (synopsis "Common Lisp ASDF extension to provide support for file-local variables")
- (description "ASDF-FLV provides support for file-local variables through
-ASDF. A file-local variable behaves like @code{*PACKAGE*} and
-@code{*READTABLE*} with respect to @code{LOAD} and @code{COMPILE-FILE}: a new
-dynamic binding is created before processing the file, so that any
-modification to the variable becomes essentially file-local.
-
-In order to make one or several variables file-local, use the macros
-@code{SET-FILE-LOCAL-VARIABLE(S)}.")
- (home-page "https://www.lrde.epita.fr/~didier/software/lisp/misc.php#asdf-flv")
- (license (license:non-copyleft
- "https://www.gnu.org/prep/maintain/html_node/License-Notices-for-Other-Files.html"
- "GNU All-Permissive License"))))
-
-(define-public cl-net.didierverna.asdf-flv
- (sbcl-package->cl-source-package sbcl-net.didierverna.asdf-flv))
-
-(define-public ecl-net.didierverna.asdf-flv
- (sbcl-package->ecl-package sbcl-net.didierverna.asdf-flv))
-
-(define-public sbcl-fiveam
- (package
- (name "sbcl-fiveam")
- (version "1.4.1")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/sionescu/fiveam.git")
- (commit (string-append "v" version))))
- (file-name (git-file-name "fiveam" version))
- (sha256
- (base32 "1q3d38pwafnwnw42clq0f8g5xw7pbzr287jl9jsqmb1vb0n1vrli"))))
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("net.didierverna.asdf-flv" ,sbcl-net.didierverna.asdf-flv)
- ("trivial-backtrace" ,sbcl-trivial-backtrace)))
- (build-system asdf-build-system/sbcl)
- (synopsis "Common Lisp testing framework")
- (description "FiveAM is a simple (as far as writing and running tests
-goes) regression testing framework. It has been designed with Common Lisp's
-interactive development model in mind.")
- (home-page "https://common-lisp.net/project/fiveam/")
- (license license:bsd-3)))
-
-(define-public cl-fiveam
- (sbcl-package->cl-source-package sbcl-fiveam))
-
-(define-public ecl-fiveam
- (sbcl-package->ecl-package sbcl-fiveam))
-
-(define-public sbcl-bordeaux-threads
- (let ((commit "5dce49fbc829f4d136a734f5ef4f5d599660984f")
- (revision "1"))
- (package
- (name "sbcl-bordeaux-threads")
- (version (git-version "0.8.6" revision commit))
- (source (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/sionescu/bordeaux-threads.git")
- (commit commit)))
- (sha256
- (base32 "1gkh9rz7zw57n3110ikcf4835950wr4hgp8l79id5ai6nd86x7wv"))
- (file-name
- (git-file-name "bordeaux-threads" version))))
- (inputs `(("alexandria" ,sbcl-alexandria)))
- (native-inputs `(("fiveam" ,sbcl-fiveam)))
- (build-system asdf-build-system/sbcl)
- (synopsis "Portable shared-state concurrency library for Common Lisp")
- (description "BORDEAUX-THREADS is a proposed standard for a minimal
-MP/Threading interface. It is similar to the CLIM-SYS threading and lock
-support.")
- (home-page "https://common-lisp.net/project/bordeaux-threads/")
- (license license:x11))))
-
-(define-public cl-bordeaux-threads
- (sbcl-package->cl-source-package sbcl-bordeaux-threads))
-
-(define-public ecl-bordeaux-threads
- (sbcl-package->ecl-package sbcl-bordeaux-threads))
-
-(define-public sbcl-trivial-gray-streams
- (let ((revision "1")
- (commit "0483ade330508b4b2edeabdb47d16ec9437ee1cb"))
- (package
- (name "sbcl-trivial-gray-streams")
- (version (string-append "0.0.0-" revision "." (string-take commit 7)))
- (source
- (origin
- (method git-fetch)
- (uri
- (git-reference
- (url "https://github.com/trivial-gray-streams/trivial-gray-streams.git")
- (commit commit)))
- (sha256
- (base32 "0m3rpf2x0zmdk3nf1qfa01j6a55vj7gkwhyw78qslcgbjlgh8p4d"))
- (file-name
- (string-append "trivial-gray-streams-" version "-checkout"))))
- (build-system asdf-build-system/sbcl)
- (synopsis "Compatibility layer for Gray streams implementations")
- (description "Gray streams is an interface proposed for inclusion with
-ANSI CL by David N. Gray. The proposal did not make it into ANSI CL, but most
-popular CL implementations implement it. This package provides an extremely
-thin compatibility layer for gray streams.")
- (home-page "http://www.cliki.net/trivial-gray-streams")
- (license license:x11))))
-
-(define-public cl-trivial-gray-streams
- (sbcl-package->cl-source-package sbcl-trivial-gray-streams))
-
-(define-public ecl-trivial-gray-streams
- (sbcl-package->ecl-package sbcl-trivial-gray-streams))
-
-(define-public sbcl-fiasco
- (let ((commit "d62f7558b21addc89f87e306f65d7f760632655f")
- (revision "1"))
- (package
- (name "sbcl-fiasco")
- (version (git-version "0.0.1" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/joaotavora/fiasco.git")
- (commit commit)))
- (file-name (git-file-name "fiasco" version))
- (sha256
- (base32
- "1zwxs3d6iswayavcmb49z2892xhym7n556d8dnmvalc32pm9bkjh"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
- (synopsis "Simple and powerful test framework for Common Lisp")
- (description "A Common Lisp test framework that treasures your failures,
-logical continuation of Stefil. It focuses on interactive debugging.")
- (home-page "https://github.com/joaotavora/fiasco")
- ;; LICENCE specifies this is public-domain unless the legislation
- ;; doesn't allow or recognize it. In that case it falls back to a
- ;; permissive licence.
- (license (list license:public-domain
- (license:x11-style "file://LICENCE"))))))
-
-(define-public cl-fiasco
- (sbcl-package->cl-source-package sbcl-fiasco))
-
-(define-public ecl-fiasco
- (sbcl-package->ecl-package sbcl-fiasco))
-
-(define-public sbcl-flexi-streams
- (package
- (name "sbcl-flexi-streams")
- (version "1.0.16")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/edicl/flexi-streams.git")
- (commit (string-append "v" version))))
- (file-name (git-file-name "flexi-streams" version))
- (sha256
- (base32 "0gvykjlmja060zqq6nn6aqxlshh6r6ijahmmgf20q0d839rwpgxc"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'make-git-checkout-writable
- (lambda _
- (for-each make-file-writable (find-files "."))
- #t)))))
- (inputs `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
- (synopsis "Implementation of virtual bivalent streams for Common Lisp")
- (description "Flexi-streams is an implementation of \"virtual\" bivalent
-streams that can be layered atop real binary or bivalent streams and that can
-be used to read and write character data in various single- or multi-octet
-encodings which can be changed on the fly. It also supplies in-memory binary
-streams which are similar to string streams.")
- (home-page "http://weitz.de/flexi-streams/")
- (license license:bsd-3)))
-
-(define-public cl-flexi-streams
- (sbcl-package->cl-source-package sbcl-flexi-streams))
-
-(define-public ecl-flexi-streams
- (sbcl-package->ecl-package sbcl-flexi-streams))
-
-(define-public sbcl-cl-ppcre
- (package
- (name "sbcl-cl-ppcre")
- (version "2.0.11")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/edicl/cl-ppcre.git")
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-ppcre" version))
- (sha256
- (base32 "0q3iany07vgqm144lw6pj0af2d3vsikpbkwcxr30fci3kzsq4f49"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs `(("flexi-streams" ,sbcl-flexi-streams)))
- (synopsis "Portable regular expression library for Common Lisp")
- (description "CL-PPCRE is a portable regular expression library for Common
-Lisp, which is compatible with perl. It is pretty fast, thread-safe, and
-compatible with ANSI-compliant Common Lisp implementations.")
- (home-page "http://weitz.de/cl-ppcre/")
- (license license:bsd-2)))
-
-(define-public cl-ppcre
- (sbcl-package->cl-source-package sbcl-cl-ppcre))
-
-(define-public ecl-cl-ppcre
- (sbcl-package->ecl-package sbcl-cl-ppcre))
-
-(define sbcl-cl-unicode-base
- (let ((revision "1")
- (commit "9fcd06fba1ddc9e66aed2f2d6c32dc9b764f03ea"))
- (package
- (name "sbcl-cl-unicode-base")
- (version (string-append "0.1.5-" revision "." (string-take commit 7)))
- (source (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/edicl/cl-unicode.git")
- (commit commit)))
- (file-name (string-append "cl-unicode-" version "-checkout"))
- (sha256
- (base32
- "1jicprb5b3bv57dy1kg03572gxkcaqdjhak00426s76g0plmx5ki"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-file "cl-unicode.asd"
- #:asd-system-name "cl-unicode/base"))
- (inputs
- `(("cl-ppcre" ,sbcl-cl-ppcre)))
- (home-page "http://weitz.de/cl-unicode/")
- (synopsis "Portable Unicode library for Common Lisp")
- (description "CL-UNICODE is a portable Unicode library Common Lisp, which
-is compatible with perl. It is pretty fast, thread-safe, and compatible with
-ANSI-compliant Common Lisp implementations.")
- (license license:bsd-2))))
-
-(define-public sbcl-cl-unicode
- (package
- (inherit sbcl-cl-unicode-base)
- (name "sbcl-cl-unicode")
- (inputs
- `(("cl-unicode/base" ,sbcl-cl-unicode-base)
- ,@(package-inputs sbcl-cl-unicode-base)))
- (native-inputs
- `(("flexi-streams" ,sbcl-flexi-streams)))
- (arguments '())))
-
-(define-public ecl-cl-unicode
- (sbcl-package->ecl-package sbcl-cl-unicode))
-
-(define-public cl-unicode
- (sbcl-package->cl-source-package sbcl-cl-unicode))
-
-(define-public sbcl-clx
- (package
- (name "sbcl-clx")
- (version "0.7.5")
- (source
- (origin
- (method git-fetch)
- (uri
- (git-reference
- (url "https://github.com/sharplispers/clx.git")
- (commit version)))
- (sha256
- (base32
- "1vi67z9hpj5rr4xcmfbfwzmlcc0ah7hzhrmfid6lqdkva238v2wf"))
- (file-name (string-append "clx-" version))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- `(("fiasco" ,sbcl-fiasco)))
- (home-page "http://www.cliki.net/portable-clx")
- (synopsis "X11 client library for Common Lisp")
- (description "CLX is an X11 client library for Common Lisp. The code was
-originally taken from a CMUCL distribution, was modified somewhat in order to
-make it compile and run under SBCL, then a selection of patches were added
-from other CLXes around the net.")
- (license license:x11)))
-
-(define-public cl-clx
- (sbcl-package->cl-source-package sbcl-clx))
-
-(define-public ecl-clx
- (sbcl-package->ecl-package sbcl-clx))
-
-(define-public sbcl-cl-ppcre-unicode
- (package (inherit sbcl-cl-ppcre)
- (name "sbcl-cl-ppcre-unicode")
- (arguments
- `(#:tests? #f ; tests fail with "Component :CL-PPCRE-TEST not found"
- #:asd-file "cl-ppcre-unicode.asd"))
- (inputs
- `(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
- ("sbcl-cl-unicode" ,sbcl-cl-unicode)))))
-
-(define-public stumpwm
- (package
- (name "stumpwm")
- (version "18.11")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/stumpwm/stumpwm.git")
- (commit version)))
- (file-name (git-file-name "stumpwm" version))
- (sha256
- (base32 "003g1fmh7446ws49866kzny4lrk1wf034dq5fa4m9mq1nzc7cwv7"))
- (patches
- ;; This patch is included in the post-18.11 git master tree
- ;; and can be removed when we move to the next release.
- (search-patches "stumpwm-fix-broken-read-one-line.patch"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs `(("fiasco" ,sbcl-fiasco)
- ("texinfo" ,texinfo)))
- (inputs `(("cl-ppcre" ,sbcl-cl-ppcre)
- ("clx" ,sbcl-clx)
- ("alexandria" ,sbcl-alexandria)))
- (outputs '("out" "lib"))
- (arguments
- '(#:asd-system-name "stumpwm"
- #:phases
- (modify-phases %standard-phases
- (add-after 'create-symlinks 'build-program
- (lambda* (#:key outputs #:allow-other-keys)
- (build-program
- (string-append (assoc-ref outputs "out") "/bin/stumpwm")
- outputs
- #:entry-program '((stumpwm:stumpwm) 0))))
- (add-after 'build-program 'create-desktop-file
- (lambda* (#:key outputs #:allow-other-keys)
- (let* ((out (assoc-ref outputs "out"))
- (xsessions (string-append out "/share/xsessions")))
- (mkdir-p xsessions)
- (call-with-output-file
- (string-append xsessions "/stumpwm.desktop")
- (lambda (file)
- (format file
- "[Desktop Entry]~@
- Name=stumpwm~@
- Comment=The Stump Window Manager~@
- Exec=~a/bin/stumpwm~@
- TryExec=~@*~a/bin/stumpwm~@
- Icon=~@
- Type=Application~%"
- out)))
- #t)))
- (add-after 'install 'install-manual
- (lambda* (#:key outputs #:allow-other-keys)
- ;; The proper way to the manual is bootstrapping a full autotools
- ;; build system and running ‘./configure && make stumpwm.info’ to
- ;; do some macro substitution. We can get away with much less.
- (let* ((out (assoc-ref outputs "out"))
- (info (string-append out "/share/info")))
- (invoke "makeinfo" "stumpwm.texi.in")
- (install-file "stumpwm.info" info)
- #t))))))
- (synopsis "Window manager written in Common Lisp")
- (description "Stumpwm is a window manager written entirely in Common Lisp.
-It attempts to be highly customizable while relying entirely on the keyboard
-for input. These design decisions reflect the growing popularity of
-productive, customizable lisp based systems.")
- (home-page "https://github.com/stumpwm/stumpwm")
- (license license:gpl2+)
- (properties `((cl-source-variant . ,(delay cl-stumpwm))))))
-
-(define-public sbcl-stumpwm
- (deprecated-package "sbcl-stumpwm" stumpwm))
-
-(define-public cl-stumpwm
- (package
- (inherit (sbcl-package->cl-source-package stumpwm))
- (name "cl-stumpwm")))
-
-;; The slynk that users expect to install includes all of slynk's contrib
-;; modules. Therefore, we build the base module and all contribs first; then
-;; we expose the union of these as `sbcl-slynk'. The following variable
-;; describes the base module.
-(define sbcl-slynk-boot0
- (let ((revision "2")
- (commit "cbf84c36c4eca8b032e3fd16177a7bc02df3ec4c"))
- (package
- (name "sbcl-slynk-boot0")
- (version (string-append "1.0.0-beta-" revision "." (string-take commit 7)))
- (source
- (origin
- (method git-fetch)
- (uri
- (git-reference
- (url "https://github.com/joaotavora/sly.git")
- (commit commit)))
- (sha256
- (base32 "13dyhsravn591p7g6is01mp2ynzjnnj7pwgi57r6xqmd4611y9vh"))
- (file-name (string-append "slynk-" version "-checkout"))
- (modules '((guix build utils)
- (ice-9 ftw)))
- (snippet
- '(begin
- ;; Move the contribs into the main source directory for easier
- ;; access
- (substitute* "slynk/slynk.asd"
- (("\\.\\./contrib")
- "contrib")
- (("\\(defsystem :slynk/util")
- "(defsystem :slynk/util :depends-on (:slynk)")
- ((":depends-on \\(:slynk :slynk/util\\)")
- ":depends-on (:slynk :slynk-util)"))
- (substitute* "contrib/slynk-trace-dialog.lisp"
- (("\\(slynk::reset-inspector\\)") ; Causes problems on load
- "nil"))
- (substitute* "contrib/slynk-profiler.lisp"
- (("slynk:to-line")
- "slynk-pprint-to-line"))
- (substitute* "contrib/slynk-fancy-inspector.lisp"
- (("slynk/util") "slynk-util")
- ((":compile-toplevel :load-toplevel") ""))
- (rename-file "contrib" "slynk/contrib")
- ;; Move slynk's contents into the base directory for easier
- ;; access
- (for-each (lambda (file)
- (unless (string-prefix? "." file)
- (rename-file (string-append "slynk/" file)
- (string-append "./" (basename file)))))
- (scandir "slynk"))
- #t))))
- (build-system asdf-build-system/sbcl)
- (arguments
- `(#:tests? #f ; No test suite
- #:asd-system-name "slynk"))
- (synopsis "Common Lisp IDE for Emacs")
- (description "SLY is a fork of SLIME, an IDE backend for Common Lisp.
-It also features a completely redesigned REPL based on Emacs's own
-full-featured comint.el, live code annotations, and a consistent interactive
-button interface. Everything can be copied to the REPL. One can create
-multiple inspectors with independent history.")
- (home-page "https://github.com/joaotavora/sly")
- (license license:public-domain)
- (properties `((cl-source-variant . ,(delay cl-slynk)))))))
-
-(define-public cl-slynk
- (package
- (inherit (sbcl-package->cl-source-package sbcl-slynk-boot0))
- (name "cl-slynk")))
-
-(define ecl-slynk-boot0
- (sbcl-package->ecl-package sbcl-slynk-boot0))
-
-(define sbcl-slynk-arglists
- (package
- (inherit sbcl-slynk-boot0)
- (name "sbcl-slynk-arglists")
- (inputs `(("slynk" ,sbcl-slynk-boot0)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-slynk-boot0)
- ((#:asd-file _ "") "slynk.asd")
- ((#:asd-system-name _ #f) "slynk/arglists")))))
-
-(define ecl-slynk-arglists
- (sbcl-package->ecl-package sbcl-slynk-arglists))
-
-(define sbcl-slynk-util
- (package
- (inherit sbcl-slynk-boot0)
- (name "sbcl-slynk-util")
- (inputs `(("slynk" ,sbcl-slynk-boot0)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-slynk-boot0)
- ((#:asd-file _ "") "slynk.asd")
- ((#:asd-system-name _ #f) "slynk/util")))))
-
-(define ecl-slynk-util
- (sbcl-package->ecl-package sbcl-slynk-util))
-
-(define sbcl-slynk-fancy-inspector
- (package
- (inherit sbcl-slynk-arglists)
- (name "sbcl-slynk-fancy-inspector")
- (inputs `(("slynk-util" ,sbcl-slynk-util)
- ,@(package-inputs sbcl-slynk-arglists)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
- ((#:asd-system-name _ #f) "slynk/fancy-inspector")))))
-
-(define ecl-slynk-fancy-inspector
- (sbcl-package->ecl-package sbcl-slynk-fancy-inspector))
-
-(define sbcl-slynk-package-fu
- (package
- (inherit sbcl-slynk-arglists)
- (name "sbcl-slynk-package-fu")
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
- ((#:asd-system-name _ #f) "slynk/package-fu")))))
-
-(define ecl-slynk-package-fu
- (sbcl-package->ecl-package sbcl-slynk-package-fu))
-
-(define sbcl-slynk-mrepl
- (package
- (inherit sbcl-slynk-fancy-inspector)
- (name "sbcl-slynk-mrepl")
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
- ((#:asd-system-name _ #f) "slynk/mrepl")))))
-
-(define ecl-slynk-mrepl
- (sbcl-package->ecl-package sbcl-slynk-mrepl))
-
-(define sbcl-slynk-trace-dialog
- (package
- (inherit sbcl-slynk-arglists)
- (name "sbcl-slynk-trace-dialog")
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
- ((#:asd-system-name _ #f) "slynk/trace-dialog")))))
-
-(define ecl-slynk-trace-dialog
- (sbcl-package->ecl-package sbcl-slynk-trace-dialog))
-
-(define sbcl-slynk-profiler
- (package
- (inherit sbcl-slynk-arglists)
- (name "sbcl-slynk-profiler")
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
- ((#:asd-system-name _ #f) "slynk/profiler")))))
-
-(define ecl-slynk-profiler
- (sbcl-package->ecl-package sbcl-slynk-profiler))
-
-(define sbcl-slynk-stickers
- (package
- (inherit sbcl-slynk-arglists)
- (name "sbcl-slynk-stickers")
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
- ((#:asd-system-name _ #f) "slynk/stickers")))))
-
-(define ecl-slynk-stickers
- (sbcl-package->ecl-package sbcl-slynk-stickers))
-
-(define sbcl-slynk-indentation
- (package
- (inherit sbcl-slynk-arglists)
- (name "sbcl-slynk-indentation")
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
- ((#:asd-system-name _ #f) "slynk/indentation")))))
-
-(define ecl-slynk-indentation
- (sbcl-package->ecl-package sbcl-slynk-indentation))
-
-(define sbcl-slynk-retro
- (package
- (inherit sbcl-slynk-arglists)
- (name "sbcl-slynk-retro")
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists)
- ((#:asd-system-name _ #f) "slynk/retro")))))
-
-(define ecl-slynk-retro
- (sbcl-package->ecl-package sbcl-slynk-retro))
-
-(define slynk-systems
- '("slynk"
- "slynk-util"
- "slynk-arglists"
- "slynk-fancy-inspector"
- "slynk-package-fu"
- "slynk-mrepl"
- "slynk-profiler"
- "slynk-trace-dialog"
- "slynk-stickers"
- "slynk-indentation"
- "slynk-retro"))
-
-(define-public sbcl-slynk
- (package
- (inherit sbcl-slynk-boot0)
- (name "sbcl-slynk")
- (inputs
- `(("slynk" ,sbcl-slynk-boot0)
- ("slynk-util" ,sbcl-slynk-util)
- ("slynk-arglists" ,sbcl-slynk-arglists)
- ("slynk-fancy-inspector" ,sbcl-slynk-fancy-inspector)
- ("slynk-package-fu" ,sbcl-slynk-package-fu)
- ("slynk-mrepl" ,sbcl-slynk-mrepl)
- ("slynk-profiler" ,sbcl-slynk-profiler)
- ("slynk-trace-dialog" ,sbcl-slynk-trace-dialog)
- ("slynk-stickers" ,sbcl-slynk-stickers)
- ("slynk-indentation" ,sbcl-slynk-indentation)
- ("slynk-retro" ,sbcl-slynk-retro)))
- (native-inputs `(("sbcl" ,sbcl)))
- (build-system trivial-build-system)
- (source #f)
- (outputs '("out" "image"))
- (arguments
- `(#:modules ((guix build union)
- (guix build utils)
- (guix build lisp-utils))
- #:builder
- (begin
- (use-modules (ice-9 match)
- (srfi srfi-1)
- (guix build union)
- (guix build lisp-utils))
-
- (union-build
- (assoc-ref %outputs "out")
- (filter-map
- (match-lambda
- ((name . path)
- (if (string-prefix? "slynk" name) path #f)))
- %build-inputs))
-
- (prepend-to-source-registry
- (string-append (assoc-ref %outputs "out") "//"))
-
- (parameterize ((%lisp-type "sbcl")
- (%lisp (string-append (assoc-ref %build-inputs "sbcl")
- "/bin/sbcl")))
- (build-image (string-append
- (assoc-ref %outputs "image")
- "/bin/slynk")
- %outputs
- #:dependencies ',slynk-systems))
- #t)))))
-
-(define-public ecl-slynk
- (package
- (inherit sbcl-slynk)
- (name "ecl-slynk")
- (inputs
- (map (match-lambda
- ((name pkg . _)
- (list name (sbcl-package->ecl-package pkg))))
- (package-inputs sbcl-slynk)))
- (native-inputs '())
- (outputs '("out"))
- (arguments
- '(#:modules ((guix build union))
- #:builder
- (begin
- (use-modules (ice-9 match)
- (guix build union))
- (match %build-inputs
- (((names . paths) ...)
- (union-build (assoc-ref %outputs "out")
- paths)
- #t)))))))
-
-(define-public stumpwm+slynk
- (package
- (inherit stumpwm)
- (name "stumpwm-with-slynk")
- (outputs '("out"))
- (inputs
- `(("stumpwm" ,stumpwm "lib")
- ("slynk" ,sbcl-slynk)))
- (arguments
- (substitute-keyword-arguments (package-arguments stumpwm)
- ((#:phases phases)
- `(modify-phases ,phases
- (replace 'build-program
- (lambda* (#:key inputs outputs #:allow-other-keys)
- (let* ((out (assoc-ref outputs "out"))
- (program (string-append out "/bin/stumpwm")))
- (build-program program outputs
- #:entry-program '((stumpwm:stumpwm) 0)
- #:dependencies '("stumpwm"
- ,@slynk-systems)
- #:dependency-prefixes
- (map (lambda (input) (assoc-ref inputs input))
- '("stumpwm" "slynk")))
- ;; Remove unneeded file.
- (delete-file (string-append out "/bin/stumpwm-exec.fasl"))
- #t)))
- (delete 'copy-source)
- (delete 'build)
- (delete 'check)
- (delete 'create-asd-file)
- (delete 'cleanup)
- (delete 'create-symlinks)))))))
-
-(define-public sbcl-stumpwm+slynk
- (deprecated-package "sbcl-stumpwm-with-slynk" stumpwm+slynk))
-
-(define-public sbcl-parse-js
- (let ((commit "fbadc6029bec7039602abfc06c73bb52970998f6")
- (revision "1"))
- (package
- (name "sbcl-parse-js")
- (version (string-append "0.0.0-" revision "." (string-take commit 9)))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "http://marijn.haverbeke.nl/git/parse-js")
- (commit commit)))
- (file-name (string-append name "-" commit "-checkout"))
- (sha256
- (base32
- "1wddrnr5kiya5s3gp4cdq6crbfy9fqcz7fr44p81502sj3bvdv39"))))
- (build-system asdf-build-system/sbcl)
- (home-page "http://marijnhaverbeke.nl/parse-js/")
- (synopsis "Parse JavaScript")
- (description "Parse-js is a Common Lisp package for parsing
-JavaScript (ECMAScript 3). It has basic support for ECMAScript 5.")
- (license license:zlib))))
-
-(define-public cl-parse-js
- (sbcl-package->cl-source-package sbcl-parse-js))
-
-(define-public sbcl-parse-number
- (package
- (name "sbcl-parse-number")
- (version "1.7")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/sharplispers/parse-number/")
- (commit (string-append "v" version))))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "0sk06ib1bhqv9y39vwnnw44vmbc4b0kvqm37xxmkxd4dwchq82d7"))))
- (build-system asdf-build-system/sbcl)
- (home-page "http://www.cliki.net/PARSE-NUMBER")
- (synopsis "Parse numbers")
- (description "@code{parse-number} is a library of functions for parsing
-strings into one of the standard Common Lisp number types without using the
-reader. @code{parse-number} accepts an arbitrary string and attempts to parse
-the string into one of the standard Common Lisp number types, if possible, or
-else @code{parse-number} signals an error of type @code{invalid-number}.")
- (license license:bsd-3)))
-
-(define-public cl-parse-number
- (sbcl-package->cl-source-package sbcl-parse-number))
-
-(define-public sbcl-iterate
- (package
- (name "sbcl-iterate")
- ;; The latest official release (1.4.3) fails to build so we have to take
- ;; the current darcs tarball from quicklisp.
- (version "20160825")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "http://beta.quicklisp.org/archive/iterate/"
- "2016-08-25/iterate-"
- version "-darcs.tgz"))
- (sha256
- (base32
- "0kvz16gnxnkdz0fy1x8y5yr28nfm7i2qpvix7mgwccdpjmsb4pgm"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- `(("rt" ,sbcl-rt)))
- (home-page "https://common-lisp.net/project/iterate/")
- (synopsis "Iteration construct for Common Lisp")
- (description "@code{iterate} is an iteration construct for Common Lisp.
-It is similar to the @code{CL:LOOP} macro, with these distinguishing marks:
-
-@itemize
-@item it is extensible,
-@item it helps editors like Emacs indent iterate forms by having a more
- lisp-like syntax, and
-@item it isn't part of the ANSI standard for Common Lisp.
-@end itemize\n")
- (license license:expat)))
-
-(define-public cl-iterate
- (sbcl-package->cl-source-package sbcl-iterate))
-
-(define-public ecl-iterate
- (sbcl-package->ecl-package sbcl-iterate))
-
-(define-public sbcl-cl-uglify-js
- ;; There have been many bug fixes since the 2010 release.
- (let ((commit "429c5e1d844e2f96b44db8fccc92d6e8e28afdd5")
- (revision "1"))
- (package
- (name "sbcl-cl-uglify-js")
- (version (string-append "0.1-" revision "." (string-take commit 9)))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/mishoo/cl-uglify-js.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "0k39y3c93jgxpr7gwz7w0d8yknn1fdnxrjhd03057lvk5w8js27a"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("sbcl-parse-js" ,sbcl-parse-js)
- ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
- ("sbcl-cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
- ("sbcl-parse-number" ,sbcl-parse-number)
- ("sbcl-iterate" ,sbcl-iterate)))
- (home-page "https://github.com/mishoo/cl-uglify-js")
- (synopsis "JavaScript compressor library for Common Lisp")
- (description "This is a Common Lisp version of UglifyJS, a JavaScript
-compressor. It works on data produced by @code{parse-js} to generate a
-@dfn{minified} version of the code. Currently it can:
-
-@itemize
-@item reduce variable names (usually to single letters)
-@item join consecutive @code{var} statements
-@item resolve simple binary expressions
-@item group most consecutive statements using the @code{sequence} operator (comma)
-@item remove unnecessary blocks
-@item convert @code{IF} expressions in various ways that result in smaller code
-@item remove some unreachable code
-@end itemize\n")
- (license license:zlib))))
-
-(define-public cl-uglify-js
- (sbcl-package->cl-source-package sbcl-cl-uglify-js))
-
-(define-public uglify-js
- (package
- (inherit sbcl-cl-uglify-js)
- (name "uglify-js")
- (build-system trivial-build-system)
- (arguments
- `(#:modules ((guix build utils))
- #:builder
- (let* ((bin (string-append (assoc-ref %outputs "out") "/bin/"))
- (script (string-append bin "uglify-js")))
- (use-modules (guix build utils))
- (mkdir-p bin)
- (with-output-to-file script
- (lambda _
- (format #t "#!~a/bin/sbcl --script
- (require :asdf)
- (push (truename \"~a/lib/sbcl\") asdf:*central-registry*)"
- (assoc-ref %build-inputs "sbcl")
- (assoc-ref %build-inputs "sbcl-cl-uglify-js"))
- ;; FIXME: cannot use progn here because otherwise it fails to
- ;; find cl-uglify-js.
- (for-each
- write
- '(;; Quiet, please!
- (let ((*standard-output* (make-broadcast-stream))
- (*error-output* (make-broadcast-stream)))
- (asdf:load-system :cl-uglify-js))
- (let ((file (cadr *posix-argv*)))
- (if file
- (format t "~a"
- (cl-uglify-js:ast-gen-code
- (cl-uglify-js:ast-mangle
- (cl-uglify-js:ast-squeeze
- (with-open-file (in file)
- (parse-js:parse-js in))))
- :beautify nil))
- (progn
- (format *error-output*
- "Please provide a JavaScript file.~%")
- (sb-ext:exit :code 1))))))))
- (chmod script #o755)
- #t)))
- (inputs
- `(("sbcl" ,sbcl)
- ("sbcl-cl-uglify-js" ,sbcl-cl-uglify-js)))
- (synopsis "JavaScript compressor")))
-
(define-public confusion-mdl
(let* ((commit "12a055581fc262225272df43287dae48281900f5"))
(package
@@ -1665,3765 +736,6 @@ enough to play the original mainframe Zork all the way through.")
(home-page "http://www.russotto.net/git/mrussotto/confusion/src/master/src/README")
(license license:gpl3+))))
-(define-public sbcl-cl-strings
- (let ((revision "1")
- (commit "c5c5cbafbf3e6181d03c354d66e41a4f063f00ae"))
- (package
- (name "sbcl-cl-strings")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/diogoalexandrefranco/cl-strings")
- (commit commit)))
- (sha256
- (base32
- "00754mfaqallj480lwd346nkfb6ra8pa8xcxcylf4baqn604zlmv"))
- (file-name (string-append "cl-strings-" version "-checkout"))))
- (build-system asdf-build-system/sbcl)
- (synopsis "Portable, dependency-free set of utilities to manipulate strings in Common Lisp")
- (description
- "@command{cl-strings} is a small, portable, dependency-free set of
-utilities that make it even easier to manipulate text in Common Lisp. It has
-100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.")
- (home-page "https://github.com/diogoalexandrefranco/cl-strings")
- (license license:expat))))
-
-(define-public cl-strings
- (sbcl-package->cl-source-package sbcl-cl-strings))
-
-(define-public ecl-cl-strings
- (sbcl-package->ecl-package sbcl-cl-strings))
-
-(define-public sbcl-trivial-features
- (package
- (name "sbcl-trivial-features")
- (version "0.8")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/trivial-features/trivial-features.git")
- (commit (string-append "v" version))))
- (file-name (git-file-name "trivial-features" version))
- (sha256
- (base32 "0ccv7dqyrk55xga78i5vzlic7mdwp28in3g1a8fqhlk6626scsq9"))))
- (build-system asdf-build-system/sbcl)
- (arguments '(#:tests? #f))
- (home-page "http://cliki.net/trivial-features")
- (synopsis "Ensures consistency of @code{*FEATURES*} in Common Lisp")
- (description "Trivial-features ensures that @code{*FEATURES*} is
-consistent across multiple Common Lisp implementations.")
- (license license:expat)))
-
-(define-public cl-trivial-features
- (sbcl-package->cl-source-package sbcl-trivial-features))
-
-(define-public ecl-trivial-features
- (sbcl-package->ecl-package sbcl-trivial-features))
-
-(define-public sbcl-hu.dwim.asdf
- (package
- (name "sbcl-hu.dwim.asdf")
- (version "20190521")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "http://beta.quicklisp.org/archive/hu.dwim.asdf/"
- "2019-05-21/hu.dwim.asdf-" version "-darcs.tgz"))
- (sha256
- (base32
- "0rsbv71vyszy8w35yjwb5h6zcmknjq223hkzir79y72qdsc6sabn"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://hub.darcs.net/hu.dwim/hu.dwim.asdf")
- (synopsis "Extensions to ASDF")
- (description "Various ASDF extensions such as attached test and
-documentation system, explicit development support, etc.")
- (license license:public-domain)))
-
-(define-public cl-hu.dwim.asdf
- (sbcl-package->cl-source-package sbcl-hu.dwim.asdf))
-
-(define-public ecl-hu.dwim.asdf
- (sbcl-package->ecl-package sbcl-hu.dwim.asdf))
-
-(define-public sbcl-hu.dwim.stefil
- (let ((commit "ab6d1aa8995878a1b66d745dfd0ba021090bbcf9"))
- (package
- (name "sbcl-hu.dwim.stefil")
- (version (git-version "0.0.0" "1" commit))
- (source
- (origin
- (method git-fetch)
- (uri
- (git-reference
- (url "https://gitlab.common-lisp.net/xcvb/hu.dwim.stefil.git")
- (commit commit)))
- (sha256
- (base32 "1d8yccw65zj3zh46cbi3x6nmn1dwdb76s9d0av035077mvyirqqp"))
- (file-name (git-file-name "hu.dwim.stefil" version))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- `(("asdf:cl-hu.dwim.asdf" ,sbcl-hu.dwim.asdf)))
- (inputs
- `(("sbcl-alexandria" ,sbcl-alexandria)))
- (home-page "https://hub.darcs.net/hu.dwim/hu.dwim.stefil")
- (synopsis "Simple test framework")
- (description "Stefil is a simple test framework for Common Lisp,
-with a focus on interactive development.")
- (license license:public-domain))))
-
-(define-public cl-hu.dwim.stefil
- (sbcl-package->cl-source-package sbcl-hu.dwim.stefil))
-
-(define-public ecl-hu.dwim.stefil
- (sbcl-package->ecl-package sbcl-hu.dwim.stefil))
-
-(define-public sbcl-babel
- (package
- (name "sbcl-babel")
- (version "0.5.0")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/cl-babel/babel.git")
- (commit (string-append "v" version))))
- (file-name (git-file-name "babel" version))
- (sha256
- (base32 "139a8rn2gnhj082n8jg01gc8fyr63hkj57hgrnmb3d1r327yc77f"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- `(("tests:cl-hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
- (inputs
- `(("sbcl-alexandria" ,sbcl-alexandria)
- ("sbcl-trivial-features" ,sbcl-trivial-features)))
- (home-page "https://common-lisp.net/project/babel/")
- (synopsis "Charset encoding and decoding library")
- (description "Babel is a charset encoding and decoding library, not unlike
-GNU libiconv, but completely written in Common Lisp.")
- (license license:expat)))
-
-(define-public cl-babel
- (sbcl-package->cl-source-package sbcl-babel))
-
-(define-public ecl-babel
- (sbcl-package->ecl-package sbcl-babel))
-
-(define-public sbcl-cl-yacc
- (package
- (name "sbcl-cl-yacc")
- (version "0.3")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/jech/cl-yacc")
- (commit (string-append "cl-yacc-" version))))
- (sha256
- (base32
- "16946pzf8vvadnyfayvj8rbh4zjzw90h0azz2qk1mxrvhh5wklib"))
- (file-name (string-append "cl-yacc-" version "-checkout"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- `(#:asd-file "yacc.asd"
- #:asd-system-name "yacc"))
- (synopsis "LALR(1) parser generator for Common Lisp, similar in spirit to Yacc")
- (description
- "CL-Yacc is a LALR(1) parser generator for Common Lisp, similar in spirit
-to AT&T Yacc, Berkeley Yacc, GNU Bison, Zebu, lalr.cl or lalr.scm.
-
-CL-Yacc uses the algorithm due to Aho and Ullman, which is the one also used
-by AT&T Yacc, Berkeley Yacc and Zebu. It does not use the faster algorithm due
-to DeRemer and Pennello, which is used by Bison and lalr.scm (not lalr.cl).")
- (home-page "https://www.irif.fr/~jch//software/cl-yacc/")
- (license license:expat)))
-
-(define-public cl-yacc
- (sbcl-package->cl-source-package sbcl-cl-yacc))
-
-(define-public ecl-cl-yacc
- (sbcl-package->ecl-package sbcl-cl-yacc))
-
-(define-public sbcl-jpl-util
- (let ((commit "0311ed374e19a49d43318064d729fe3abd9a3b62"))
- (package
- (name "sbcl-jpl-util")
- (version "20151005")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- ;; Quicklisp uses this fork.
- (url "https://github.com/hawkir/cl-jpl-util")
- (commit commit)))
- (file-name
- (git-file-name "jpl-util" version))
- (sha256
- (base32
- "0nc0rk9n8grkg3045xsw34whmcmddn2sfrxki4268g7kpgz0d2yz"))))
- (build-system asdf-build-system/sbcl)
- (synopsis "Collection of Common Lisp utility functions and macros")
- (description
- "@command{cl-jpl-util} is a collection of Common Lisp utility functions
-and macros, primarily for software projects written in CL by the author.")
- (home-page "https://www.thoughtcrime.us/software/cl-jpl-util/")
- (license license:isc))))
-
-(define-public cl-jpl-util
- (sbcl-package->cl-source-package sbcl-jpl-util))
-
-(define-public ecl-jpl-util
- (sbcl-package->ecl-package sbcl-jpl-util))
-
-(define-public sbcl-jpl-queues
- (package
- (name "sbcl-jpl-queues")
- (version "0.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "http://www.thoughtcrime.us/software/jpl-queues/jpl-queues-"
- version
- ".tar.gz"))
- (sha256
- (base32
- "1wvvv7j117h9a42qaj1g4fh4mji28xqs7s60rn6d11gk9jl76h96"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("jpl-util" ,sbcl-jpl-util)
- ("bordeaux-threads" ,sbcl-bordeaux-threads)))
- (arguments
- ;; Tests seem to be broken.
- `(#:tests? #f))
- (synopsis "Common Lisp library implementing a few different kinds of queues")
- (description
- "A Common Lisp library implementing a few different kinds of queues:
-
-@itemize
-@item Bounded and unbounded FIFO queues.
-@item Lossy bounded FIFO queues that drop elements when full.
-@item Unbounded random-order queues that use less memory than unbounded FIFO queues.
-@end itemize
-
-Additionally, a synchronization wrapper is provided to make any queue
-conforming to the @command{jpl-queues} API thread-safe for lightweight
-multithreading applications. (See Calispel for a more sophisticated CL
-multithreaded message-passing library with timeouts and alternation among
-several blockable channels.)")
- (home-page "https://www.thoughtcrime.us/software/jpl-queues/")
- (license license:isc)))
-
-(define-public cl-jpl-queues
- (sbcl-package->cl-source-package sbcl-jpl-queues))
-
-(define-public ecl-jpl-queues
- (sbcl-package->ecl-package sbcl-jpl-queues))
-
-(define-public sbcl-eos
- (let ((commit "b0faca83781ead9a588661e37bd47f90362ccd94"))
- (package
- (name "sbcl-eos")
- (version (git-version "0.0.0" "1" commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/adlai/Eos")
- (commit commit)))
- (sha256
- (base32
- "1bq8cfg087iyxmxi1mwgx5cfgy3b8ydrf81xljcis8qbgb2vszph"))
- (file-name (git-file-name "eos" version))))
- (build-system asdf-build-system/sbcl)
- (synopsis "Unit Testing for Common Lisp")
- (description
- "Eos was a unit testing library for Common Lisp.
-It began as a fork of FiveAM; however, FiveAM development has continued, while
-that of Eos has not. Thus, Eos is now deprecated in favor of FiveAM.")
- (home-page "https://github.com/adlai/Eos")
- (license license:expat))))
-
-(define-public cl-eos
- (sbcl-package->cl-source-package sbcl-eos))
-
-(define-public ecl-eos
- (sbcl-package->ecl-package sbcl-eos))
-
-(define-public sbcl-esrap
- (let ((commit "133be8b05c2aae48696fe5b739eea2fa573fa48d"))
- (package
- (name "sbcl-esrap")
- (version (git-version "0.0.0" "1" commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/nikodemus/esrap")
- (commit commit)))
- (sha256
- (base32
- "02d5clihsdryhf7pix8c5di2571fdsffh75d40fkzhws90r5mksl"))
- (file-name (git-file-name "esrap" version))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- `(("eos" ,sbcl-eos))) ;For testing only.
- (inputs
- `(("alexandria" ,sbcl-alexandria)))
- (synopsis "Common Lisp packrat parser")
- (description
- "A packrat parser for Common Lisp.
-In addition to regular Packrat / Parsing Grammar / TDPL features ESRAP supports:
-
-@itemize
-@item dynamic redefinition of nonterminals
-@item inline grammars
-@item semantic predicates
-@item introspective facilities (describing grammars, tracing, setting breaks)
-@end itemize\n")
- (home-page "https://nikodemus.github.io/esrap/")
- (license license:expat))))
-
-(define-public cl-esrap
- (sbcl-package->cl-source-package sbcl-esrap))
-
-(define-public ecl-esrap
- (sbcl-package->ecl-package sbcl-esrap))
-
-(define-public sbcl-split-sequence
- (package
- (name "sbcl-split-sequence")
- (version "1.4.1")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/sharplispers/split-sequence")
- (commit (string-append "v" version))))
- (sha256
- (base32
- "0c3zp6b7fmmp93sfhq112ind4zkld49ycw68z409xpnz3gc0wpf0"))
- (file-name (git-file-name "split-sequence" version))))
- (build-system asdf-build-system/sbcl)
- (arguments
- ;; TODO: Tests seem to be broken.
- ;; https://github.com/sharplispers/split-sequence/issues/8
- `(#:tests? #f))
- (synopsis "Member of the Common Lisp Utilities family of programs")
- (description
- "Splits sequence into a list of subsequences delimited by objects
-satisfying the test.")
- (home-page "https://cliki.net/split-sequence")
- (license license:expat)))
-
-(define-public cl-split-sequence
- (sbcl-package->cl-source-package sbcl-split-sequence))
-
-(define-public ecl-split-sequence
- (sbcl-package->ecl-package sbcl-split-sequence))
-
-(define-public sbcl-html-encode
- (package
- (name "sbcl-html-encode")
- (version "1.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "http://beta.quicklisp.org/archive/html-encode/2010-10-06/html-encode-"
- version ".tgz"))
- (sha256
- (base32
- "06mf8wn95yf5swhmzk4vp0xr4ylfl33dgfknkabbkd8n6jns8gcf"))
- (file-name (string-append "colorize" version "-checkout"))))
- (build-system asdf-build-system/sbcl)
- (synopsis "Common Lisp library for encoding text in various web-savvy encodings")
- (description
- "A library for encoding text in various web-savvy encodings.")
- (home-page "http://quickdocs.org/html-encode/")
- (license license:expat)))
-
-(define-public cl-html-encode
- (sbcl-package->cl-source-package sbcl-html-encode))
-
-(define-public ecl-html-encode
- (sbcl-package->ecl-package sbcl-html-encode))
-
-(define-public sbcl-colorize
- (let ((commit "ea676b584e0899cec82f21a9e6871172fe3c0eb5"))
- (package
- (name "sbcl-colorize")
- (version (git-version "0.0.0" "1" commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/kingcons/colorize")
- (commit commit)))
- (sha256
- (base32
- "1pdg4kiaczmr3ivffhirp7m3lbr1q27rn7dhaay0vwghmi31zcw9"))
- (file-name (git-file-name "colorize" version))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("split-sequence" ,sbcl-split-sequence)
- ("html-encode" ,sbcl-html-encode)))
- (synopsis "Common Lisp for syntax highlighting")
- (description
- "@command{colorize} is a Lisp library for syntax highlighting
-supporting the following languages: Common Lisp, Emacs Lisp, Scheme, Clojure,
-C, C++, Java, Python, Erlang, Haskell, Objective-C, Diff, Webkit.")
- (home-page "https://github.com/kingcons/colorize")
- ;; TODO: Missing license?
- (license license:expat))))
-
-(define-public cl-colorize
- (sbcl-package->cl-source-package sbcl-colorize))
-
-(define-public ecl-colorize
- (sbcl-package->ecl-package sbcl-colorize))
-
-(define-public sbcl-3bmd
- (let ((commit "192ea13435b605a96ef607df51317056914cabbd"))
- (package
- (name "sbcl-3bmd")
- (version (git-version "0.0.0" "1" commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/3b/3bmd")
- (commit commit)))
- (sha256
- (base32
- "1rgv3gi7wf963ikmmpk132wgn0icddf226gq3bmcnk1fr3v9gf2f"))
- (file-name (git-file-name "3bmd" version))))
- (build-system asdf-build-system/sbcl)
- (arguments
- ;; FIXME: We need to specify the name because the build-system thinks
- ;; "3" is a version marker.
- `(#:asd-system-name "3bmd"))
- (inputs
- `(("esrap" ,sbcl-esrap)
- ("split-sequence" ,sbcl-split-sequence)))
- (synopsis "Markdown processor in Command Lisp using esrap parser")
- (description
- "Common Lisp Markdown -> HTML converter, using @command{esrap} for
-parsing, and grammar based on @command{peg-markdown}.")
- (home-page "https://github.com/3b/3bmd")
- (license license:expat))))
-
-(define-public cl-3bmd
- (sbcl-package->cl-source-package sbcl-3bmd))
-
-(define-public ecl-3bmd
- (sbcl-package->ecl-package sbcl-3bmd))
-
-(define-public sbcl-3bmd-ext-code-blocks
- (let ((commit "192ea13435b605a96ef607df51317056914cabbd"))
- (package
- (inherit sbcl-3bmd)
- (name "sbcl-3bmd-ext-code-blocks")
- (arguments
- `(#:asd-system-name "3bmd-ext-code-blocks"
- #:asd-file "3bmd-ext-code-blocks.asd"))
- (inputs
- `(("3bmd" ,sbcl-3bmd)
- ("colorize" ,sbcl-colorize)))
- (synopsis "3bmd extension which adds support for GitHub-style fenced
-code blocks")
- (description
- "3bmd extension which adds support for GitHub-style fenced code blocks,
-with @command{colorize} support."))))
-
-(define-public cl-3bmd-ext-code-blocks
- (sbcl-package->cl-source-package sbcl-3bmd-ext-code-blocks))
-
-(define-public ecl-3bmd-ext-code-blocks
- (sbcl-package->ecl-package sbcl-3bmd-ext-code-blocks))
-
-(define-public sbcl-cl-fad
- (package
- (name "sbcl-cl-fad")
- (version "0.7.5")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/edicl/cl-fad/")
- (commit (string-append "v" version))))
- (sha256
- (base32
- "1l1qmk9z57q84bz5r04sxsksggsnd7dgkxlybzh9imz6ma7sm52m"))
- (file-name (string-append "cl-fad" version "-checkout"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
- (synopsis "Portable pathname library for Common Lisp")
- (description
- "CL-FAD (for \"Files and Directories\") is a thin layer atop Common
-Lisp's standard pathname functions. It is intended to provide some
-unification between current CL implementations on Windows, OS X, Linux, and
-Unix. Most of the code was written by Peter Seibel for his book Practical
-Common Lisp.")
- (home-page "https://edicl.github.io/cl-fad/")
- (license license:bsd-2)))
-
-(define-public cl-fad
- (sbcl-package->cl-source-package sbcl-cl-fad))
-
-(define-public ecl-cl-fad
- (sbcl-package->ecl-package sbcl-cl-fad))
-
-(define-public sbcl-rt
- (package
- (name "sbcl-rt")
- (version "1990.12.19")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "http://beta.quicklisp.org/archive/rt/2010-10-06/rt-"
- "20101006-git" ".tgz"))
- (sha256
- (base32
- "1jncar0xwkqk8yrc2dln389ivvgzs7ijdhhs3zpfyi5d21f0qa1v"))))
- (build-system asdf-build-system/sbcl)
- (synopsis "MIT Regression Tester")
- (description
- "RT provides a framework for writing regression test suites.")
- (home-page "https://github.com/sharplispers/nibbles")
- (license license:unlicense)))
-
-(define-public cl-rt
- (sbcl-package->cl-source-package sbcl-rt))
-
-(define-public ecl-rt
- (sbcl-package->ecl-package sbcl-rt))
-
-(define-public sbcl-nibbles
- (package
- (name "sbcl-nibbles")
- (version "0.14")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/sharplispers/nibbles/")
- (commit (string-append "v" version))))
- (sha256
- (base32
- "1v7qfgpvdr6nz7v63dj69d26dis0kff3rd8xamr1llfdvza2pm8f"))
- (file-name (git-file-name "nibbles" version))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- ;; Tests only.
- `(("rt" ,sbcl-rt)))
- (synopsis "Common Lisp library for accessing octet-addressed blocks of data")
- (description
- "When dealing with network protocols and file formats, it's common to
-have to read or write 16-, 32-, or 64-bit datatypes in signed or unsigned
-flavors. Common Lisp sort of supports this by specifying :element-type for
-streams, but that facility is underspecified and there's nothing similar for
-read/write from octet vectors. What most people wind up doing is rolling their
-own small facility for their particular needs and calling it a day.
-
-This library attempts to be comprehensive and centralize such
-facilities. Functions to read 16-, 32-, and 64-bit quantities from octet
-vectors in signed or unsigned flavors are provided; these functions are also
-SETFable. Since it's sometimes desirable to read/write directly from streams,
-functions for doing so are also provided. On some implementations,
-reading/writing IEEE singles/doubles (i.e. single-float and double-float) will
-also be supported.")
- (home-page "https://github.com/sharplispers/nibbles")
- (license license:bsd-3)))
-
-(define-public cl-nibbles
- (sbcl-package->cl-source-package sbcl-nibbles))
-
-(define-public ecl-nibbles
- (sbcl-package->ecl-package sbcl-nibbles))
-
-(define-public sbcl-ironclad
- (package
- (name "sbcl-ironclad")
- (version "0.46")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/sharplispers/ironclad/")
- (commit (string-append "v" version))))
- (sha256
- (base32
- "1s391awi2lsl7m1dbjirgpkm4p9p8wd076pakgvsvpn1rrznisnd"))
- (file-name (git-file-name name version))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- ;; Tests only.
- `(("rt" ,sbcl-rt)))
- (inputs
- `(("bordeaux-threads" ,sbcl-bordeaux-threads)
- ("flexi-streams" ,sbcl-flexi-streams)
- ("nibbles" ,sbcl-nibbles)))
- (synopsis "Cryptographic toolkit written in Common Lisp")
- (description
- "Ironclad is a cryptography library written entirely in Common Lisp.
-It includes support for several popular ciphers, digests, MACs and public key
-cryptography algorithms. For several implementations that support Gray
-streams, support is included for convenient stream wrappers.")
- (home-page "https://github.com/sharplispers/ironclad")
- (license license:bsd-3)))
-
-(define-public cl-ironclad
- (sbcl-package->cl-source-package sbcl-ironclad))
-
-(define-public ecl-ironclad
- (sbcl-package->ecl-package sbcl-ironclad))
-
-(define-public sbcl-named-readtables
- (let ((commit "4dfb89fa1af6b305b6492b8af042f5190c11e9fc")
- (revision "1"))
- (package
- (name "sbcl-named-readtables")
- (version (string-append "0.9-" revision "." (string-take commit 7)))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/melisgl/named-readtables.git")
- (commit commit)))
- (sha256
- (base32 "083kgh5462iqbb4px6kq8s7sggvpvkm36hx4qi9rnaw53b6ilqkk"))
- (file-name (git-file-name "named-readtables" version))))
- (build-system asdf-build-system/sbcl)
- (arguments
- ;; Tests seem to be broken.
- `(#:tests? #f))
- (home-page "https://github.com/melisgl/named-readtables/")
- (synopsis "Library that creates a namespace for named readtables")
- (description "Named readtables is a library that creates a namespace for
-named readtables, which is akin to package namespacing in Common Lisp.")
- (license license:bsd-3))))
-
-(define-public cl-named-readtables
- (sbcl-package->cl-source-package sbcl-named-readtables))
-
-(define-public ecl-named-readtables
- (sbcl-package->ecl-package sbcl-named-readtables))
-
-(define-public sbcl-pythonic-string-reader
- (let ((commit "47a70ba1e32362e03dad6ef8e6f36180b560f86a"))
- (package
- (name "sbcl-pythonic-string-reader")
- (version (git-version "0.0.0" "1" commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/smithzvk/pythonic-string-reader/")
- (commit commit)))
- (sha256
- (base32 "1b5iryqw8xsh36swckmz8rrngmc39k92si33fgy5pml3n9l5rq3j"))
- (file-name (git-file-name "pythonic-string-reader" version))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("named-readtables" ,sbcl-named-readtables)))
- (home-page "https://github.com/smithzvk/pythonic-string-reader")
- (synopsis "Read table modification inspired by Python's three quote strings")
- (description "This piece of code sets up some reader macros that make it
-simpler to input string literals which contain backslashes and double quotes
-This is very useful for writing complicated docstrings and, as it turns out,
-writing code that contains string literals that contain code themselves.")
- (license license:bsd-3))))
-
-(define-public cl-pythonic-string-reader
- (sbcl-package->cl-source-package sbcl-pythonic-string-reader))
-
-(define-public ecl-pythonic-string-reader
- (sbcl-package->ecl-package sbcl-pythonic-string-reader))
-
-;; SLIME does not have a ASDF system definition to build all of Swank. As a
-;; result, the asdf-build-system/sbcl will produce an almost empty package.
-;; Some work was done to fix this at
-;; https://github.com/sionescu/slime/tree/swank-asdf but it was never merged
-;; and is now lagging behind. Building SBCL fasls might not be worth the
-;; hassle, so let's just ship the source then.
-(define-public cl-slime-swank
- (package
- (name "cl-slime-swank")
- (version "2.24")
- (source
- (origin
- (file-name (string-append name "-" version ".tar.gz"))
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/slime/slime/")
- (commit (string-append "v" version))))
- (sha256
- (base32
- "0js24x42m7b5iymb4rxz501dff19vav5pywnzv50b673rbkaaqvh"))))
- (build-system asdf-build-system/source)
- (home-page "https://github.com/slime/slime")
- (synopsis "Common Lisp Swank server")
- (description
- "This is only useful if you want to start a Swank server in a Lisp
-processes that doesn't run under Emacs. Lisp processes created by
-@command{M-x slime} automatically start the server.")
- (license (list license:gpl2+ license:public-domain))))
-
-(define-public sbcl-slime-swank
- (deprecated-package "sbcl-slime-swank" cl-slime-swank))
-
-(define-public sbcl-mgl-pax
- (let ((commit "818448418d6b9de74620f606f5b23033c6082769"))
- (package
- (name "sbcl-mgl-pax")
- (version (git-version "0.0.0" "1" commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/melisgl/mgl-pax")
- (commit commit)))
- (sha256
- (base32
- "1p97zfkh130bdxqqxwaw2j9psv58751wakx7czbfpq410lg7dd7i"))
- (file-name (git-file-name "mgl-pax" version))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("3bmd" ,sbcl-3bmd)
- ("3bmd-ext-code-blocks" ,sbcl-3bmd-ext-code-blocks)
- ("babel" ,sbcl-babel)
- ("cl-fad" ,sbcl-cl-fad)
- ("ironclad" ,sbcl-ironclad)
- ("named-readtables" ,sbcl-named-readtables)
- ("pythonic-string-reader" ,sbcl-pythonic-string-reader)
- ("swank" ,cl-slime-swank)))
- (synopsis "Exploratory programming environment and documentation generator")
- (description
- "PAX provides an extremely poor man's Explorable Programming
-environment. Narrative primarily lives in so called sections that mix markdown
-docstrings with references to functions, variables, etc, all of which should
-probably have their own docstrings.
-
-The primary focus is on making code easily explorable by using SLIME's
-@command{M-.} (@command{slime-edit-definition}). See how to enable some
-fanciness in Emacs Integration. Generating documentation from sections and all
-the referenced items in Markdown or HTML format is also implemented.
-
-With the simplistic tools provided, one may accomplish similar effects as with
-Literate Programming, but documentation is generated from code, not vice versa
-and there is no support for chunking yet. Code is first, code must look
-pretty, documentation is code.")
- (home-page "http://quotenil.com/")
- (license license:expat))))
-
-(define-public cl-mgl-pax
- (sbcl-package->cl-source-package sbcl-mgl-pax))
-
-(define-public ecl-mgl-pax
- (sbcl-package->ecl-package sbcl-mgl-pax))
-
-(define-public sbcl-lisp-unit
- (let ((commit "89653a232626b67400bf9a941f9b367da38d3815"))
- (package
- (name "sbcl-lisp-unit")
- (version (git-version "0.0.0" "1" commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/OdonataResearchLLC/lisp-unit")
- (commit commit)))
- (sha256
- (base32
- "0p6gdmgr7p383nvd66c9y9fp2bjk4jx1lpa5p09g43hr9y9pp9ry"))
- (file-name (git-file-name "lisp-unit" version))))
- (build-system asdf-build-system/sbcl)
- (synopsis "Common Lisp Test framework inspired by JUnit to be simple of use")
- (description
- "@command{lisp-unit} is a Common Lisp library that supports unit
-testing. It is an extension of the library written by Chris Riesbeck.")
- (home-page "https://github.com/OdonataResearchLLC/lisp-unit")
- (license license:expat))))
-
-(define-public cl-lisp-unit
- (sbcl-package->cl-source-package sbcl-lisp-unit))
-
-(define-public ecl-lisp-unit
- (sbcl-package->ecl-package sbcl-lisp-unit))
-
-(define-public sbcl-anaphora
- (package
- (name "sbcl-anaphora")
- (version "0.9.6")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/tokenrove/anaphora")
- (commit version)))
- (sha256
- (base32
- "19wfrk3asimznkli0x2rfy637hwpdgqyvwj3vhq9x7vjvyf5vv6x"))
- (file-name (git-file-name "anaphora" version))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- `(("rt" ,sbcl-rt)))
- (synopsis "The anaphoric macro collection from Hell")
- (description
- "Anaphora is the anaphoric macro collection from Hell: it includes many
-new fiends in addition to old friends like @command{aif} and
-@command{awhen}.")
- (home-page "https://github.com/tokenrove/anaphora")
- (license license:public-domain)))
-
-(define-public cl-anaphora
- (sbcl-package->cl-source-package sbcl-anaphora))
-
-(define-public ecl-anaphora
- (sbcl-package->ecl-package sbcl-anaphora))
-
-(define-public sbcl-lift
- (let ((commit "7d49a66c62759535624037826891152223d4206c"))
- (package
- (name "sbcl-lift")
- (version (git-version "1.7.1" "1" commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/gwkkwg/lift")
- (commit commit)))
- (sha256
- (base32
- "127v5avpz1i4m0lkaxqrq8hrl69rdazqaxf6s8awf0nd7wj2g4dp"))
- (file-name (git-file-name "lift" version))
- (modules '((guix build utils)))
- (snippet
- ;; Don't keep the bundled website
- `(begin
- (delete-file-recursively "website")
- #t))))
- (build-system asdf-build-system/sbcl)
- (arguments
- ;; The tests require a debugger, but we run with the debugger disabled.
- '(#:tests? #f))
- (synopsis "LIsp Framework for Testing")
- (description
- "The LIsp Framework for Testing (LIFT) is a unit and system test tool for LISP.
-Though inspired by SUnit and JUnit, it's built with Lisp in mind. In LIFT,
-testcases are organized into hierarchical testsuites each of which can have
-its own fixture. When run, a testcase can succeed, fail, or error. LIFT
-supports randomized testing, benchmarking, profiling, and reporting.")
- (home-page "https://github.com/gwkkwg/lift")
- (license license:expat))))
-
-(define-public cl-lift
- (sbcl-package->cl-source-package sbcl-lift))
-
-(define-public ecl-lift
- (sbcl-package->ecl-package sbcl-lift))
-
-(define-public sbcl-let-plus
- (let ((commit "5f14af61d501ecead02ec6b5a5c810efc0c9fdbb"))
- (package
- (name "sbcl-let-plus")
- (version (git-version "0.0.0" "1" commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/sharplispers/let-plus")
- (commit commit)))
- (sha256
- (base32
- "0i050ca2iys9f5mb7dgqgqdxfnc3b0rnjdwv95sqd490vkiwrsaj"))
- (file-name (git-file-name "let-plus" version))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("anaphora" ,sbcl-anaphora)))
- (native-inputs
- `(("lift" ,sbcl-lift)))
- (synopsis "Destructuring extension of let*")
- (description
- "This library implements the let+ macro, which is a dectructuring
-extension of let*. It features:
-
-@itemize
-@item Clean, consistent syntax and small implementation (less than 300 LOC,
-not counting tests)
-@item Placeholder macros allow editor hints and syntax highlighting
-@item @command{&ign} for ignored values (in forms where that makes sense)
-@item Very easy to extend
-@end itemize\n")
- (home-page "https://github.com/sharplispers/let-plus")
- (license license:boost1.0))))
-
-(define-public cl-let-plus
- (sbcl-package->cl-source-package sbcl-let-plus))
-
-(define-public ecl-let-plus
- (sbcl-package->ecl-package sbcl-let-plus))
-
-(define-public sbcl-cl-colors
- (let ((commit "827410584553f5c717eec6182343b7605f707f75"))
- (package
- (name "sbcl-cl-colors")
- (version (git-version "0.0.0" "1" commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/tpapp/cl-colors")
- (commit commit)))
- (sha256
- (base32
- "0l446lday4hybsm9bq3jli97fvv8jb1d33abg79vbylpwjmf3y9a"))
- (file-name (git-file-name "cl-colors" version))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("let-plus" ,sbcl-let-plus)))
- (synopsis "Simple color library for Common Lisp")
- (description
- "This is a very simple color library for Common Lisp, providing
-
-@itemize
-@item Types for representing colors in HSV and RGB spaces.
-@item Simple conversion functions between the above types (and also
-hexadecimal representation for RGB).
-@item Some predefined colors (currently X11 color names – of course the
-library does not depend on X11).Because color in your terminal is nice.
-@end itemize
-
-This library is no longer supported by its author.")
- (home-page "https://github.com/tpapp/cl-colors")
- (license license:boost1.0))))
-
-(define-public cl-colors
- (sbcl-package->cl-source-package sbcl-cl-colors))
-
-(define-public ecl-cl-colors
- (sbcl-package->ecl-package sbcl-cl-colors))
-
-(define-public sbcl-cl-ansi-text
- (let ((commit "53badf7878f27f22f2d4a2a43e6df458e43acbe9"))
- (package
- (name "sbcl-cl-ansi-text")
- (version (git-version "1.0.0" "1" commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/pnathan/cl-ansi-text")
- (commit commit)))
- (sha256
- (base32
- "11i27n0dbz5lmygiw65zzr8lx0rac6b6yysqranphn31wls6ja3v"))
- (file-name (git-file-name "cl-ansi-text" version))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-colors" ,sbcl-cl-colors)))
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)))
- (synopsis "ANSI terminal color implementation for Common Lisp")
- (description
- "@command{cl-ansi-text} provides utilities which enable printing to an
-ANSI terminal with colored text. It provides the macro @command{with-color}
-which causes everything printed in the body to be displayed with the provided
-color. It further provides functions which will print the argument with the
-named color.")
- (home-page "https://github.com/pnathan/cl-ansi-text")
- (license license:llgpl))))
-
-(define-public cl-ansi-text
- (sbcl-package->cl-source-package sbcl-cl-ansi-text))
-
-(define-public ecl-cl-ansi-text
- (sbcl-package->ecl-package sbcl-cl-ansi-text))
-
-(define-public sbcl-prove-asdf
- (let ((commit "4f9122bd393e63c5c70c1fba23070622317cfaa0"))
- (package
- (name "sbcl-prove-asdf")
- (version (git-version "1.0.0" "1" commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/prove")
- (commit commit)))
- (sha256
- (base32
- "07sbfw459z8bbjvx1qlmfa8qk2mvbjnnzi2mi0x72blaj8bkl4vc"))
- (file-name (git-file-name "prove" version))))
- (build-system asdf-build-system/sbcl)
- (arguments
- `(#:asd-file "prove-asdf.asd"))
- (synopsis "Test requirement for the Common Lisp 'prove' library")
- (description
- "Test requirement for the Common Lisp @command{prove} library.")
- (home-page "https://github.com/fukamachi/prove")
- (license license:expat))))
-
-(define-public cl-prove-asdf
- (sbcl-package->cl-source-package sbcl-prove-asdf))
-
-(define-public ecl-prove-asdf
- (sbcl-package->ecl-package sbcl-prove-asdf))
-
-(define-public sbcl-prove
- (package
- (inherit sbcl-prove-asdf)
- (name "sbcl-prove")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-ppcre" ,sbcl-cl-ppcre)
- ("cl-ansi-text" ,sbcl-cl-ansi-text)))
- (native-inputs
- `(("prove-asdf" ,sbcl-prove-asdf)))
- (arguments
- `(#:asd-file "prove.asd"))
- (synopsis "Yet another unit testing framework for Common Lisp")
- (description
- "This project was originally called @command{cl-test-more}.
-@command{prove} is yet another unit testing framework for Common Lisp. The
-advantages of @command{prove} are:
-
-@itemize
-@item Various simple functions for testing and informative error messages
-@item ASDF integration
-@item Extensible test reporters
-@item Colorizes the report if it's available (note for SLIME)
-@item Reports test durations
-@end itemize\n")))
-
-(define-public cl-prove
- (sbcl-package->cl-source-package sbcl-prove))
-
-(define-public ecl-prove
- (sbcl-package->ecl-package sbcl-prove))
-
-(define-public sbcl-proc-parse
- (let ((commit "ac3636834d561bdc2686c956dbd82494537285fd"))
- (package
- (name "sbcl-proc-parse")
- (version (git-version "0.0.0" "1" commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/proc-parse")
- (commit commit)))
- (sha256
- (base32
- "06rnl0h4cx6xv2wj3jczmmcxqn2703inmmvg1s4npbghmijsybfh"))
- (file-name (git-file-name "proc-parse" version))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("babel" ,sbcl-babel)))
- (native-inputs
- `(("prove" ,sbcl-prove)
- ("prove-asdf" ,sbcl-prove-asdf)))
- (arguments
- ;; TODO: Tests don't find "proc-parse-test", why?
- `(#:tests? #f))
- (synopsis "Procedural vector parser")
- (description
- "This is a string/octets parser library for Common Lisp with speed and
-readability in mind. Unlike other libraries, the code is not a
-pattern-matching-like, but a char-by-char procedural parser.")
- (home-page "https://github.com/fukamachi/proc-parse")
- (license license:bsd-2))))
-
-(define-public cl-proc-parse
- (sbcl-package->cl-source-package sbcl-proc-parse))
-
-(define-public ecl-proc-parse
- (sbcl-package->ecl-package sbcl-proc-parse))
-
-(define-public sbcl-parse-float
- (let ((commit "2aae569f2a4b2eb3bfb5401a959425dcf151b09c"))
- (package
- (name "sbcl-parse-float")
- (version (git-version "0.0.0" "1" commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/soemraws/parse-float")
- (commit commit)))
- (sha256
- (base32
- "08xw8cchhmqcc0byng69m3f5a2izc9y2290jzz2k0qrbibp1fdk7"))
- (file-name (git-file-name "proc-parse" version))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("babel" ,sbcl-babel)))
- (native-inputs
- `(("prove" ,sbcl-prove)
- ("prove-asdf" ,sbcl-prove-asdf)))
- (arguments
- ;; TODO: Tests don't find "proc-parse-test", why?
- `(#:tests? #f))
- (synopsis "Parse a floating point value from a string in Common Lisp")
- (description
- "This package exports the following function to parse floating-point
-values from a string in Common Lisp.")
- (home-page "https://github.com/soemraws/parse-float")
- (license license:public-domain))))
-
-(define-public cl-parse-float
- (sbcl-package->cl-source-package sbcl-parse-float))
-
-(define-public ecl-parse-float
- (sbcl-package->ecl-package sbcl-parse-float))
-
-(define-public sbcl-ascii-strings
- (let ((revision "1")
- (changeset "5048480a61243e6f1b02884012c8f25cdbee6d97"))
- (package
- (name "sbcl-ascii-strings")
- (version (string-append "0-" revision "." (string-take changeset 7)))
- (source
- (origin
- (method hg-fetch)
- (uri (hg-reference
- (url "https://bitbucket.org/vityok/cl-string-match/")
- (changeset changeset)))
- (sha256
- (base32
- "01wn5qx562w43ssy92xlfgv79w7p0nv0wbl76mpmba131n9ziq2y"))
- (file-name (git-file-name "cl-string-match" version))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("babel" ,sbcl-babel)))
- (arguments
- `(#:asd-file "ascii-strings.asd"))
- (synopsis "Operations on ASCII strings")
- (description
- "Operations on ASCII strings. Essentially this can be any kind of
-single-byte encoded strings.")
- (home-page "https://bitbucket.org/vityok/cl-string-match/")
- (license license:bsd-3))))
-
-(define-public cl-ascii-strings
- (sbcl-package->cl-source-package sbcl-ascii-strings))
-
-(define-public ecl-ascii-strings
- (sbcl-package->ecl-package sbcl-ascii-strings))
-
-(define-public sbcl-simple-scanf
- (package
- (inherit sbcl-ascii-strings)
- (name "sbcl-simple-scanf")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("iterate" ,sbcl-iterate)
- ("proc-parse" ,sbcl-proc-parse)
- ("parse-float" ,sbcl-parse-float)))
- (arguments
- `(#:asd-file "simple-scanf.asd"))
- (synopsis "Simple scanf-like functionality implementation")
- (description
- "A simple scanf-like functionality implementation.")))
-
-(define-public cl-simple-scanf
- (sbcl-package->cl-source-package sbcl-simple-scanf))
-
-(define-public ecl-simple-scanf
- (sbcl-package->ecl-package sbcl-simple-scanf))
-
-(define-public sbcl-cl-string-match
- (package
- (inherit sbcl-ascii-strings)
- (name "sbcl-cl-string-match")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("ascii-strings" ,sbcl-ascii-strings)
- ("yacc" ,sbcl-cl-yacc)
- ("jpl-util" ,sbcl-jpl-util)
- ("jpl-queues" ,sbcl-jpl-queues)
- ("mgl-pax" ,sbcl-mgl-pax)
- ("iterate" ,sbcl-iterate)))
- ;; TODO: Tests are not evaluated properly.
- (native-inputs
- ;; For testing:
- `(("lisp-unit" ,sbcl-lisp-unit)
- ("simple-scanf" ,sbcl-simple-scanf)))
- (arguments
- `(#:tests? #f
- #:asd-file "cl-string-match.asd"))
- (synopsis "Portable, dependency-free set of utilities to manipulate strings in Common Lisp")
- (description
- "@command{cl-strings} is a small, portable, dependency-free set of
-utilities that make it even easier to manipulate text in Common Lisp. It has
-100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.")))
-
-(define-public cl-string-match
- (sbcl-package->cl-source-package sbcl-cl-string-match))
-
-(define-public ecl-cl-string-match
- (sbcl-package->ecl-package sbcl-cl-string-match))
-
-(define-public sbcl-ptester
- (package
- (name "sbcl-ptester")
- (version "20160929")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "http://beta.quicklisp.org/archive/ptester/"
- (date->string (string->date version "~Y~m~d") "~Y-~m-~d")
- "/ptester-"
- version
- "-git.tgz"))
- (sha256
- (base32
- "04rlq1zljhxc65pm31bah3sq3as24l0sdivz440s79qlnnyh13hz"))))
- (build-system asdf-build-system/sbcl)
- (home-page "http://quickdocs.org/ptester/")
- (synopsis "Portable test harness package")
- (description
- "@command{ptester} is a portable testing framework based on Franz's
-tester module.")
- (license license:lgpl3+)))
-
-(define-public cl-ptester
- (sbcl-package->cl-source-package sbcl-ptester))
-
-(define-public ecl-ptester
- (sbcl-package->ecl-package sbcl-ptester))
-
-(define-public sbcl-puri
- (package
- (name "sbcl-puri")
- (version "20180228")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "http://beta.quicklisp.org/archive/puri/"
- (date->string (string->date version "~Y~m~d") "~Y-~m-~d")
- "/puri-"
- version
- "-git.tgz"))
- (sha256
- (base32
- "1s4r5adrjy5asry45xbcbklxhdjydvf6n55z897nvyw33bigrnbz"))))
- (build-system asdf-build-system/sbcl)
- ;; REVIEW: Webiste down?
- (native-inputs
- `(("ptester" ,sbcl-ptester)))
- (home-page "http://files.kpe.io/puri/")
- (synopsis "Portable URI Library")
- (description
- "This is portable Universal Resource Identifier library for Common Lisp
-programs. It parses URI according to the RFC 2396 specification")
- (license license:lgpl3+)))
-
-(define-public cl-puri
- (sbcl-package->cl-source-package sbcl-puri))
-
-(define-public ecl-puri
- (sbcl-package->ecl-package sbcl-puri))
-
-(define-public sbcl-queues
- (let ((commit "47d4da65e9ea20953b74aeeab7e89a831b66bc94"))
- (package
- (name "sbcl-queues")
- (version (git-version "0.0.0" "1" commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/oconnore/queues")
- (commit commit)))
- (file-name (git-file-name "queues" version))
- (sha256
- (base32
- "0wdhfnzi4v6d97pggzj2aw55si94w4327br94jrmyvwf351wqjvv"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://github.com/oconnore/queues")
- (synopsis "Common Lisp queue library")
- (description
- "This is a simple queue library for Common Lisp with features such as
-non-consing thread safe queues and fibonacci priority queues.")
- (license license:expat))))
-
-(define-public cl-queues
- (sbcl-package->cl-source-package sbcl-queues))
-
-(define-public ecl-queues
- (sbcl-package->ecl-package sbcl-queues))
-
-(define-public sbcl-queues.simple-queue
- (package
- (inherit sbcl-queues)
- (name "sbcl-queues.simple-queue")
- (inputs
- `(("sbcl-queues" ,sbcl-queues)))
- (arguments
- `(#:asd-file "queues.simple-queue.asd"))
- (synopsis "Simple queue implementation")
- (description
- "This is a simple queue library for Common Lisp with features such as
-non-consing thread safe queues and fibonacci priority queues.")
- (license license:expat)))
-
-(define-public cl-queues.simple-queue
- (sbcl-package->cl-source-package sbcl-queues.simple-queue))
-
-(define-public ecl-queues.simple-queue
- (sbcl-package->ecl-package sbcl-queues.simple-queue))
-
-(define-public sbcl-queues.simple-cqueue
- (package
- (inherit sbcl-queues)
- (name "sbcl-queues.simple-cqueue")
- (inputs
- `(("sbcl-queues" ,sbcl-queues)
- ("sbcl-queues.simple-queue" ,sbcl-queues.simple-queue)
- ("bordeaux-threads" ,sbcl-bordeaux-threads)))
- (arguments
- `(#:asd-file "queues.simple-cqueue.asd"))
- (synopsis "Thread safe queue implementation")
- (description
- "This is a simple queue library for Common Lisp with features such as
-non-consing thread safe queues and fibonacci priority queues.")
- (license license:expat)))
-
-(define-public cl-queues.simple-cqueue
- (sbcl-package->cl-source-package sbcl-queues.simple-cqueue))
-
-(define-public ecl-queues.simple-cqueue
- (sbcl-package->ecl-package sbcl-queues.simple-cqueue))
-
-(define-public sbcl-queues.priority-queue
- (package
- (inherit sbcl-queues)
- (name "sbcl-queues.priority-queue")
- (inputs
- `(("sbcl-queues" ,sbcl-queues)))
- (arguments
- `(#:asd-file "queues.priority-queue.asd"))
- (synopsis "Priority queue (Fibonacci) implementation")
- (description
- "This is a simple queue library for Common Lisp with features such as
-non-consing thread safe queues and fibonacci priority queues.")
- (license license:expat)))
-
-(define-public cl-queues.priority-queue
- (sbcl-package->cl-source-package sbcl-queues.priority-queue))
-
-(define-public ecl-queues.priority-queue
- (sbcl-package->ecl-package sbcl-queues.priority-queue))
-
-(define-public sbcl-queues.priority-cqueue
- (package
- (inherit sbcl-queues)
- (name "sbcl-queues.priority-cqueue")
- (inputs
- `(("sbcl-queues" ,sbcl-queues)
- ("sbcl-queues.priority-queue" ,sbcl-queues.priority-queue)
- ("bordeaux-threads" ,sbcl-bordeaux-threads)))
- (arguments
- `(#:asd-file "queues.priority-cqueue.asd"))
- (synopsis "Thread safe fibonacci priority queue implementation")
- (description
- "This is a simple queue library for Common Lisp with features such as
-non-consing thread safe queues and fibonacci priority queues.")
- (license license:expat)))
-
-(define-public cl-queues.priority-cqueue
- (sbcl-package->cl-source-package sbcl-queues.priority-cqueue))
-
-(define-public ecl-queues.priority-cqueue
- (sbcl-package->ecl-package sbcl-queues.priority-cqueue))
-
-(define sbcl-cffi-bootstrap
- (package
- (name "sbcl-cffi-bootstrap")
- (version "0.19.0")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/cffi/cffi.git")
- (commit (string-append "v" version))))
- (file-name (git-file-name "cffi-bootstrap" version))
- (sha256
- (base32 "09sfgc6r7ihmbkwfpvkq5fxc7h45cabpvgbvs47i5cvnmv3k72xy"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("libffi" ,libffi)
- ("alexandria" ,sbcl-alexandria)
- ("babel" ,sbcl-babel)
- ("trivial-features" ,sbcl-trivial-features)))
- (native-inputs
- `(("pkg-config" ,pkg-config)))
- (arguments
- '(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "libffi/libffi.lisp"
- (("libffi.so.6" all) (string-append
- (assoc-ref inputs "libffi")
- "/lib/" all)))
- (substitute* "toolchain/c-toolchain.lisp"
- (("\"cc\"") (format #f "~S" (which "gcc")))))))
- #:asd-system-name "cffi"
- #:tests? #f))
- (home-page "https://common-lisp.net/project/cffi/")
- (synopsis "Common Foreign Function Interface for Common Lisp")
- (description "The Common Foreign Function Interface (CFFI)
-purports to be a portable foreign function interface for Common Lisp.
-The CFFI library is composed of a Lisp-implementation-specific backend
-in the CFFI-SYS package, and a portable frontend in the CFFI
-package.")
- (license license:expat)))
-
-(define-public sbcl-cffi-toolchain
- (package
- (inherit sbcl-cffi-bootstrap)
- (name "sbcl-cffi-toolchain")
- (inputs
- `(("libffi" ,libffi)
- ("sbcl-cffi" ,sbcl-cffi-bootstrap)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cffi-bootstrap)
- ((#:asd-system-name _) #f)
- ((#:tests? _) #t)))))
-
-(define-public sbcl-cffi-libffi
- (package
- (inherit sbcl-cffi-toolchain)
- (name "sbcl-cffi-libffi")
- (inputs
- `(("cffi" ,sbcl-cffi-bootstrap)
- ("cffi-grovel" ,sbcl-cffi-grovel)
- ("trivial-features" ,sbcl-trivial-features)
- ("libffi" ,libffi)))))
-
-(define-public sbcl-cffi-grovel
- (package
- (inherit sbcl-cffi-toolchain)
- (name "sbcl-cffi-grovel")
- (inputs
- `(("libffi" ,libffi)
- ("cffi" ,sbcl-cffi-bootstrap)
- ("cffi-toolchain" ,sbcl-cffi-toolchain)
- ("alexandria" ,sbcl-alexandria)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-cffi-toolchain)
- ((#:phases phases)
- `(modify-phases ,phases
- (add-after 'build 'install-headers
- (lambda* (#:key outputs #:allow-other-keys)
- (install-file "grovel/common.h"
- (string-append
- (assoc-ref outputs "out")
- "/include/grovel"))))))))))
-
-(define-public sbcl-cffi
- (package
- (inherit sbcl-cffi-toolchain)
- (name "sbcl-cffi")
- (inputs (package-inputs sbcl-cffi-bootstrap))
- (native-inputs
- `(("cffi-grovel" ,sbcl-cffi-grovel)
- ("cffi-libffi" ,sbcl-cffi-libffi)
- ("rt" ,sbcl-rt)
- ("bordeaux-threads" ,sbcl-bordeaux-threads)
- ,@(package-native-inputs sbcl-cffi-bootstrap)))))
-
-(define-public cl-cffi
- (sbcl-package->cl-source-package sbcl-cffi))
-
-(define-public sbcl-cl-sqlite
- (let ((commit "c738e66d4266ef63a1debc4ef4a1b871a068c112"))
- (package
- (name "sbcl-cl-sqlite")
- (version (git-version "0.2" "1" commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/dmitryvk/cl-sqlite")
- (commit commit)))
- (file-name (git-file-name "cl-sqlite" version))
- (sha256
- (base32
- "1ng45k1hdb84sqjryrfx93g66bsbybmpy301wd0fdybnc5jzr36q"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("iterate" ,sbcl-iterate)
- ("cffi" ,sbcl-cffi)
- ("sqlite" ,sqlite)))
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)
- ("bordeaux-threads" ,sbcl-bordeaux-threads)))
- (arguments
- `(#:tests? #f ; Upstream seems to have issues with tests: https://github.com/dmitryvk/cl-sqlite/issues/7
- #:asd-file "sqlite.asd"
- #:asd-system-name "sqlite"
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "sqlite-ffi.lisp"
- (("libsqlite3" all) (string-append
- (assoc-ref inputs "sqlite")"/lib/" all))))))))
- (home-page "https://common-lisp.net/project/cl-sqlite/")
- (synopsis "Common Lisp binding for SQLite")
- (description
- "The @command{cl-sqlite} package is an interface to the SQLite embedded
-relational database engine.")
- (license license:public-domain))))
-
-(define-public cl-sqlite
- (sbcl-package->cl-source-package sbcl-cl-sqlite))
-
-(define-public sbcl-parenscript
- (let ((commit "061d8e286c81c3f45c84fb2b11ee7d83f590a8f8"))
- (package
- (name "sbcl-parenscript")
- (version (git-version "2.6" "1" commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://gitlab.common-lisp.net/parenscript/parenscript")
- (commit commit)))
- (file-name (git-file-name "parenscript" version))
- (sha256
- (base32
- "1kbhgsjbikc73m5cwdp4d4fdafyqcr1b7b630qjrziql0nh6mi3k"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("cl-ppcre" ,sbcl-cl-ppcre)
- ("anaphora" ,sbcl-anaphora)
- ("named-readtables" ,sbcl-named-readtables)))
- (home-page "https://common-lisp.net/project/parenscript/")
- (synopsis "Translator from a subset of Common Lisp to JavaScript")
- (description
- "Parenscript is a translator from an extended subset of Common Lisp to
-JavaScript. Parenscript code can run almost identically on both the
-browser (as JavaScript) and server (as Common Lisp).
-
-Parenscript code is treated the same way as Common Lisp code, making the full
-power of Lisp macros available for JavaScript. This provides a web
-development environment that is unmatched in its ability to reduce code
-duplication and provide advanced meta-programming facilities to web
-developers.
-
-At the same time, Parenscript is different from almost all other \"language
-X\" to JavaScript translators in that it imposes almost no overhead:
-
-@itemize
-@item No run-time dependencies: Any piece of Parenscript code is runnable
-as-is. There are no JavaScript files to include.
-@item Native types: Parenscript works entirely with native JavaScript data
-types. There are no new types introduced, and object prototypes are not
-touched.
-@item Native calling convention: Any JavaScript code can be called without the
-need for bindings. Likewise, Parenscript can be used to make efficient,
-self-contained JavaScript libraries.
-@item Readable code: Parenscript generates concise, formatted, idiomatic
-JavaScript code. Identifier names are preserved. This enables seamless
-debugging in tools like Firebug.
-@item Efficiency: Parenscript introduces minimal overhead for advanced Common
-Lisp features. The generated code is almost as fast as hand-written
-JavaScript.
-@end itemize\n")
- (license license:bsd-3))))
-
-(define-public cl-parenscript
- (sbcl-package->cl-source-package sbcl-parenscript))
-
-(define-public ecl-parenscript
- (sbcl-package->ecl-package sbcl-parenscript))
-
-(define-public sbcl-cl-json
- (let ((commit "6dfebb9540bfc3cc33582d0c03c9ec27cb913e79"))
- (package
- (name "sbcl-cl-json")
- (version (git-version "0.5" "1" commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/hankhero/cl-json")
- (commit commit)))
- (file-name (git-file-name "cl-json" version))
- (sha256
- (base32
- "0fx3m3x3s5ji950yzpazz4s0img3l6b3d6l3jrfjv0lr702496lh"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)))
- (home-page "https://github.com/hankhero/cl-json")
- (synopsis "JSON encoder and decoder for Common-Lisp")
- (description
- "@command{cl-json} provides an encoder of Lisp objects to JSON format
-and a corresponding decoder of JSON data to Lisp objects. Both the encoder
-and the decoder are highly customizable; at the same time, the default
-settings ensure a very simple mode of operation, similar to that provided by
-@command{yason} or @command{st-json}.")
- (license license:expat))))
-
-(define-public cl-json
- (sbcl-package->cl-source-package sbcl-cl-json))
-
-(define-public ecl-cl-json
- (sbcl-package->ecl-package sbcl-cl-json))
-
-(define-public sbcl-unix-opts
- (package
- (name "sbcl-unix-opts")
- (version "0.1.7")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/libre-man/unix-opts")
- (commit version)))
- (file-name (git-file-name "unix-opts" version))
- (sha256
- (base32
- "08djdi1ard09fijb7w9bdmhmwd98b1hzmcnjw9fqjiqa0g3b44rr"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://github.com/hankhero/cl-json")
- (synopsis "Unix-style command line options parser")
- (description
- "This is a minimalistic parser of command line options. The main
-advantage of the library is the ability to concisely define command line
-options once and then use this definition for parsing and extraction of
-command line arguments, as well as printing description of command line
-options (you get --help for free). This way you don't need to repeat
-yourself. Also, @command{unix-opts} doesn't depend on anything and allows to
-precisely control behavior of the parser via Common Lisp restarts.")
- (license license:expat)))
-
-(define-public cl-unix-opts
- (sbcl-package->cl-source-package sbcl-unix-opts))
-
-(define-public ecl-unix-opts
- (sbcl-package->ecl-package sbcl-unix-opts))
-
-(define-public sbcl-trivial-garbage
- (package
- (name "sbcl-trivial-garbage")
- (version "0.21")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/trivial-garbage/trivial-garbage.git")
- (commit (string-append "v" version))))
- (file-name (git-file-name "trivial-garbage" version))
- (sha256
- (base32 "0122jicfg7pca1wxw8zak1n92h5friqy60988ns0ysksj3fphw9n"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- `(("rt" ,sbcl-rt)))
- (home-page "https://common-lisp.net/project/trivial-garbage/")
- (synopsis "Portable GC-related APIs for Common Lisp")
- (description "@command{trivial-garbage} provides a portable API to
-finalizers, weak hash-tables and weak pointers on all major implementations of
-the Common Lisp programming language.")
- (license license:public-domain)))
-
-(define-public cl-trivial-garbage
- (sbcl-package->cl-source-package sbcl-trivial-garbage))
-
-(define-public ecl-trivial-garbage
- (sbcl-package->ecl-package sbcl-trivial-garbage))
-
-(define-public sbcl-closer-mop
- (let ((commit "fac29ce90e3a46e1fc6cf182190e193526fa9dbc"))
- (package
- (name "sbcl-closer-mop")
- (version (git-version "1.0.0" "1" commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/pcostanza/closer-mop")
- (commit commit)))
- (sha256
- (base32 "0hvh77y869h8fg9di5snyg85fxq6fdh9gj1igmx1g6j6j5x915dl"))
- (file-name (git-file-name "closer-mop" version ))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://github.com/pcostanza/closer-mop")
- (synopsis "Rectifies absent or incorrect CLOS MOP features")
- (description "Closer to MOP is a compatibility layer that rectifies many
-of the absent or incorrect CLOS MOP features across a broad range of Common
-Lisp implementations.")
- (license license:expat))))
-
-(define-public cl-closer-mop
- (sbcl-package->cl-source-package sbcl-closer-mop))
-
-(define-public ecl-closer-mop
- (sbcl-package->ecl-package sbcl-closer-mop))
-
-(define sbcl-cl-cffi-gtk-boot0
- (let ((commit "29443c5aaca975709df8025c4649366d882033cb"))
- (package
- (name "sbcl-cl-cffi-gtk-boot0")
- (version (git-version "0.11.2" "1" commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Ferada/cl-cffi-gtk/")
- (commit commit)))
- (file-name (git-file-name "cl-cffi-gtk" version))
- (sha256
- (base32
- "0f6s92sf8xyzh1yksqx8bsy1sv0zmy0c13j3b8bavaba5hlxpxah"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("iterate" ,sbcl-iterate)
- ("cffi" ,sbcl-cffi)
- ("trivial-features" ,sbcl-trivial-features)))
- (home-page "https://github.com/Ferada/cl-cffi-gtk/")
- (synopsis "Common Lisp binding for GTK+3")
- (description
- "@command{cl-cffi-gtk} is a Lisp binding to GTK+ 3 (GIMP Toolkit) which
-is a library for creating graphical user interfaces.")
- (license license:lgpl3))))
-
-(define-public sbcl-cl-cffi-gtk-glib
- (package
- (inherit sbcl-cl-cffi-gtk-boot0)
- (name "sbcl-cl-cffi-gtk-glib")
- (inputs
- `(("glib" ,glib)
- ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
- (arguments
- `(#:asd-file "glib/cl-cffi-gtk-glib.asd"
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "glib/glib.init.lisp"
- (("libglib|libgthread" all) (string-append
- (assoc-ref inputs "glib") "/lib/" all))))))))))
-
-(define-public sbcl-cl-cffi-gtk-gobject
- (package
- (inherit sbcl-cl-cffi-gtk-boot0)
- (name "sbcl-cl-cffi-gtk-gobject")
- (inputs
- `(("glib" ,glib)
- ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
- ("trivial-garbage" ,sbcl-trivial-garbage)
- ("bordeaux-threads" ,sbcl-bordeaux-threads)
- ("closer-mop" ,sbcl-closer-mop)
- ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
- (arguments
- `(#:asd-file "gobject/cl-cffi-gtk-gobject.asd"
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "gobject/gobject.init.lisp"
- (("libgobject" all) (string-append
- (assoc-ref inputs "glib") "/lib/" all))))))))))
-
-(define-public sbcl-cl-cffi-gtk-gio
- (package
- (inherit sbcl-cl-cffi-gtk-boot0)
- (name "sbcl-cl-cffi-gtk-gio")
- (inputs
- `(("glib" ,glib)
- ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
- ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
- ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
- (arguments
- `(#:asd-file "gio/cl-cffi-gtk-gio.asd"
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "gio/gio.init.lisp"
- (("libgio" all)
- (string-append
- (assoc-ref inputs "glib") "/lib/" all))))))))))
-
-(define-public sbcl-cl-cffi-gtk-cairo
- (package
- (inherit sbcl-cl-cffi-gtk-boot0)
- (name "sbcl-cl-cffi-gtk-cairo")
- (inputs
- `(("cairo" ,cairo)
- ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
- ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
- (arguments
- `(#:asd-file "cairo/cl-cffi-gtk-cairo.asd"
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "cairo/cairo.init.lisp"
- (("libcairo" all)
- (string-append
- (assoc-ref inputs "cairo") "/lib/" all))))))))))
-
-(define-public sbcl-cl-cffi-gtk-pango
- (package
- (inherit sbcl-cl-cffi-gtk-boot0)
- (name "sbcl-cl-cffi-gtk-pango")
- (inputs
- `(("pango" ,pango)
- ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
- ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
- ("cl-cffi-gtk-cairo" ,sbcl-cl-cffi-gtk-cairo)
- ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
- (arguments
- `(#:asd-file "pango/cl-cffi-gtk-pango.asd"
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "pango/pango.init.lisp"
- (("libpango" all)
- (string-append
- (assoc-ref inputs "pango") "/lib/" all))))))))))
-
-(define-public sbcl-cl-cffi-gtk-gdk-pixbuf
- (package
- (inherit sbcl-cl-cffi-gtk-boot0)
- (name "sbcl-cl-cffi-gtk-gdk-pixbuf")
- (inputs
- `(("gdk-pixbuf" ,gdk-pixbuf)
- ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
- ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
- (arguments
- `(#:asd-file "gdk-pixbuf/cl-cffi-gtk-gdk-pixbuf.asd"
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "gdk-pixbuf/gdk-pixbuf.init.lisp"
- (("libgdk_pixbuf" all)
- (string-append
- (assoc-ref inputs "gdk-pixbuf") "/lib/" all))))))))))
-
-(define-public sbcl-cl-cffi-gtk-gdk
- (package
- (inherit sbcl-cl-cffi-gtk-boot0)
- (name "sbcl-cl-cffi-gtk-gdk")
- (inputs
- `(("gtk" ,gtk+)
- ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
- ("cl-cffi-gtk-gio" ,sbcl-cl-cffi-gtk-gio)
- ("cl-cffi-gtk-gdk-pixbuf" ,sbcl-cl-cffi-gtk-gdk-pixbuf)
- ("cl-cffi-gtk-cairo" ,sbcl-cl-cffi-gtk-cairo)
- ("cl-cffi-gtk-pango" ,sbcl-cl-cffi-gtk-pango)
- ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
- (arguments
- `(#:asd-file "gdk/cl-cffi-gtk-gdk.asd"
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "gdk/gdk.init.lisp"
- (("libgdk" all)
- (string-append
- (assoc-ref inputs "gtk") "/lib/" all)))
- (substitute* "gdk/gdk.package.lisp"
- (("libgtk" all)
- (string-append
- (assoc-ref inputs "gtk") "/lib/" all))))))))))
-
-(define-public sbcl-cl-cffi-gtk
- (package
- (inherit sbcl-cl-cffi-gtk-boot0)
- (name "sbcl-cl-cffi-gtk")
- (inputs
- `(("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
- ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
- ("cl-cffi-gtk-gio" ,sbcl-cl-cffi-gtk-gio)
- ("cl-cffi-gtk-gdk" ,sbcl-cl-cffi-gtk-gdk)
- ,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)))
- (arguments
- `(#:asd-file "gtk/cl-cffi-gtk.asd"
- #:test-asd-file "test/cl-cffi-gtk-test.asd"
- ;; TODO: Tests fail with memory fault.
- ;; See https://github.com/Ferada/cl-cffi-gtk/issues/24.
- #:tests? #f))))
-
-(define-public cl-cffi-gtk
- (sbcl-package->cl-source-package sbcl-cl-cffi-gtk))
-
-(define-public sbcl-cl-webkit
- (let ((commit "cd2a9008e0c152e54755e8a7f07b050fe36bab31"))
- (package
- (name "sbcl-cl-webkit")
- (version (git-version "2.4" "1" commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/jmercouris/cl-webkit")
- (commit commit)))
- (file-name (git-file-name "cl-webkit" version))
- (sha256
- (base32
- "0f5lyn9i7xrn3g1bddga377mcbawkbxydijpg389q4n04gqj0vwf"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("cffi" ,sbcl-cffi)
- ("cl-cffi-gtk" ,sbcl-cl-cffi-gtk)
- ("webkitgtk" ,webkitgtk)))
- (arguments
- `(#:asd-file "webkit2/cl-webkit2.asd"
- #:asd-system-name "cl-webkit2"
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "webkit2/webkit2.init.lisp"
- (("libwebkit2gtk" all)
- (string-append
- (assoc-ref inputs "webkitgtk") "/lib/" all))))))))
- (home-page "https://github.com/jmercouris/cl-webkit")
- (synopsis "Binding to WebKitGTK+ for Common Lisp")
- (description
- "@command{cl-webkit} is a binding to WebKitGTK+ for Common Lisp,
-currently targeting WebKit version 2. The WebKitGTK+ library adds web
-browsing capabilities to an application, leveraging the full power of the
-WebKit browsing engine.")
- (license license:expat))))
-
-(define-public cl-webkit
- (sbcl-package->cl-source-package sbcl-cl-webkit))
-
-(define-public sbcl-lparallel
- (package
- (name "sbcl-lparallel")
- (version "2.8.4")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/lmj/lparallel/")
- (commit (string-append "lparallel-" version))))
- (file-name (git-file-name "lparallel" version))
- (sha256
- (base32
- "0g0aylrbbrqsz0ahmwhvnk4cmc2931fllbpcfgzsprwnqqd7vwq9"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("bordeaux-threads" ,sbcl-bordeaux-threads)
- ("trivial-garbage" ,sbcl-trivial-garbage)))
- (home-page "https://lparallel.org/")
- (synopsis "Parallelism for Common Lisp")
- (description
- "@command{lparallel} is a library for parallel programming in Common
-Lisp, featuring:
-
-@itemize
-@item a simple model of task submission with receiving queue,
-@item constructs for expressing fine-grained parallelism,
-@item asynchronous condition handling across thread boundaries,
-@item parallel versions of map, reduce, sort, remove, and many others,
-@item promises, futures, and delayed evaluation constructs,
-@item computation trees for parallelizing interconnected tasks,
-@item bounded and unbounded FIFO queues,
-@item high and low priority tasks,
-@item task killing by category,
-@item integrated timeouts.
-@end itemize\n")
- (license license:expat)))
-
-(define-public cl-lparallel
- (sbcl-package->cl-source-package sbcl-lparallel))
-
-(define-public ecl-lparallel
- (sbcl-package->ecl-package sbcl-lparallel))
-
-(define-public sbcl-cl-markup
- (let ((commit "e0eb7debf4bdff98d1f49d0f811321a6a637b390"))
- (package
- (name "sbcl-cl-markup")
- (version (git-version "0.1" "1" commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/arielnetworks/cl-markup/")
- (commit commit)))
- (file-name (git-file-name "cl-markup" version))
- (sha256
- (base32
- "10l6k45971dl13fkdmva7zc6i453lmq9j4xax2ci6pjzlc6xjhp7"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://github.com/arielnetworks/cl-markup/")
- (synopsis "Markup generation library for Common Lisp")
- (description
- "A modern markup generation library for Common Lisp that features:
-
-@itemize
-@item Fast (even faster through compiling the code)
-@item Safety
-@item Support for multiple document types (markup, xml, html, html5, xhtml)
-@item Output with doctype
-@item Direct output to stream
-@end itemize\n")
- (license license:lgpl3+))))
-
-(define-public cl-markup
- (sbcl-package->cl-source-package sbcl-cl-markup))
-
-(define-public ecl-cl-markup
- (sbcl-package->ecl-package sbcl-cl-markup))
-
-(define-public sbcl-cl-css
- (let ((commit "8fe654c8f0cf95b300718101cce4feb517f78e2f"))
- (package
- (name "sbcl-cl-css")
- (version (git-version "0.1" "1" commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/inaimathi/cl-css/")
- (commit commit)))
- (file-name (git-file-name "cl-css" version))
- (sha256
- (base32
- "1lc42zi2sw11fl2589sc19nr5sd2p0wy7wgvgwaggxa5f3ajhsmd"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://github.com/inaimathi/cl-css/")
- (synopsis "Non-validating, inline CSS generator for Common Lisp")
- (description
- "This is a dead-simple, non validating, inline CSS generator for Common
-Lisp. Its goals are axiomatic syntax, simple implementation to support
-portability, and boilerplate reduction in CSS.")
- (license license:expat))))
-
-(define-public cl-css
- (sbcl-package->cl-source-package sbcl-cl-css))
-
-(define-public ecl-cl-css
- (sbcl-package->ecl-package sbcl-cl-css))
-
-(define-public sbcl-portable-threads
- (let ((commit "c0e61a1faeb0583c80fd3f20b16cc4c555226920"))
- (package
- (name "sbcl-portable-threads")
- (version (git-version "2.3" "1" commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/binghe/portable-threads/")
- (commit commit)))
- (file-name (git-file-name "portable-threads" version))
- (sha256
- (base32
- "03fmxyarc0xf4kavwkfa0a2spkyfrz6hbgbi9y4q7ny5aykdyfaq"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- `(;; Tests seem broken.
- #:tests? #f))
- (home-page "https://github.com/binghe/portable-threads")
- (synopsis "Portable threads (and scheduled and periodic functions) API for Common Lisp")
- (description
- "Portable Threads (and Scheduled and Periodic Functions) API for Common
-Lisp (from GBBopen project).")
- (license license:asl2.0))))
-
-(define-public cl-portable-threads
- (sbcl-package->cl-source-package sbcl-portable-threads))
-
-(define-public ecl-portable-threada
- (sbcl-package->ecl-package sbcl-portable-threads))
-
-(define-public sbcl-usocket-boot0
- ;; usocket's test rely on usocket-server which depends on usocket itself.
- ;; We break this cyclic dependency with -boot0 that packages usocket.
- (let ((commit "86e7efbfe50101931edf4b67cdcfa7e221ecfde9"))
- (package
- (name "sbcl-usocket-boot0")
- (version (git-version "0.7.1" "1" commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/usocket/usocket/")
- (commit commit)))
- (file-name (git-file-name "usocket" version))
- (sha256
- (base32
- "1lk6ipakrib7kdgzw44hrgmls9akp5pz4h35yynw0k5zwmmq6374"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("split-sequence" ,sbcl-split-sequence)))
- (arguments
- `(#:tests? #f
- #:asd-system-name "usocket"))
- (home-page "https://common-lisp.net/project/usocket/")
- (synopsis "Universal socket library for Common Lisp (server side)")
- (description
- "This library strives to provide a portable TCP/IP and UDP/IP socket
-interface for as many Common Lisp implementations as possible, while keeping
-the abstraction and portability layer as thin as possible.")
- (license license:expat))))
-
-(define-public sbcl-usocket-server
- (package
- (inherit sbcl-usocket-boot0)
- (name "sbcl-usocket-server")
- (inputs
- `(("usocket" ,sbcl-usocket-boot0)
- ("portable-threads" ,sbcl-portable-threads)))
- (arguments
- '(#:asd-system-name "usocket-server"))
- (synopsis "Universal socket library for Common Lisp (server side)")))
-
-(define-public cl-usocket-server
- (sbcl-package->cl-source-package sbcl-usocket-server))
-
-(define-public ecl-socket-server
- (sbcl-package->ecl-package sbcl-usocket-server))
-
-(define-public sbcl-usocket
- (package
- (inherit sbcl-usocket-boot0)
- (name "sbcl-usocket")
- (arguments
- ;; FIXME: Tests need network access?
- `(#:tests? #f))
- (native-inputs
- ;; Testing only.
- `(("usocket-server" ,sbcl-usocket-server)
- ("rt" ,sbcl-rt)))))
-
-(define-public cl-usocket
- (sbcl-package->cl-source-package sbcl-usocket))
-
-(define-public ecl-socket
- (sbcl-package->ecl-package sbcl-usocket))
-
-(define-public sbcl-s-xml
- (package
- (name "sbcl-s-xml")
- (version "3")
- (source
- (origin
- (method url-fetch)
- (uri "https://common-lisp.net/project/s-xml/s-xml.tgz")
- (sha256
- (base32
- "061qcr0dzshsa38s5ma4ay924cwak2nq9gy59dw6v9p0qb58nzjf"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://common-lisp.net/project/s-xml/")
- (synopsis "Simple XML parser implemented in Common Lisp")
- (description
- "S-XML is a simple XML parser implemented in Common Lisp. This XML
-parser implementation has the following features:
-
-@itemize
-@item It works (handling many common XML usages).
-@item It is very small (the core is about 700 lines of code, including
-comments and whitespace).
-@item It has a core API that is simple, efficient and pure functional, much
-like that from SSAX (see also http://ssax.sourceforge.net).
-@item It supports different DOM models: an XSML-based one, an LXML-based one
-and a classic xml-element struct based one.
-@item It is reasonably time and space efficient (internally avoiding garbage
-generatation as much as possible).
-@item It does support CDATA.
-@item It should support the same character sets as your Common Lisp
-implementation.
-@item It does support XML name spaces.
-@end itemize
-
-This XML parser implementation has the following limitations:
-
-@itemize
-@item It does not support any special tags (like processing instructions).
-@item It is not validating, even skips DTD's all together.
-@end itemize\n")
- (license license:lgpl3+)))
-
-(define-public cl-s-xml
- (sbcl-package->cl-source-package sbcl-s-xml))
-
-(define-public ecl-s-xml
- (sbcl-package->ecl-package sbcl-s-xml))
-
-(define-public sbcl-s-xml-rpc
- (package
- (name "sbcl-s-xml-rpc")
- (version "7")
- (source
- (origin
- (method url-fetch)
- (uri "https://common-lisp.net/project/s-xml-rpc/s-xml-rpc.tgz")
- (sha256
- (base32
- "02z7k163d51v0pzk8mn1xb6h5s6x64gjqkslhwm3a5x26k2gfs11"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("s-xml" ,sbcl-s-xml)))
- (home-page "https://common-lisp.net/project/s-xml-rpc/")
- (synopsis "Implementation of XML-RPC in Common Lisp for both client and server")
- (description
- "S-XML-RPC is an implementation of XML-RPC in Common Lisp for both
-client and server.")
- (license license:lgpl3+)))
-
-(define-public cl-s-xml-rpc
- (sbcl-package->cl-source-package sbcl-s-xml-rpc))
-
-(define-public ecl-s-xml-rpc
- (sbcl-package->ecl-package sbcl-s-xml-rpc))
-
-(define-public sbcl-trivial-clipboard
- (let ((commit "5af3415d1484e6d69a1b5c178f24680d9fd01796"))
- (package
- (name "sbcl-trivial-clipboard")
- (version (git-version "0.0.0.0" "2" commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/snmsts/trivial-clipboard")
- (commit commit)))
- (file-name (git-file-name "trivial-clipboard" version))
- (sha256
- (base32
- "1gb515z5yq6h5548pb1fwhmb0hhq1ssyb78pvxh4alq799xipxs9"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("xclip" ,xclip)))
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)))
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/text.lisp"
- (("\\(executable-find \"xclip\"\\)")
- (string-append "(executable-find \""
- (assoc-ref inputs "xclip")
- "/bin/xclip\")"))))))))
- (home-page "https://github.com/snmsts/trivial-clipboard")
- (synopsis "Access system clipboard in Common Lisp")
- (description
- "@command{trivial-clipboard} gives access to the system clipboard.")
- (license license:expat))))
-
-(define-public cl-trivial-clipboard
- (sbcl-package->cl-source-package sbcl-trivial-clipboard))
-
-(define-public ecl-trivial-clipboard
- (sbcl-package->ecl-package sbcl-trivial-clipboard))
-
-(define-public sbcl-trivial-backtrace
- (let ((commit "ca81c011b86424a381a7563cea3b924f24e6fbeb")
- (revision "1"))
- (package
- (name "sbcl-trivial-backtrace")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/gwkkwg/trivial-backtrace.git")
- (commit commit)))
- (file-name (git-file-name "trivial-backtrace" version))
- (sha256
- (base32 "10p41p43skj6cimdg8skjy7372s8v2xpkg8djjy0l8rm45i654k1"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("sbcl-lift" ,sbcl-lift)))
- (home-page "https://common-lisp.net/project/trivial-backtrace/")
- (synopsis "Portable simple API to work with backtraces in Common Lisp")
- (description
- "On of the many things that didn't quite get into the Common Lisp
-standard was how to get a Lisp to output its call stack when something has
-gone wrong. As such, each Lisp has developed its own notion of what to
-display, how to display it, and what sort of arguments can be used to
-customize it. @code{trivial-backtrace} is a simple solution to generating a
-backtrace portably.")
- (license license:expat))))
-
-(define-public cl-trivial-backtrace
- (sbcl-package->cl-source-package sbcl-trivial-backtrace))
-
-(define-public sbcl-rfc2388
- (let ((commit "591bcf7e77f2c222c43953a80f8c297751dc0c4e")
- (revision "1"))
- (package
- (name "sbcl-rfc2388")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/jdz/rfc2388.git")
- (commit commit)))
- (file-name (git-file-name "rfc2388" version))
- (sha256
- (base32 "0phh5n3clhl9ji8jaxrajidn22d3f0aq87mlbfkkxlnx2pnw694k"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://github.com/jdz/rfc2388/")
- (synopsis "An implementation of RFC 2388 in Common Lisp")
- (description
- "This package contains an implementation of RFC 2388, which is used to
-process form data posted with HTTP POST method using enctype
-\"multipart/form-data\".")
- (license license:bsd-2))))
-
-(define-public cl-rfc2388
- (sbcl-package->cl-source-package sbcl-rfc2388))
-
-(define-public sbcl-md5
- (package
- (name "sbcl-md5")
- (version "2.0.4")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://github.com/pmai/md5/archive/release-" version ".tar.gz"))
- (sha256
- (base32 "19yl9n0pjdz5gw4qi711lka97xcd9f81ylg434hk7jwn9f2s6w11"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://github.com/pmai/md5")
- (synopsis
- "Common Lisp implementation of the MD5 Message-Digest Algorithm (RFC 1321)")
- (description
- "This package implements The MD5 Message-Digest Algorithm, as defined in
-RFC 1321 by R. Rivest, published April 1992.")
- (license license:public-domain)))
-
-(define-public cl-md5
- (sbcl-package->cl-source-package sbcl-md5))
-
-(define-public sbcl-cl+ssl
- (let ((commit "141ae91416bc40f1618dc07e48429b84388aa599")
- (revision "1"))
- (package
- (name "sbcl-cl+ssl")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/cl-plus-ssl/cl-plus-ssl.git")
- (commit commit)))
- (file-name (git-file-name "cl+ssl" version))
- (sha256
- (base32 "1s0hg1h9sf8q89v0yrxmzg5f5sng29rgx3n21r9h9yql8351myan"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/reload.lisp"
- (("libssl.so" all)
- (string-append
- (assoc-ref inputs "openssl") "/lib/" all))))))))
- (inputs
- `(("openssl" ,openssl)
- ("sbcl-cffi" ,sbcl-cffi)
- ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)
- ("sbcl-flexi-streams" ,sbcl-flexi-streams)
- ("sbcl-bordeaux-threads" ,sbcl-bordeaux-threads)
- ("sbcl-trivial-garbage" ,sbcl-trivial-garbage)
- ("sbcl-alexandria" ,sbcl-alexandria)
- ("sbcl-trivial-features" ,sbcl-trivial-features)))
- (home-page "http://common-lisp.net/project/cl-plus-ssl/")
- (synopsis "Common Lisp bindings to OpenSSL")
- (description
- "This library is a fork of SSL-CMUCL. The original SSL-CMUCL source
-code was written by Eric Marsden and includes contributions by Jochen Schmidt.
-Development into CL+SSL was done by David Lichteblau.")
- (license license:expat))))
-
-(define-public cl-cl+ssl
- (sbcl-package->cl-source-package sbcl-cl+ssl))
-
-(define-public sbcl-kmrcl
- (let ((version "1.109.0")
- (commit "5260068b2eb735af6796740c2db4955afac21636")
- (revision "1"))
- (package
- (name "sbcl-kmrcl")
- (version (git-version version revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "http://git.kpe.io/kmrcl.git/")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "1va7xjgzfv674bpsli674i7zj3f7wg5kxic41kz18r6hh4n52dfv"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- ;; Tests fail with: :FORCE and :FORCE-NOT arguments not allowed in a
- ;; nested call to ASDF/OPERATE:OPERATE unless identically to toplevel
- '(#:tests? #f))
- (inputs
- `(("sbcl-rt" ,sbcl-rt)))
- (home-page "http://files.kpe.io/kmrcl/")
- (synopsis "General utilities for Common Lisp programs")
- (description
- "KMRCL is a collection of utilities used by a number of Kevin
-Rosenberg's CL packages.")
- (license license:llgpl))))
-
-(define-public cl-kmrcl
- (sbcl-package->cl-source-package sbcl-kmrcl))
-
-(define-public sbcl-cl-base64
- (let ((version "3.3.3"))
- (package
- (name "sbcl-cl-base64")
- (version version)
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "http://git.kpe.io/cl-base64.git")
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-base64" version))
- (sha256
- (base32 "1dw6j7n6gsd2qa0p0rbsjxj00acxx3i9ca1qkgl0liy8lpnwkypl"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- ;; Tests fail with: :FORCE and :FORCE-NOT arguments not allowed
- ;; in a nested call to ASDF/OPERATE:OPERATE unless identically
- ;; to toplevel
- '(#:tests? #f))
- (inputs
- `(("sbcl-ptester" ,sbcl-ptester)
- ("sbcl-kmrcl" ,sbcl-kmrcl)))
- (home-page "http://files.kpe.io/cl-base64/")
- (synopsis
- "Common Lisp package to encode and decode base64 with URI support")
- (description
- "This package provides highly optimized base64 encoding and decoding.
-Besides conversion to and from strings, integer conversions are supported.
-Encoding with Uniform Resource Identifiers is supported by using a modified
-encoding table that uses only URI-compatible characters.")
- (license license:bsd-3))))
-
-(define-public cl-base64
- (sbcl-package->cl-source-package sbcl-cl-base64))
-
-(define-public sbcl-chunga
- (package
- (name "sbcl-chunga")
- (version "1.1.7")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/edicl/chunga.git")
- (commit (string-append "v" version))))
- (file-name (git-file-name name version))
- (sha256
- (base32 "0jzn3nyb3f22gm983rfk99smqs3mhb9ivjmasvhq9qla5cl9pyhd"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)))
- (home-page "https://edicl.github.io/chunga/")
- (synopsis "Portable chunked streams for Common Lisp")
- (description
- "Chunga implements streams capable of chunked encoding on demand as
-defined in RFC 2616.")
- (license license:bsd-2)))
-
-(define-public cl-chunga
- (sbcl-package->cl-source-package sbcl-chunga))
-
-(define-public sbcl-cl-who
- (let ((version "1.1.4")
- (commit "2c08caa4bafba720409af9171feeba3f32e86d32")
- (revision "1"))
- (package
- (name "sbcl-cl-who")
- (version (git-version version revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/edicl/cl-who.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "0yjb6sr3yazm288m318kqvj9xk8rm9n1lpimgf65ymqv0i5agxsb"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- `(("sbcl-flexi-streams" ,sbcl-flexi-streams)))
- (home-page "https://edicl.github.io/cl-who/")
- (synopsis "Yet another Lisp markup language")
- (description
- "There are plenty of Lisp Markup Languages out there - every Lisp
-programmer seems to write at least one during his career - and CL-WHO (where
-WHO means \"with-html-output\" for want of a better acronym) is probably just
-as good or bad as the next one.")
- (license license:bsd-2))))
-
-(define-public cl-cl-who
- (sbcl-package->cl-source-package sbcl-cl-who))
-
-(define-public sbcl-chipz
- (let ((version "0.8")
- (commit "75dfbc660a5a28161c57f115adf74c8a926bfc4d")
- (revision "1"))
- (package
- (name "sbcl-chipz")
- (version (git-version version revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/froydnj/chipz.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "0plx4rs39zbs4gjk77h4a2q11zpy75fh9v8hnxrvsf8fnakajhwg"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- `(("sbcl-flexi-streams" ,sbcl-flexi-streams)))
- (home-page "http://method-combination.net/lisp/chipz/")
- (synopsis
- "Common Lisp library for decompressing deflate, zlib, gzip, and bzip2
-data")
- (description
- "DEFLATE data, defined in RFC1951, forms the core of popular
-compression formats such as zlib (RFC 1950) and gzip (RFC 1952). As such,
-Chipz also provides for decompressing data in those formats as well. BZIP2 is
-the format used by the popular compression tool bzip2.")
- ;; The author describes it as "MIT-like"
- (license license:expat))))
-
-(define-public cl-chipz
- (sbcl-package->cl-source-package sbcl-chipz))
-
-(define-public sbcl-drakma
- (let ((version "2.0.4")
- (commit "7647c0ae842ff2058624e53979c7f297760c97a7")
- (revision "1"))
- (package
- (name "sbcl-drakma")
- (version (git-version version revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/edicl/drakma.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "1c4i9wakhj5pxfyyykxshdmv3180sbkrx6fcyynikmc0jd0rh84r"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("sbcl-puri" ,sbcl-puri)
- ("sbcl-cl-base64" ,sbcl-cl-base64)
- ("sbcl-chunga" ,sbcl-chunga)
- ("sbcl-flexi-streams" ,sbcl-flexi-streams)
- ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
- ("sbcl-chipz" ,sbcl-chipz)
- ("sbcl-usocket" ,sbcl-usocket)
- ("sbcl-cl+ssl" ,sbcl-cl+ssl)))
- (native-inputs
- `(("sbcl-fiveam" ,sbcl-fiveam)))
- (home-page "https://edicl.github.io/drakma/")
- (synopsis "HTTP client written in Common Lisp")
- (description
- "Drakma is a full-featured HTTP client implemented in Common Lisp. It
-knows how to handle HTTP/1.1 chunking, persistent connections, re-usable
-sockets, SSL, continuable uploads, file uploads, cookies, and more.")
- (license license:bsd-2))))
-
-(define-public cl-drakma
- (sbcl-package->cl-source-package sbcl-drakma))
-
-(define-public sbcl-hunchentoot
- (package
- (name "sbcl-hunchentoot")
- (version "1.2.38")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/edicl/hunchentoot.git")
- (commit (string-append "v" version))))
- (file-name (git-file-name "hunchentoot" version))
- (sha256
- (base32 "1anpcad7w045m4rsjs1f3xdhjwx5cppq1h0vlb3q7dz81fi3i6yq"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- `(("sbcl-cl-who" ,sbcl-cl-who)
- ("sbcl-drakma" ,sbcl-drakma)))
- (inputs
- `(("sbcl-chunga" ,sbcl-chunga)
- ("sbcl-cl-base64" ,sbcl-cl-base64)
- ("sbcl-cl-fad" ,sbcl-cl-fad)
- ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
- ("sbcl-flexi-streams" ,sbcl-flexi-streams)
- ("sbcl-cl+ssl" ,sbcl-cl+ssl)
- ("sbcl-md5" ,sbcl-md5)
- ("sbcl-rfc2388" ,sbcl-rfc2388)
- ("sbcl-trivial-backtrace" ,sbcl-trivial-backtrace)
- ("sbcl-usocket" ,sbcl-usocket)))
- (home-page "https://edicl.github.io/hunchentoot/")
- (synopsis "Web server written in Common Lisp")
- (description
- "Hunchentoot is a web server written in Common Lisp and at the same
-time a toolkit for building dynamic websites. As a stand-alone web server,
-Hunchentoot is capable of HTTP/1.1 chunking (both directions), persistent
-connections (keep-alive), and SSL.")
- (license license:bsd-2)))
-
-(define-public cl-hunchentoot
- (sbcl-package->cl-source-package sbcl-hunchentoot))
-
-(define-public sbcl-trivial-types
- (package
- (name "sbcl-trivial-types")
- (version "0.0.1")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/m2ym/trivial-types.git")
- (commit "ee869f2b7504d8aa9a74403641a5b42b16f47d88")))
- (file-name (git-file-name name version))
- (sha256
- (base32 "1s4cp9bdlbn8447q7w7f1wkgwrbvfzp20mgs307l5pxvdslin341"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://github.com/m2ym/trivial-types")
- (synopsis "Trivial type definitions for Common Lisp")
- (description
- "TRIVIAL-TYPES provides missing but important type definitions such as
-PROPER-LIST, ASSOCIATION-LIST, PROPERTY-LIST and TUPLE.")
- (license license:llgpl)))
-
-(define-public cl-trivial-types
- (sbcl-package->cl-source-package sbcl-trivial-types))
-
-(define-public sbcl-cl-syntax
- (package
- (name "sbcl-cl-syntax")
- (version "0.0.3")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/m2ym/cl-syntax.git")
- (commit "03f0c329bbd55b8622c37161e6278366525e2ccc")))
- (file-name (git-file-name "cl-syntax" version))
- (sha256
- (base32 "17ran8xp77asagl31xv8w819wafh6whwfc9p6dgx22ca537gyl4y"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-file "cl-syntax.asd"
- #:asd-system-name "cl-syntax"))
- (inputs `(("sbcl-trivial-types" ,sbcl-trivial-types)
- ("sbcl-named-readtables" ,sbcl-named-readtables)))
- (home-page "https://github.com/m2ym/cl-syntax")
- (synopsis "Reader Syntax Coventions for Common Lisp and SLIME")
- (description
- "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp and SLIME.")
- (license license:llgpl)))
-
-(define-public cl-syntax
- (sbcl-package->cl-source-package sbcl-cl-syntax))
-
-(define-public sbcl-cl-annot
- (let ((commit "c99e69c15d935eabc671b483349a406e0da9518d")
- (revision "1"))
- (package
- (name "sbcl-cl-annot")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/m2ym/cl-annot.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "1wq1gs9jjd5m6iwrv06c2d7i5dvqsfjcljgbspfbc93cg5xahk4n"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-file "cl-annot.asd"
- #:asd-system-name "cl-annot"))
- (inputs
- `(("sbcl-alexandria" ,sbcl-alexandria)))
- (home-page "https://github.com/m2ym/cl-annot")
- (synopsis "Python-like Annotation Syntax for Common Lisp.")
- (description
- "@code{cl-annot} is an general annotation library for Common Lisp.")
- (license license:llgpl))))
-
-(define-public cl-annot
- (sbcl-package->cl-source-package sbcl-cl-annot))
-
-(define-public sbcl-cl-syntax-annot
- (package
- (name "sbcl-cl-syntax-annot")
- (version "0.0.3")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/m2ym/cl-syntax.git")
- (commit "03f0c329bbd55b8622c37161e6278366525e2ccc")))
- (file-name (git-file-name name version))
- (sha256
- (base32 "17ran8xp77asagl31xv8w819wafh6whwfc9p6dgx22ca537gyl4y"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-file "cl-syntax-annot.asd"
- #:asd-system-name "cl-syntax-annot"))
- (inputs
- `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
- ("sbcl-cl-annot" ,sbcl-cl-annot)))
- (home-page "https://github.com/m2ym/cl-syntax")
- (synopsis "Reader Syntax Coventions for Common Lisp and SLIME")
- (description
- "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp and
-SLIME.")
- (license license:llgpl)))
-
-(define-public cl-syntax-annot
- (sbcl-package->cl-source-package sbcl-cl-syntax-annot))
-
-(define-public sbcl-cl-utilities
- (let ((commit "dce2d2f6387091ea90357a130fa6d13a6776884b")
- (revision "1"))
- (package
- (name "sbcl-cl-utilities")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method url-fetch)
- (uri
- (string-append
- "https://gitlab.common-lisp.net/cl-utilities/cl-utilities/-/"
- "archive/" commit "/cl-utilities-" commit ".tar.gz"))
- (sha256
- (base32 "1r46v730yf96nk2vb24qmagv9x96xvd08abqwhf02ghgydv1a7z2"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-file "cl-utilities.asd"
- #:asd-system-name "cl-utilities"
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "rotate-byte.lisp"
- (("in-package :cl-utilities)" all)
- "in-package :cl-utilities)\n\n#+sbcl\n(require :sb-rotate-byte)")))))))
- (home-page "http://common-lisp.net/project/cl-utilities")
- (synopsis "A collection of semi-standard utilities")
- (description
- "On Cliki.net <http://www.cliki.net/Common%20Lisp%20Utilities>, there
-is a collection of Common Lisp Utilities, things that everybody writes since
-they're not part of the official standard. There are some very useful things
-there; the only problems are that they aren't implemented as well as you'd
-like (some aren't implemented at all) and they aren't conveniently packaged
-and maintained. It takes quite a bit of work to carefully implement utilities
-for common use, commented and documented, with error checking placed
-everywhere some dumb user might make a mistake.")
- (license license:public-domain))))
-
-(define-public cl-utilities
- (sbcl-package->cl-source-package sbcl-cl-utilities))
-
-(define-public sbcl-map-set
- (let ((commit "7b4b545b68b8")
- (revision "1"))
- (package
- (name "sbcl-map-set")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://bitbucket.org/tarballs_are_good/map-set/get/"
- commit ".tar.gz"))
- (sha256
- (base32 "1sx5j5qdsy5fklspfammwb16kjrhkggdavm922a9q86jm5l0b239"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://bitbucket.org/tarballs_are_good/map-set")
- (synopsis "Set-like data structure")
- (description
- "Implementation of a set-like data structure with constant time
-addition, removal, and random selection.")
- (license license:bsd-3))))
-
-(define-public cl-map-set
- (sbcl-package->cl-source-package sbcl-map-set))
-
-(define-public sbcl-quri
- (let ((commit "76b75103f21ead092c9f715512fa82441ef61185")
- (revision "1"))
- (package
- (name "sbcl-quri")
- (version (git-version "0.1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/quri.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "1ccbxsgzdibmzq33mmbmmz9vwl6l03xh6nbpsh1hkdvdcl7q0a60"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- ;; Tests fail with: Component QURI-ASD::QURI-TEST not found,
- ;; required by #<SYSTEM "quri">. Why?
- '(#:tests? #f))
- (native-inputs `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
- ("sbcl-prove" ,sbcl-prove)))
- (inputs `(("sbcl-babel" ,sbcl-babel)
- ("sbcl-split-sequence" ,sbcl-split-sequence)
- ("sbcl-cl-utilities" ,sbcl-cl-utilities)
- ("sbcl-alexandria" ,sbcl-alexandria)))
- (home-page "https://github.com/fukamachi/quri")
- (synopsis "Yet another URI library for Common Lisp")
- (description
- "QURI (pronounced \"Q-ree\") is yet another URI library for Common
-Lisp. It is intended to be a replacement of PURI.")
- (license license:bsd-3))))
-
-(define-public cl-quri
- (sbcl-package->cl-source-package sbcl-quri))
-
-(define-public sbcl-myway
- (let ((commit "286230082a11f879c18b93f17ca571c5f676bfb7")
- (revision "1"))
- (package
- (name "sbcl-myway")
- (version (git-version "0.1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/myway.git")
- (commit commit)))
- (file-name (git-file-name "myway" version))
- (sha256
- (base32 "0briia9bk3lbr0frnx39d1qg6i38dm4j6z9w3yga3d40k6df4a90"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- ;; Tests fail with: Component MYWAY-ASD::MYWAY-TEST not found, required
- ;; by #<SYSTEM "myway">. Why?
- '(#:tests? #f))
- (native-inputs
- `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
- ("sbcl-prove" ,sbcl-prove)))
- (inputs
- `(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
- ("sbcl-quri" ,sbcl-quri)
- ("sbcl-map-set" ,sbcl-map-set)))
- (home-page "https://github.com/fukamachi/myway")
- (synopsis "Sinatra-compatible URL routing library for Common Lisp")
- (description "My Way is a Sinatra-compatible URL routing library.")
- (license license:llgpl))))
-
-(define-public cl-myway
- (sbcl-package->cl-source-package sbcl-myway))
-
-(define-public sbcl-xsubseq
- (let ((commit "5ce430b3da5cda3a73b9cf5cee4df2843034422b")
- (revision "1"))
- (package
- (name "sbcl-xsubseq")
- (version (git-version "0.0.1" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/xsubseq")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "1xz79q0p2mclf3sqjiwf6izdpb6xrsr350bv4mlmdlm6rg5r99px"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- ;; Tests fail with: Component XSUBSEQ-ASD::XSUBSEQ-TEST not found,
- ;; required by #<SYSTEM "xsubseq">. Why?
- '(#:tests? #f))
- (native-inputs
- `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
- ("sbcl-prove" ,sbcl-prove)))
- (home-page "https://github.com/fukamachi/xsubseq")
- (synopsis "Efficient way to use \"subseq\"s in Common Lisp")
- (description
- "XSubseq provides functions to be able to handle \"subseq\"s more
-effieiently.")
- (license license:bsd-2))))
-
-(define-public cl-xsubseq
- (sbcl-package->cl-source-package sbcl-xsubseq))
-
-(define-public sbcl-smart-buffer
- (let ((commit "09b9a9a0b3abaa37abe9a730f5aac2643dca4e62")
- (revision "1"))
- (package
- (name "sbcl-smart-buffer")
- (version (git-version "0.0.1" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/smart-buffer")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "0qz1zzxx0wm5ff7gpgsq550a59p0qj594zfmm2rglj97dahj54l7"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- ;; Tests fail with: Component SMART-BUFFER-ASD::SMART-BUFFER-TEST not
- ;; found, required by #<SYSTEM "smart-buffer">. Why?
- `(#:tests? #f))
- (native-inputs
- `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
- ("sbcl-prove" ,sbcl-prove)))
- (inputs
- `(("sbcl-xsubseq" ,sbcl-xsubseq)
- ("sbcl-flexi-streams" ,sbcl-flexi-streams)))
- (home-page "https://github.com/fukamachi/smart-buffer")
- (synopsis "Smart octets buffer")
- (description
- "Smart-buffer provides an output buffer which changes the destination
-depending on content size.")
- (license license:bsd-3))))
-
-(define-public cl-smart-buffer
- (sbcl-package->cl-source-package sbcl-smart-buffer))
-
-(define-public sbcl-fast-http
- (let ((commit "f9e7597191bae380503e20724fd493a24d024935")
- (revision "1"))
- (package
- (name "sbcl-fast-http")
- (version (git-version "0.2.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/fast-http")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "0qdmwv2zm0sizxdb8nnclgwl0nfjcbjaimbakavikijw7lr9b4jp"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- ;; Tests fail with: Component FAST-HTTP-ASD::FAST-HTTP-TEST not found,
- ;; required by #<SYSTEM "fast-http">. Why?
- `(#:tests? #f))
- (native-inputs
- `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
- ("sbcl-prove" ,sbcl-prove)))
- (inputs
- `(("sbcl-alexandria" ,sbcl-alexandria)
- ("sbcl-proc-parse" ,sbcl-proc-parse)
- ("sbcl-xsubseq" ,sbcl-xsubseq)
- ("sbcl-smart-buffer" ,sbcl-smart-buffer)
- ("sbcl-cl-utilities" ,sbcl-cl-utilities)))
- (home-page "https://github.com/fukamachi/fast-http")
- (synopsis "HTTP request/response parser for Common Lisp")
- (description
- "@code{fast-http} is a HTTP request/response protocol parser for Common
-Lisp.")
- ;; Author specified the MIT license
- (license license:expat))))
-
-(define-public cl-fast-http
- (sbcl-package->cl-source-package sbcl-fast-http))
-
-(define-public sbcl-static-vectors
- (let ((commit "0681eac1f49370cde03e64b077251e8abf47d702")
- (revision "1"))
- (package
- (name "sbcl-static-vectors")
- (version (git-version "1.8.3" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/sionescu/static-vectors.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "138nlsq14hv8785ycjm6jw3i6ablhq8vcwys7q09y80arcgrg6r3"))))
- (native-inputs
- `(("sbcl-fiveam" ,sbcl-fiveam)))
- (inputs
- `(("sbcl-cffi-grovel" ,sbcl-cffi-grovel)
- ("sbcl-cffi" ,sbcl-cffi)))
- (build-system asdf-build-system/sbcl)
- (home-page "http://common-lisp.net/projects/iolib/")
- (synopsis "Allocate SIMPLE-ARRAYs in static memory")
- (description
- "With @code{static-vectors}, you can create vectors allocated in static
-memory.")
- (license license:expat))))
-
-(define-public cl-static-vectors
- (sbcl-package->cl-source-package sbcl-static-vectors))
-
-(define-public sbcl-marshal
- (let ((commit "eff1b15f2b0af2f26f71ad6a4dd5c4beab9299ec")
- (revision "1"))
- (package
- (name "sbcl-marshal")
- (version (git-version "1.3.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/wlbr/cl-marshal.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "08qs6fhk38xpkkjkpcj92mxx0lgy4ygrbbzrmnivdx281syr0gwh"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://github.com/wlbr/cl-marshal")
- (synopsis "Simple (de)serialization of Lisp datastructures")
- (description
- "Simple and fast marshalling of Lisp datastructures. Convert any object
-into a string representation, put it on a stream an revive it from there.
-Only minimal changes required to make your CLOS objects serializable.")
- (license license:expat))))
-
-(define-public cl-marshal
- (sbcl-package->cl-source-package sbcl-marshal))
-
-(define-public sbcl-checkl
- (let ((commit "80328800d047fef9b6e32dfe6bdc98396aee3cc9")
- (revision "1"))
- (package
- (name "sbcl-checkl")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/rpav/CheckL.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "0bpisihx1gay44xmyr1dmhlwh00j0zzi04rp9fy35i95l2r4xdlx"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- ;; Error while trying to load definition for system checkl-test from
- ;; pathname [...]/checkl-test.asd: The function CHECKL:DEFINE-TEST-OP
- ;; is undefined.
- '(#:tests? #f))
- (native-inputs
- `(("sbcl-fiveam" ,sbcl-fiveam)))
- (inputs
- `(("sbcl-marshal" ,sbcl-marshal)))
- (home-page "https://github.com/rpav/CheckL/")
- (synopsis "Dynamic testing for Common Lisp")
- (description
- "CheckL lets you write tests dynamically, it checks resulting values
-against the last run.")
- ;; The author specifies both LLGPL and "BSD", but the "BSD" license
- ;; isn't specified anywhere, so I don't know which kind. LLGPL is the
- ;; stronger of the two and so I think only listing this should suffice.
- (license license:llgpl))))
-
-(define-public cl-checkl
- (sbcl-package->cl-source-package sbcl-checkl))
-
-(define-public sbcl-fast-io
- (let ((commit "dc3a71db7e9b756a88781ae9c342fe9d4bbab51c")
- (revision "1"))
- (package
- (name "sbcl-fast-io")
- (version (git-version "1.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/rpav/fast-io.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "1jsp6xvi26ln6fdy5j5zi05xvan8jsqdhisv552dy6xg6ws8i1yq"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- ;; Error while trying to load definition for system fast-io-test from
- ;; pathname [...]/fast-io-test.asd: The function CHECKL:DEFINE-TEST-OP
- ;; is undefined.
- '(#:tests? #f))
- (native-inputs
- `(("sbcl-fiveam" ,sbcl-fiveam)
- ("sbcl-checkl" ,sbcl-checkl)))
- (inputs
- `(("sbcl-alexandria" ,sbcl-alexandria)
- ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)
- ("sbcl-static-vectors" ,sbcl-static-vectors)))
- (home-page "https://github.com/rpav/fast-io")
- (synopsis "Fast octet-vector/stream I/O for Common Lisp")
- (description
- "Fast-io is about improving performance to octet-vectors and octet
-streams (though primarily the former, while wrapping the latter).")
- ;; Author specifies this as NewBSD which is an alias
- (license license:bsd-3))))
-
-(define-public cl-fast-io
- (sbcl-package->cl-source-package sbcl-fast-io))
-
-(define-public sbcl-jonathan
- (let ((commit "1f448b4f7ac8265e56e1c02b32ce383e65316300")
- (revision "1"))
- (package
- (name "sbcl-jonathan")
- (version (git-version "0.1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Rudolph-Miller/jonathan.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "14x4iwz3mbag5jzzzr4sb6ai0m9r4q4kyypbq32jmsk2dx1hi807"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- ;; Tests fail with: Component JONATHAN-ASD::JONATHAN-TEST not found,
- ;; required by #<SYSTEM "jonathan">. Why?
- `(#:tests? #f))
- (native-inputs
- `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
- ("sbcl-prove" ,sbcl-prove)))
- (inputs
- `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
- ("sbcl-cl-syntax-annot" ,sbcl-cl-syntax-annot)
- ("sbcl-fast-io" ,sbcl-fast-io)
- ("sbcl-proc-parse" ,sbcl-proc-parse)
- ("sbcl-cl-ppcre" ,sbcl-cl-ppcre)))
- (home-page "http://rudolph-miller.github.io/jonathan/overview.html")
- (synopsis "JSON encoder and decoder")
- (description
- "High performance JSON encoder and decoder. Currently support: SBCL,
-CCL.")
- ;; Author specifies the MIT license
- (license license:expat))))
-
-(define-public cl-jonathan
- (sbcl-package->cl-source-package sbcl-jonathan))
-
-(define-public sbcl-http-body
- (let ((commit "dd01dc4f5842e3d29728552e5163acce8386eb73")
- (revision "1"))
- (package
- (name "sbcl-http-body")
- (version (git-version "0.1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/http-body")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "1jd06snjvxcprhapgfq8sx0y5lrldkvhf206ix6d5a23dd6zcmr0"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- ;; Tests fail with: Component HTTP-BODY-ASD::HTTP-BODY-TEST not
- ;; found, required by #<SYSTEM "http-body">. Why?
- `(#:tests? #f))
- (native-inputs
- `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
- ("sbcl-prove" ,sbcl-prove)))
- (inputs
- `(("sbcl-fast-http" ,sbcl-fast-http)
- ("sbcl-jonathan" ,sbcl-jonathan)
- ("sbcl-quri" ,sbcl-quri)))
- (home-page "https://github.com/fukamachi/http-body")
- (synopsis "HTTP POST data parser")
- (description
- "HTTP-Body parses HTTP POST data and returns POST parameters. It
-supports application/x-www-form-urlencoded, application/json, and
-multipart/form-data.")
- (license license:bsd-2))))
-
-(define-public cl-http-body
- (sbcl-package->cl-source-package sbcl-http-body))
-
-(define-public sbcl-circular-streams
- (let ((commit "e770bade1919c5e8533dd2078c93c3d3bbeb38df")
- (revision "1"))
- (package
- (name "sbcl-circular-streams")
- (version (git-version "0.1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/circular-streams")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "1wpw6d5cciyqcf92f7mvihak52pd5s47kk4qq6f0r2z2as68p5rs"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- ;; The tests depend on cl-test-more which is now prove. Prove
- ;; tests aren't working for some reason.
- `(#:tests? #f))
- (inputs
- `(("sbcl-fast-io" ,sbcl-fast-io)
- ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)))
- (home-page "https://github.com/fukamachi/circular-streams")
- (synopsis "Circularly readable streams for Common Lisp")
- (description
- "Circular-Streams allows you to read streams circularly by wrapping real
-streams. Once you reach end-of-file of a stream, it's file position will be
-reset to 0 and you're able to read it again.")
- (license license:llgpl))))
-
-(define-public cl-circular-streams
- (sbcl-package->cl-source-package sbcl-circular-streams))
-
-(define-public sbcl-lack-request
- (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
- (revision "1"))
- (package
- (name "sbcl-lack-request")
- (version (git-version "0.1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/lack.git")
- (commit commit)))
- (file-name (git-file-name "lack-request" version))
- (sha256
- (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-file "lack-request.asd"
- #:asd-system-name "lack-request"
- #:test-asd-file "t-lack-request.asd"
- ;; XXX: Component :CLACK-TEST not found
- #:tests? #f))
- (native-inputs
- `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
- ("sbcl-prove" ,sbcl-prove)))
- (inputs
- `(("sbcl-quri" ,sbcl-quri)
- ("sbcl-http-body" ,sbcl-http-body)
- ("sbcl-circular-streams" ,sbcl-circular-streams)))
- (home-page "https://github.com/fukamachi/lack")
- (synopsis "Lack, the core of Clack")
- (description
- "Lack is a Common Lisp library which allows web applications to be
-constructed of modular components. It was originally a part of Clack, however
-it's going to be rewritten as an individual project since Clack v2 with
-performance and simplicity in mind.")
- (license license:llgpl))))
-
-(define-public cl-lack-request
- (sbcl-package->cl-source-package sbcl-lack-request))
-
-(define-public sbcl-local-time
- (let ((commit "beac054eef428552b63d4ae7820c32ffef9a3015")
- (revision "1"))
- (package
- (name "sbcl-local-time")
- (version (git-version "1.0.6" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/dlowe-net/local-time.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "0xhkmgxh41dg2wwlsp0h2l41jp144xn4gpxhh0lna6kh0560w2cc"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- ;; TODO: Component :STEFIL not found, required by #<SYSTEM
- ;; "local-time/test">
- '(#:tests? #f))
- (native-inputs
- `(("stefil" ,sbcl-hu.dwim.stefil)))
- (inputs
- `(("sbcl-cl-fad" ,sbcl-cl-fad)))
- (home-page "https://common-lisp.net/project/local-time/")
- (synopsis "Time manipulation library for Common Lisp")
- (description
- "The LOCAL-TIME library is a Common Lisp library for the manipulation of
-dates and times. It is based almost entirely upon Erik Naggum's paper \"The
-Long Painful History of Time\".")
- (license license:expat))))
-
-(define-public cl-local-time
- (sbcl-package->cl-source-package sbcl-local-time))
-
-(define-public sbcl-lack-response
- (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
- (revision "1"))
- (package
- (name "sbcl-lack-response")
- (version (git-version "0.1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/lack.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-file "lack-response.asd"
- #:asd-system-name "lack-response"
- ;; XXX: no tests for lack-response.
- #:tests? #f))
- (native-inputs
- `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
- ("sbcl-prove" ,sbcl-prove)))
- (inputs
- `(("sbcl-quri" ,sbcl-quri)
- ("sbcl-http-body" ,sbcl-http-body)
- ("sbcl-circular-streams" ,sbcl-circular-streams)
- ("sbcl-local-time" ,sbcl-local-time)))
- (home-page "https://github.com/fukamachi/lack")
- (synopsis "Lack, the core of Clack")
- (description
- "Lack is a Common Lisp library which allows web applications to be
-constructed of modular components. It was originally a part of Clack, however
-it's going to be rewritten as an individual project since Clack v2 with
-performance and simplicity in mind.")
- (license license:llgpl))))
-
-(define-public cl-lack-response
- (sbcl-package->cl-source-package sbcl-lack-response))
-
-(define-public sbcl-lack-component
- (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
- (revision "1"))
- (package
- (name "sbcl-lack-component")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/lack.git")
- (commit commit)))
- (file-name (git-file-name "lack-component" version))
- (sha256
- (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-file "lack-component.asd"
- #:asd-system-name "lack-component"
- #:test-asd-file "t-lack-component.asd"
- ;; XXX: Component :LACK-TEST not found
- #:tests? #f))
- (native-inputs
- `(("prove-asdf" ,sbcl-prove-asdf)))
- (home-page "https://github.com/fukamachi/lack")
- (synopsis "Lack, the core of Clack")
- (description
- "Lack is a Common Lisp library which allows web applications to be
-constructed of modular components. It was originally a part of Clack, however
-it's going to be rewritten as an individual project since Clack v2 with
-performance and simplicity in mind.")
- (license license:llgpl))))
-
-(define-public cl-lack-component
- (sbcl-package->cl-source-package sbcl-lack-component))
-
-(define-public sbcl-lack-util
- (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
- (revision "1"))
- (package
- (name "sbcl-lack-util")
- (version (git-version "0.1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/lack.git")
- (commit commit)))
- (file-name (git-file-name "lack-util" version))
- (sha256
- (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-file "lack-util.asd"
- #:asd-system-name "lack-util"
- #:test-asd-file "t-lack-util.asd"
- ;; XXX: Component :LACK-TEST not found
- #:tests? #f))
- (native-inputs
- `(("prove-asdf" ,sbcl-prove-asdf)))
- (inputs
- `(("sbcl-ironclad" ,sbcl-ironclad)))
- (home-page "https://github.com/fukamachi/lack")
- (synopsis "Lack, the core of Clack")
- (description
- "Lack is a Common Lisp library which allows web applications to be
-constructed of modular components. It was originally a part of Clack, however
-it's going to be rewritten as an individual project since Clack v2 with
-performance and simplicity in mind.")
- (license license:llgpl))))
-
-(define-public cl-lack-util
- (sbcl-package->cl-source-package sbcl-lack-util))
-
-(define-public sbcl-lack-middleware-backtrace
- (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
- (revision "1"))
- (package
- (name "sbcl-lack-middleware-backtrace")
- (version (git-version "0.1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/lack.git")
- (commit commit)))
- (file-name (git-file-name "lack-middleware-backtrace" version))
- (sha256
- (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-file "lack-middleware-backtrace.asd"
- #:asd-system-name "lack-middleware-backtrace"
- #:test-asd-file "t-lack-middleware-backtrace.asd"
- ;; XXX: Component :LACK not found
- #:tests? #f))
- (native-inputs
- `(("prove-asdf" ,sbcl-prove-asdf)))
- (home-page "https://github.com/fukamachi/lack")
- (synopsis "Lack, the core of Clack")
- (description
- "Lack is a Common Lisp library which allows web applications to be
-constructed of modular components. It was originally a part of Clack, however
-it's going to be rewritten as an individual project since Clack v2 with
-performance and simplicity in mind.")
- (license license:llgpl))))
-
-(define-public cl-lack-middleware-backtrace
- (sbcl-package->cl-source-package sbcl-lack-middleware-backtrace))
-
-(define-public sbcl-trivial-mimes
- (let ((commit "303f8ac0aa6ca0bc139aa3c34822e623c3723fab")
- (revision "1"))
- (package
- (name "sbcl-trivial-mimes")
- (version (git-version "1.1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Shinmera/trivial-mimes.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "17jxgl47r695bvsb7wi3n2ws5rp1zzgvw0zii8cy5ggw4b4ayv6m"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:phases
- (modify-phases %standard-phases
- (add-after
- 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (let ((anchor "#p\"/etc/mime.types\""))
- (substitute* "mime-types.lisp"
- ((anchor all)
- (string-append
- anchor "\n"
- "(asdf:system-relative-pathname :trivial-mimes "
- "\"../../share/common-lisp/" (%lisp-type)
- "-source/trivial-mimes/mime.types\")")))))))))
- (native-inputs
- `(("stefil" ,sbcl-hu.dwim.stefil)))
- (inputs
- `(("sbcl-cl-fad" ,sbcl-cl-fad)))
- (home-page "http://shinmera.github.io/trivial-mimes/")
- (synopsis "Tiny Common Lisp library to detect mime types in files")
- (description
- "This is a teensy library that provides some functions to determine the
-mime-type of a file.")
- (license license:artistic2.0))))
-
-(define-public cl-trivial-mimes
- (sbcl-package->cl-source-package sbcl-trivial-mimes))
-
-(define-public ecl-trivial-mimes
- (sbcl-package->ecl-package sbcl-trivial-mimes))
-
-(define-public sbcl-lack-middleware-static
- (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
- (revision "1"))
- (package
- (name "sbcl-lack-middleware-static")
- (version (git-version "0.1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/lack.git")
- (commit commit)))
- (file-name (git-file-name "lack-middleware-static" version))
- (sha256
- (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-file "lack-middleware-static.asd"
- #:asd-system-name "lack-middleware-static"
- #:test-asd-file "t-lack-middleware-static.asd"
- ;; XXX: Component :LACK not found
- #:tests? #f))
- (native-inputs
- `(("prove-asdf" ,sbcl-prove-asdf)))
- (inputs
- `(("sbcl-ironclad" ,sbcl-ironclad)
- ("sbcl-trivial-mimes" ,sbcl-trivial-mimes)
- ("sbcl-local-time" ,sbcl-local-time)))
- (home-page "https://github.com/fukamachi/lack")
- (synopsis "Lack, the core of Clack")
- (description
- "Lack is a Common Lisp library which allows web applications to be
-constructed of modular components. It was originally a part of Clack, however
-it's going to be rewritten as an individual project since Clack v2 with
-performance and simplicity in mind.")
- (license license:llgpl))))
-
-(define-public cl-lack-middleware-static
- (sbcl-package->cl-source-package sbcl-lack-middleware-static))
-
-(define-public sbcl-lack
- (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
- (revision "1"))
- (package
- (name "sbcl-lack")
- (version (git-version "0.1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/lack.git")
- (commit commit)))
- (file-name (git-file-name "lack" version))
- (sha256
- (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:test-asd-file "t-lack.asd"
- ;; XXX: Component :CLACK not found
- #:tests? #f))
- (native-inputs
- `(("prove-asdf" ,sbcl-prove-asdf)))
- (inputs
- `(("sbcl-lack-component" ,sbcl-lack-component)
- ("sbcl-lack-util" ,sbcl-lack-util)))
- (home-page "https://github.com/fukamachi/lack")
- (synopsis "Lack, the core of Clack")
- (description
- "Lack is a Common Lisp library which allows web applications to be
-constructed of modular components. It was originally a part of Clack, however
-it's going to be rewritten as an individual project since Clack v2 with
-performance and simplicity in mind.")
- (license license:llgpl))))
-
-(define-public cl-lack
- (sbcl-package->cl-source-package sbcl-lack))
-
-(define-public sbcl-ningle
- (let ((commit "50bd4f09b5a03a7249bd4d78265d6451563b25ad")
- (revision "1"))
- (package
- (name "sbcl-ningle")
- (version (git-version "0.3.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/ningle.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "1bsl8cnxhacb8p92z9n89vhk1ikmij5zavk0m2zvmj7iqm79jzgw"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- ;; TODO: pull in clack-test
- '(#:tests? #f
- #:phases
- (modify-phases %standard-phases
- (delete 'cleanup-files)
- (delete 'cleanup)
- (add-before 'cleanup 'combine-fasls
- (lambda* (#:key outputs #:allow-other-keys)
- (let* ((out (assoc-ref outputs "out"))
- (lib (string-append out "/lib/sbcl"))
- (ningle-path (string-append lib "/ningle"))
- (fasl-files (find-files out "\\.fasl$")))
- (mkdir-p ningle-path)
- (let ((fasl-path (lambda (name)
- (string-append ningle-path
- "/"
- (basename name)
- "--system.fasl"))))
- (for-each (lambda (file)
- (rename-file file
- (fasl-path
- (basename file ".fasl"))))
- fasl-files))
- fasl-files)
- #t)))))
- (native-inputs
- `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
- ("sbcl-prove" ,sbcl-prove)))
- (inputs
- `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
- ("sbcl-cl-syntax-annot" ,sbcl-cl-syntax-annot)
- ("sbcl-myway" ,sbcl-myway)
- ("sbcl-lack-request" ,sbcl-lack-request)
- ("sbcl-lack-response" ,sbcl-lack-response)
- ("sbcl-lack-component" ,sbcl-lack-component)
- ("sbcl-alexandria" ,sbcl-alexandria)
- ("sbcl-babel" ,sbcl-babel)))
- (home-page "http://8arrow.org/ningle/")
- (synopsis "Super micro framework for Common Lisp")
- (description
- "Ningle is a lightweight web application framework for Common Lisp.")
- (license license:llgpl))))
-
-(define-public cl-ningle
- (sbcl-package->cl-source-package sbcl-ningle))
-
-(define-public sbcl-clack
- (let ((commit "e3e032843bb1220ab96263c411aa7f2feb4746e0")
- (revision "1"))
- (package
- (name "sbcl-clack")
- (version (git-version "2.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/clack.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "1ymzs6qyrwhlj6cgqsnpyn6g5cbp7a3s1vgxwna20y2q7y4iacy0"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("sbcl-lack" ,sbcl-lack)
- ("sbcl-lack-middleware-backtrace" ,sbcl-lack-middleware-backtrace)
- ("sbcl-bordeaux-threads" ,sbcl-bordeaux-threads)))
- (home-page "https://github.com/fukamachi/clack")
- (synopsis "Web Application Environment for Common Lisp")
- (description
- "Clack is a web application environment for Common Lisp inspired by
-Python's WSGI and Ruby's Rack.")
- (license license:llgpl))))
-
-(define-public cl-clack
- (sbcl-package->cl-source-package sbcl-clack))
-
-(define-public sbcl-log4cl
- (let ((commit "611e094458504b938d49de904eab141285328c7c")
- (revision "1"))
- (package
- (name "sbcl-log4cl")
- (build-system asdf-build-system/sbcl)
- (version "1.1.2")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/sharplispers/log4cl")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "08jly0s0g26b56hhpfizxsb4j0yvbh946sd205gr42dkzv8l7dsc"))))
- ;; FIXME: tests require stefil, sbcl-hu.dwim.stefil wont work
- (arguments
- `(#:tests? #f))
- (inputs `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
- (synopsis "Common Lisp logging framework, modeled after Log4J")
- (home-page "https://github.com/7max/log4cl")
- (description "This is a Common Lisp logging framework that can log at
-various levels and mix text with expressions.")
- (license license:asl2.0))))
-
-(define-public cl-log4cl
- (sbcl-package->cl-source-package sbcl-log4cl))
-
-(define-public ecl-log4cl
- (sbcl-package->ecl-package sbcl-log4cl))
-
-(define-public sbcl-find-port
- (let ((commit "00c96a25af93a0f8681d34ec548861f2d7485478")
- (revision "1"))
- (package
- (name "sbcl-find-port")
- (build-system asdf-build-system/sbcl)
- (version "0.1")
- (home-page "https://github.com/eudoxia0/find-port")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url home-page)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "0d6dzbb45jh0rx90wgs6v020k2xa87mvzas3mvfzvivjvqqlpryq"))))
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)))
- (inputs
- `(("sbcl-usocket" ,sbcl-usocket)))
- (synopsis "Find open ports programmatically in Common Lisp")
- (description "This is a small Common Lisp library that finds an open
-port within a range.")
- (license license:expat))))
-
-(define-public cl-find-port
- (sbcl-package->cl-source-package sbcl-find-port))
-
-(define-public ecl-find-port
- (sbcl-package->ecl-package sbcl-find-port))
-
(define-public txr
(package
(name "txr")
@@ -5469,2626 +781,3 @@ command line, to data scanning and extracting scripts, to full application
development in a wide-range of areas.")
(home-page "https://nongnu.org/txr/")
(license license:bsd-2)))
-
-(define-public sbcl-clunit
- (let ((commit "6f6d72873f0e1207f037470105969384f8380628")
- (revision "1"))
- (package
- (name "sbcl-clunit")
- (version (git-version "0.2.3" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/tgutu/clunit.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "1idf2xnqzlhi8rbrqmzpmb3i1l6pbdzhhajkmhwbp6qjkmxa4h85"))))
- (build-system asdf-build-system/sbcl)
- (synopsis "CLUnit is a Common Lisp unit testing framework")
- (description
- "CLUnit is a Common Lisp unit testing framework. It is designed
-to be easy to use so that you can quickly start testing. CLUnit
-provides a rich set of features aimed at improving your unit testing
-experience.")
- (home-page "http://tgutu.github.io/clunit/")
- ;; MIT License
- (license license:expat))))
-
-(define-public cl-clunit
- (sbcl-package->cl-source-package sbcl-clunit))
-
-(define-public ecl-clunit
- (sbcl-package->ecl-package sbcl-clunit))
-
-(define-public sbcl-py4cl
- (let ((commit "4c8a2b0814fd311f978964f825ce012290f60136")
- (revision "1"))
- (package
- (name "sbcl-py4cl")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/bendudson/py4cl.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "15mk7qdqjkj56gdnbyrdyz6r7m1h26ldvn6ch96pmvg5vmr1m45r"))
- (modules '((guix build utils)))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- `(("sbcl-clunit" ,sbcl-clunit)))
- (inputs
- `(("sbcl-trivial-garbage" ,sbcl-trivial-garbage)))
- (propagated-inputs
- ;; This package doesn't do anything without python available
- `(("python" ,python)
- ;; For multi-dimensional array support
- ("python-numpy" ,python-numpy)))
- (arguments
- '(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'replace-*base-directory*-var
- (lambda* (#:key outputs #:allow-other-keys)
- ;; In the ASD, the author makes an attempt to
- ;; programatically determine the location of the
- ;; source-code so lisp can call into "py4cl.py". We can
- ;; hard-code this since we know where this file will
- ;; reside.
- (substitute* "src/callpython.lisp"
- (("py4cl/config:\\*base-directory\\*")
- (string-append
- "\""
- (assoc-ref outputs "out")
- "/share/common-lisp/sbcl-source/py4cl/"
- "\""))))))))
- (synopsis "Call python from Common Lisp")
- (description
- "Py4CL is a bridge between Common Lisp and Python, which enables Common
-Lisp to interact with Python code. It uses streams to communicate with a
-separate python process, the approach taken by cl4py. This is different to
-the CFFI approach used by burgled-batteries, but has the same goal.")
- (home-page "https://github.com/bendudson/py4cl")
- ;; MIT License
- (license license:expat))))
-
-(define-public cl-py4cl
- (sbcl-package->cl-source-package sbcl-py4cl))
-
-(define-public ecl-py4cl
- (sbcl-package->ecl-package sbcl-py4cl))
-
-(define-public sbcl-parse-declarations
- (package
- (name "sbcl-parse-declarations")
- (version "1.0.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "http://beta.quicklisp.org/archive/parse-declarations/"
- "2010-10-06/parse-declarations-20101006-darcs.tgz"))
- (sha256
- (base32
- "0r85b0jfacd28kr65kw9c13dx4i6id1dpmby68zjy63mqbnyawrd"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- `(#:asd-file "parse-declarations-1.0.asd"
- #:asd-system-name "parse-declarations-1.0"))
- (home-page "https://common-lisp.net/project/parse-declarations/")
- (synopsis "Parse, filter, and build declarations")
- (description
- "Parse-Declarations is a Common Lisp library to help writing
-macros which establish bindings. To be semantically correct, such
-macros must take user declarations into account, as these may affect
-the bindings they establish. Yet the ANSI standard of Common Lisp does
-not provide any operators to work with declarations in a convenient,
-high-level way. This library provides such operators.")
- ;; MIT License
- (license license:expat)))
-
-(define-public cl-parse-declarations
- (sbcl-package->cl-source-package sbcl-parse-declarations))
-
-(define-public ecl-parse-declarations
- (sbcl-package->ecl-package sbcl-parse-declarations))
-
-(define-public sbcl-cl-quickcheck
- (let ((commit "807b2792a30c883a2fbecea8e7db355b50ba662f")
- (revision "1"))
- (package
- (name "sbcl-cl-quickcheck")
- (version (git-version "0.0.4" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/mcandre/cl-quickcheck.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "165lhypq5xkcys6hvzb3jq7ywnmqvzaflda29qk2cbs3ggas4767"))))
- (build-system asdf-build-system/sbcl)
- (synopsis
- "Common Lisp port of the QuickCheck unit test framework")
- (description
- "Common Lisp port of the QuickCheck unit test framework")
- (home-page "https://github.com/mcandre/cl-quickcheck")
- ;; MIT
- (license license:expat))))
-
-(define-public cl-cl-quickcheck
- (sbcl-package->cl-source-package sbcl-cl-quickcheck))
-
-(define-public ecl-cl-quickcheck
- (sbcl-package->ecl-package sbcl-cl-quickcheck))
-
-(define-public sbcl-burgled-batteries3
- (let ((commit "9c0f6667e1a71ddf77e21793a0bea524710fef6e")
- (revision "1"))
- (package
- (name "sbcl-burgled-batteries3")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/snmsts/burgled-batteries3.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "0b726kz2xxcg5l930gz035rsdvhxrzmp05iwfwympnb4z4ammicb"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:tests? #f
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'set-*cpython-include-dir*-var
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "grovel-include-dir.lisp"
- (("\\(defparameter \\*cpython-include-dir\\* \\(detect-python\\)\\)")
- (string-append
- "(defparameter *cpython-include-dir* \""
- (assoc-ref inputs "python")
- "/include/python3.7m"
- "\")")))
- (substitute* "ffi-interface.lisp"
- (("\\*cpython-lib\\*")
- (format #f "'(\"~a/lib/libpython3.so\")"
- (assoc-ref inputs "python"))))
- #t)))))
- (native-inputs
- `(("python" ,python)
- ("sbcl-cl-fad" ,sbcl-cl-fad)
- ("sbcl-lift" ,sbcl-lift)
- ("sbcl-cl-quickcheck" ,sbcl-cl-quickcheck)))
- (inputs
- `(("sbcl-cffi" ,sbcl-cffi)
- ("sbcl-cffi-grovel" ,sbcl-cffi-grovel)
- ("sbcl-alexandria" , sbcl-alexandria)
- ("sbcl-parse-declarations-1.0" ,sbcl-parse-declarations)
- ("sbcl-trivial-garbage" ,sbcl-trivial-garbage)))
- (synopsis "Bridge between Python and Lisp (FFI bindings, etc.)")
- (description
- "This package provides a shim between Python3 (specifically, the
-CPython implementation of Python) and Common Lisp.")
- (home-page "https://github.com/snmsts/burgled-batteries3")
- ;; MIT
- (license license:expat))))
-
-(define-public cl-burgled-batteries3
- (sbcl-package->cl-source-package sbcl-burgled-batteries3))
-
-(define-public ecl-burgled-batteries3
- (sbcl-package->ecl-package sbcl-burgled-batteries3))
-
-(define-public sbcl-metabang-bind
- (let ((commit "c93b7f7e1c18c954c2283efd6a7fdab36746ab5e")
- (revision "1"))
- (package
- (name "sbcl-metabang-bind")
- (version (git-version "0.8.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/gwkkwg/metabang-bind.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "0hd0kr91795v77akpbcyqiss9p0p7ypa9dznrllincnmgvsxlmf0"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- `(("sbcl-lift" ,sbcl-lift)))
- (synopsis "Macro that generalizes @code{multiple-value-bind} etc.")
- (description
- "Bind extends the idea of of let and destructing to provide a uniform
-syntax for all your accessor needs. It combines @code{let},
-@code{destructuring-bind}, @code{with-slots}, @code{with-accessors}, structure
-editing, property or association-lists, and @code{multiple-value-bind} and a
-whole lot more into a single form.")
- (home-page "https://common-lisp.net/project/metabang-bind/")
- ;; MIT License
- (license license:expat))))
-
-(define-public cl-metabang-bind
- (sbcl-package->cl-source-package sbcl-metabang-bind))
-
-(define-public ecl-metabang-bind
- (sbcl-package->ecl-package sbcl-metabang-bind))
-
-(define-public sbcl-fare-utils
- (let ((commit "66e9c6f1499140bc00ccc22febf2aa528cbb5724")
- (revision "1"))
- (package
- (name "sbcl-fare-utils")
- (version (git-version "1.0.0.5" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri
- (git-reference
- (url
- "https://gitlab.common-lisp.net/frideau/fare-utils.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "01wsr1aap3jdzhn4hrqjbhsjx6qci9dbd3gh4gayv1p49rbg8aqr"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- `(#:test-asd-file "test/fare-utils-test.asd"))
- (native-inputs
- `(("sbcl-hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
- (synopsis "Collection of utilities and data structures")
- (description
- "fare-utils is a small collection of utilities. It contains a lot of
-basic everyday functions and macros.")
- (home-page "https://gitlab.common-lisp.net/frideau/fare-utils")
- ;; MIT License
- (license license:expat))))
-
-(define-public cl-fare-utils
- (sbcl-package->cl-source-package sbcl-fare-utils))
-
-(define-public ecl-fare-utils
- (sbcl-package->ecl-package sbcl-fare-utils))
-
-(define-public sbcl-trivial-utf-8
- (let ((commit "4d427cfbb1c452436a0efb71c3205c9da67f718f")
- (revision "1"))
- (package
- (name "sbcl-trivial-utf-8")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri
- (git-reference
- (url (string-append "https://gitlab.common-lisp.net/"
- "trivial-utf-8/trivial-utf-8.git"))
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "1jz27gz8gvqdmvp3k9bxschs6d5b3qgk94qp2bj6nv1d0jc3m1l1"))))
- (arguments
- ;; Guix incorrectly assumes the "8" is part of the version
- ;; number and lobs it off.
- `(#:asd-file "trivial-utf-8.asd"
- #:asd-system-name "trivial-utf-8"))
- (build-system asdf-build-system/sbcl)
- (synopsis "UTF-8 input/output library")
- (description
- "The Babel library solves a similar problem while understanding more
-encodings. Trivial UTF-8 was written before Babel existed, but for new
-projects you might be better off going with Babel. The one plus that Trivial
-UTF-8 has is that it doesn't depend on any other libraries.")
- (home-page "https://common-lisp.net/project/trivial-utf-8/")
- (license license:bsd-3))))
-
-(define-public cl-trivial-utf-8
- (sbcl-package->cl-source-package sbcl-trivial-utf-8))
-
-(define-public ecl-trivial-utf-8
- (sbcl-package->ecl-package sbcl-trivial-utf-8))
-
-(define-public sbcl-idna
- (package
- (name "sbcl-idna")
- (build-system asdf-build-system/sbcl)
- (version "0.2.2")
- (home-page "https://github.com/antifuchs/idna")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url home-page)
- (commit version)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "00nbr3mffxhlq14gg9d16pa6691s4qh35inyw76v906s77khm5a2"))))
- (inputs
- `(("split-sequence" ,sbcl-split-sequence)))
- (synopsis "IDNA string encoding and decoding routines for Common Lisp")
- (description "This Common Lisp library provides string encoding and
-decoding routines for IDNA, the International Domain Names in Applications.")
- (license license:expat)))
-
-(define-public cl-idna
- (sbcl-package->cl-source-package sbcl-idna))
-
-(define-public ecl-idna
- (sbcl-package->ecl-package sbcl-idna))
-
-(define-public sbcl-swap-bytes
- (package
- (name "sbcl-swap-bytes")
- (build-system asdf-build-system/sbcl)
- (version "1.1")
- (home-page "https://github.com/sionescu/swap-bytes")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url home-page)
- (commit (string-append "v" version))))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "1qysbv0jngdfkv53y874qjhcxc4qi8ixaqq6j8bzxh5z0931wv55"))))
- (inputs
- `(("trivial-features" ,sbcl-trivial-features)))
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)))
- (arguments
- ;; TODO: Tests fail, why?
- `(#:tests? #f))
- (synopsis "Efficient endianness conversion for Common Lisp")
- (description "This Common Lisp library provides optimized byte-swapping
-primitives. The library can change endianness of unsigned integers of length
-1/2/4/8. Very useful in implementing various network protocols and file
-formats.")
- (license license:expat)))
-
-(define-public cl-swap-bytes
- (sbcl-package->cl-source-package sbcl-swap-bytes))
-
-(define-public ecl-swap-bytes
- (sbcl-package->ecl-package sbcl-swap-bytes))
-
-(define-public sbcl-iolib.asdf
- ;; Latest release is from June 2017.
- (let ((commit "81e20614c0d27f9605bf9766214e236fd31b99b4")
- (revision "1"))
- (package
- (name "sbcl-iolib.asdf")
- (build-system asdf-build-system/sbcl)
- (version "0.8.3")
- (home-page "https://github.com/sionescu/iolib")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url home-page)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "1j81r0wm7nfbwl991f26s4npcy7kybzybd3m47rbxy31h0cfcmdm"))))
- (inputs
- `(("alexandria" ,sbcl-alexandria)))
- (arguments
- '(#:asd-file "iolib.asdf.asd"))
- (synopsis "ASDF component classes for IOLib, a Common Lisp I/O library")
- (description "IOlib is to be a better and more modern I/O library than
-the standard Common Lisp library. It contains a socket library, a DNS
-resolver, an I/O multiplexer(which supports @code{select(2)}, @code{epoll(4)}
-and @code{kqueue(2)}), a pathname library and file-system utilities.")
- (license license:expat))))
-
-(define-public sbcl-iolib.conf
- (package
- (inherit sbcl-iolib.asdf)
- (name "sbcl-iolib.conf")
- (inputs
- `(("iolib.asdf" ,sbcl-iolib.asdf)))
- (arguments
- '(#:asd-file "iolib.conf.asd"))
- (synopsis "Compile-time configuration for IOLib, a Common Lisp I/O library")))
-
-(define-public sbcl-iolib.common-lisp
- (package
- (inherit sbcl-iolib.asdf)
- (name "sbcl-iolib.common-lisp")
- (inputs
- `(("iolib.asdf" ,sbcl-iolib.asdf)
- ("iolib.conf" ,sbcl-iolib.conf)))
- (arguments
- '(#:asd-file "iolib.common-lisp.asd"))
- (synopsis "Slightly modified Common Lisp for IOLib, a Common Lisp I/O library")))
-
-(define-public sbcl-iolib.base
- (package
- (inherit sbcl-iolib.asdf)
- (name "sbcl-iolib.base")
- (inputs
- `(("iolib.asdf" ,sbcl-iolib.asdf)
- ("iolib.conf" ,sbcl-iolib.conf)
- ("iolib.common-lisp" ,sbcl-iolib.common-lisp)
- ("split-sequence" ,sbcl-split-sequence)))
- (arguments
- '(#:asd-file "iolib.base.asd"))
- (synopsis "Base package for IOLib, a Common Lisp I/O library")))
-
-(define-public sbcl-iolib.grovel
- (package
- (inherit sbcl-iolib.asdf)
- (name "sbcl-iolib.grovel")
- (inputs
- `(("iolib.asdf" ,sbcl-iolib.asdf)
- ("iolib.conf" ,sbcl-iolib.conf)
- ("iolib.base", sbcl-iolib.base)
- ("cffi", sbcl-cffi)))
- (arguments
- '(#:asd-file "iolib.grovel.asd"
- #:phases
- (modify-phases %standard-phases
- (add-after 'install 'install-header
- (lambda* (#:key outputs #:allow-other-keys)
- ;; This header is required by sbcl-iolib.
- (install-file "src/grovel/grovel-common.h"
- (string-append (assoc-ref outputs "out")
- "/lib/sbcl"))
- #t)))))
- (synopsis "CFFI Groveller for IOLib, a Common Lisp I/O library")))
-
-(define-public sbcl-iolib
- (package
- (inherit sbcl-iolib.asdf)
- (name "sbcl-iolib")
- (inputs
- `(("iolib.asdf" ,sbcl-iolib.asdf)
- ("iolib.conf" ,sbcl-iolib.conf)
- ("iolib.grovel" ,sbcl-iolib.grovel)
- ("iolib.base" ,sbcl-iolib.base)
- ("bordeaux-threads" ,sbcl-bordeaux-threads)
- ("idna" ,sbcl-idna)
- ("swap-bytes" ,sbcl-swap-bytes)
- ("libfixposix" ,libfixposix)
- ("cffi" ,sbcl-cffi)))
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)))
- (arguments
- '(#:asd-file "iolib.asd"
- #:asd-system-name "iolib"
- #:test-asd-file "iolib.tests.asd"
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/syscalls/ffi-functions-unix.lisp"
- (("\\(:default \"libfixposix\"\\)")
- (string-append
- "(:default \""
- (assoc-ref inputs "libfixposix") "/lib/libfixposix\")")))
- ;; Socket tests need Internet access, disable them.
- (substitute* "iolib.tests.asd"
- (("\\(:file \"sockets\" :depends-on \\(\"pkgdcl\" \"defsuites\"\\)\\)")
- "")))))))
- (synopsis "Common Lisp I/O library")))
-
-(define-public cl-iolib
- (sbcl-package->cl-source-package sbcl-iolib))
-
-(define sbcl-iolib+multiplex
- (package
- (inherit sbcl-iolib)
- (name "sbcl-iolib+multiplex")
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-iolib)
- ((#:asd-system-name _) "iolib/multiplex")))))
-
-(define sbcl-iolib+syscalls
- (package
- (inherit sbcl-iolib)
- (name "sbcl-iolib+syscalls")
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-iolib)
- ((#:asd-system-name _) "iolib/syscalls")))))
-
-(define sbcl-iolib+streams
- (package
- (inherit sbcl-iolib)
- (name "sbcl-iolib+streams")
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-iolib)
- ((#:asd-system-name _) "iolib/streams")))))
-
-(define sbcl-iolib+sockets
- (package
- (inherit sbcl-iolib)
- (name "sbcl-iolib+sockets")
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-iolib)
- ((#:asd-system-name _) "iolib/sockets")))))
-
-(define-public sbcl-ieee-floats
- (let ((commit "566b51a005e81ff618554b9b2f0b795d3b29398d")
- (revision "1"))
- (package
- (name "sbcl-ieee-floats")
- (build-system asdf-build-system/sbcl)
- (version (git-version "20170924" revision commit))
- (home-page "https://github.com/marijnh/ieee-floats/")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url home-page)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "1xyj49j9x3lc84cv3dhbf9ja34ywjk1c46dklx425fxw9mkwm83m"))))
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)))
- (synopsis "IEEE 754 binary representation for floats in Common Lisp")
- (description "This is a Common Lisp library that allows to convert
-floating point values to IEEE 754 binary representation.")
- (license license:bsd-3))))
-
-(define-public cl-ieee-floats
- (sbcl-package->cl-source-package sbcl-ieee-floats))
-
-(define sbcl-closure-common
- (let ((commit "e3c5f5f454b72b01b89115e581c3c52a7e201e5c")
- (revision "1"))
- (package
- (name "sbcl-closure-common")
- (build-system asdf-build-system/sbcl)
- (version (git-version "20101006" revision commit))
- (home-page "https://common-lisp.net/project/cxml/")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/sharplispers/closure-common")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "0k5r2qxn122pxi301ijir3nayi9sg4d7yiy276l36qmzwhp4mg5n"))))
- (inputs
- `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)
- ("babel" ,sbcl-babel)))
- (synopsis "Support Common Lisp library for CXML")
- (description "Closure-common is an internal helper library. The name
-Closure is a reference to the web browser it was originally written for.")
- ;; TODO: License?
- (license #f))))
-
-(define-public sbcl-cxml+xml
- (let ((commit "00b22bf4c4cf11c993d5866fae284f95ab18e6bf")
- (revision "1"))
- (package
- (name "sbcl-cxml+xml")
- (build-system asdf-build-system/sbcl)
- (version (git-version "0.0.0" revision commit))
- (home-page "https://common-lisp.net/project/cxml/")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/sharplispers/cxml")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "13kif7rf3gqdycsk9zq0d7y0g9y81krkl0z87k0p2fkbjfgrph37"))))
- (inputs
- `(("closure-common" ,sbcl-closure-common)
- ("puri" ,sbcl-puri)
- ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
- (arguments
- `(#:asd-file "cxml.asd"
- #:asd-system-name "cxml/xml"))
- (synopsis "Common Lisp XML parser")
- (description "CXML implements a namespace-aware, validating XML 1.0
-parser as well as the DOM Level 2 Core interfaces. Two parser interfaces are
-offered, one SAX-like, the other similar to StAX.")
- (license license:llgpl))))
-
-(define sbcl-cxml+dom
- (package
- (inherit sbcl-cxml+xml)
- (name "sbcl-cxml+dom")
- (inputs
- `(("closure-common" ,sbcl-closure-common)
- ("puri" ,sbcl-puri)
- ("cxml+xml" ,sbcl-cxml+xml)))
- (arguments
- `(#:asd-file "cxml.asd"
- #:asd-system-name "cxml/dom"))))
-
-(define sbcl-cxml+klacks
- (package
- (inherit sbcl-cxml+xml)
- (name "sbcl-cxml+klacks")
- (inputs
- `(("closure-common" ,sbcl-closure-common)
- ("puri" ,sbcl-puri)
- ("cxml+xml" ,sbcl-cxml+xml)))
- (arguments
- `(#:asd-file "cxml.asd"
- #:asd-system-name "cxml/klacks"))))
-
-(define sbcl-cxml+test
- (package
- (inherit sbcl-cxml+xml)
- (name "sbcl-cxml+test")
- (inputs
- `(("closure-common" ,sbcl-closure-common)
- ("puri" ,sbcl-puri)
- ("cxml+xml" ,sbcl-cxml+xml)))
- (arguments
- `(#:asd-file "cxml.asd"
- #:asd-system-name "cxml/test"))))
-
-(define-public sbcl-cxml
- (package
- (inherit sbcl-cxml+xml)
- (name "sbcl-cxml")
- (inputs
- `(("closure-common" ,sbcl-closure-common)
- ("puri" ,sbcl-puri)
- ("trivial-gray-streams" ,sbcl-trivial-gray-streams)
- ("cxml+dom" ,sbcl-cxml+dom)
- ("cxml+klacks" ,sbcl-cxml+klacks)
- ("cxml+test" ,sbcl-cxml+test)))
- (arguments
- `(#:asd-file "cxml.asd"
- #:asd-system-name "cxml"
- #:phases
- (modify-phases %standard-phases
- (add-after 'build 'install-dtd
- (lambda* (#:key outputs #:allow-other-keys)
- (install-file "catalog.dtd"
- (string-append
- (assoc-ref outputs "out")
- "/lib/" (%lisp-type)))))
- (add-after 'create-asd 'remove-component
- ;; XXX: The original .asd has no components, but our build system
- ;; creates an entry nonetheless. We need to remove it for the
- ;; generated .asd to load properly. See trivia.trivial for a
- ;; similar problem.
- (lambda* (#:key outputs #:allow-other-keys)
- (let* ((out (assoc-ref outputs "out"))
- (asd (string-append out "/lib/sbcl/cxml.asd")))
- (substitute* asd
- ((" :components
-")
- ""))
- (substitute* asd
- ((" *\\(\\(:compiled-file \"cxml--system\"\\)\\)")
- ""))))))))))
-
-(define-public cl-cxml
- (sbcl-package->cl-source-package sbcl-cxml))
-
-(define-public sbcl-cl-reexport
- (let ((commit "312f3661bbe187b5f28536cd7ec2956e91366c3b")
- (revision "1"))
- (package
- (name "sbcl-cl-reexport")
- (build-system asdf-build-system/sbcl)
- (version (git-version "0.1" revision commit))
- (home-page "https://github.com/takagi/cl-reexport")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url home-page)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "1cwpn1m3wrl0fl9plznn7p464db646gnfc8zkyk97dyxski2aq0x"))))
- (inputs
- `(("alexandria" ,sbcl-alexandria)))
- (arguments
- ;; TODO: Tests fail because cl-test-more is missing, but I can't find it online.
- `(#:tests? #f))
- (synopsis "HTTP cookie manager for Common Lisp")
- (description "cl-cookie is a Common Lisp library featuring parsing of
-cookie headers, cookie creation, cookie jar creation and more.")
- (license license:llgpl))))
-
-(define-public cl-reexport
- (sbcl-package->cl-source-package sbcl-cl-reexport))
-
-(define-public sbcl-cl-cookie
- (let ((commit "cea55aed8b9ad25fafd13defbcb9fe8f41b29546")
- (revision "1"))
- (package
- (name "sbcl-cl-cookie")
- (build-system asdf-build-system/sbcl)
- (version (git-version "0.9.10" revision commit))
- (home-page "https://github.com/fukamachi/cl-cookie")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url home-page)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "090g7z75h98zvc1ldx0vh4jn4086dhjm2w30jcwkq553qmyxwl8h"))))
- (inputs
- `(("proc-parse" ,sbcl-proc-parse)
- ("alexandria" ,sbcl-alexandria)
- ("quri" ,sbcl-quri)
- ("cl-ppcre" ,sbcl-cl-ppcre)
- ("local-time" ,sbcl-local-time)))
- (native-inputs
- `(("prove-asdf" ,sbcl-prove-asdf)
- ("prove" ,sbcl-prove)))
- (arguments
- ;; TODO: Tests fail because cl-cookie depends on cl-cookie-test.
- `(#:tests? #f))
- (synopsis "HTTP cookie manager for Common Lisp")
- (description "cl-cookie is a Common Lisp library featuring parsing of
-cookie headers, cookie creation, cookie jar creation and more.")
- (license license:bsd-2))))
-
-(define-public cl-cookie
- (sbcl-package->cl-source-package sbcl-cl-cookie))
-
-(define-public sbcl-dexador
- (let ((commit "a2714d126cc94bc7a9a6e1e3c08de455b3a66378")
- (revision "1"))
- (package
- (name "sbcl-dexador")
- (build-system asdf-build-system/sbcl)
- (version (git-version "0.9.10" revision commit))
- (home-page "https://github.com/fukamachi/dexador")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url home-page)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "0nbqgn4v3l2z6m1k1bdxfnqpfrk84nxdmz7csz11zzcfs4flkv79"))))
- (inputs
- `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)
- ("babel" ,sbcl-babel)
- ("usocket" ,sbcl-usocket)
- ("fast-http" ,sbcl-fast-http)
- ("quri" ,sbcl-quri)
- ("fast-io" ,sbcl-fast-io)
- ("chunga" ,sbcl-chunga)
- ("cl-ppcre" ,sbcl-cl-ppcre)
- ("cl-cookie" ,sbcl-cl-cookie)
- ("trivial-mimes" ,sbcl-trivial-mimes)
- ("chipz" ,sbcl-chipz)
- ("cl-base64" ,sbcl-cl-base64)
- ("cl-reexport" ,sbcl-cl-reexport)
- ("cl+ssl" ,sbcl-cl+ssl)
- ("bordeaux-threads" ,sbcl-bordeaux-threads)
- ("alexandria" ,sbcl-alexandria)))
- (native-inputs
- `(("prove" ,sbcl-prove)
- ("prove-asdf" ,sbcl-prove-asdf)
- ("lack-request" ,sbcl-lack-request)
- ("clack" ,sbcl-clack)
- ("babel" ,sbcl-babel)
- ("alexandria" ,sbcl-alexandria)
- ("cl-ppcre" ,sbcl-cl-ppcre)
- ("local-time" ,sbcl-local-time)))
- (arguments
- ;; TODO: Circular dependency: tests depend on clack-test which depends on dexador.
- `(#:tests? #f
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-permissions
- (lambda _ (make-file-writable "t/data/test.gz") #t)))))
- (synopsis "Yet another HTTP client for Common Lisp")
- (description "Dexador is yet another HTTP client for Common Lisp with
-neat APIs and connection-pooling. It is meant to supersede Drakma.")
- (license license:expat))))
-
-(define-public cl-dexador
- (package
- (inherit (sbcl-package->cl-source-package sbcl-dexador))
- (arguments
- `(#:phases
- ;; asdf-build-system/source has its own phases and does not inherit
- ;; from asdf-build-system/sbcl phases.
- (modify-phases %standard-phases/source
- (add-after 'unpack 'fix-permissions
- (lambda _ (make-file-writable "t/data/test.gz") #t)))))))
-
-(define-public ecl-dexador
- (sbcl-package->ecl-package sbcl-dexador))
-
-(define-public sbcl-lisp-namespace
- (let ((commit "28107cafe34e4c1c67490fde60c7f92dc610b2e0")
- (revision "1"))
- (package
- (name "sbcl-lisp-namespace")
- (build-system asdf-build-system/sbcl)
- (version (git-version "0.1" revision commit))
- (home-page "https://github.com/guicho271828/lisp-namespace")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url home-page)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "1jw2wykp06z2afb9nm1lgfzll5cjlj36pnknjx614057zkkxq4iy"))))
- (inputs
- `(("alexandria" ,sbcl-alexandria)))
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)))
- (arguments
- `(#:test-asd-file "lisp-namespace.test.asd"
- ;; XXX: Component LISP-NAMESPACE-ASD::LISP-NAMESPACE.TEST not found
- #:tests? #f))
- (synopsis "LISP-N, or extensible namespaces in Common Lisp")
- (description "Common Lisp already has major 2 namespaces, function
-namespace and value namespace (or variable namespace), but there are actually
-more — e.g., class namespace.
-This library offers macros to deal with symbols from any namespace.")
- (license license:llgpl))))
-
-(define-public cl-lisp-namespace
- (sbcl-package->cl-source-package sbcl-lisp-namespace))
-
-(define-public sbcl-trivial-cltl2
- (let ((commit "8eec8407df833e8f27df8a388bc10913f16d9e83")
- (revision "1"))
- (package
- (name "sbcl-trivial-cltl2")
- (build-system asdf-build-system/sbcl)
- (version (git-version "0.1.1" revision commit))
- (home-page "https://github.com/Zulu-Inuoe/trivial-cltl2")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url home-page)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "1dyyxz17vqv8hlfwq287gl8xxbvcnq798ajb7p5jdjz91wqf4bgk"))))
- (synopsis "Simple CLtL2 compatibility layer for Common Lisp")
- (description "This library is a portable compatibility layer around
-\"Common Lisp the Language, 2nd
-Edition\" (@url{https://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node102.html})
-and it exports symbols from implementation-specific packages.")
- (license license:llgpl))))
-
-(define-public cl-trivial-cltl2
- (sbcl-package->cl-source-package sbcl-trivial-cltl2))
-
-(define-public sbcl-introspect-environment
- (let ((commit "fff42f8f8fd0d99db5ad6c5812e53de7d660020b")
- (revision "1"))
- (package
- (name "sbcl-introspect-environment")
- (build-system asdf-build-system/sbcl)
- (version (git-version "0.1" revision commit))
- (home-page "https://github.com/Bike/introspect-environment")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url home-page)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "1i305n0wfmpac63ni4i3vixnnkl8daw5ncxy0k3dv92krgx6qzhp"))))
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)))
- (synopsis "Common Lisp environment introspection portability layer")
- (description "This library is a small interface to portable but
-nonstandard introspection of Common Lisp environments. It is intended to
-allow a bit more compile-time introspection of environments in Common Lisp.
-
-Quite a bit of information is available at the time a macro or compiler-macro
-runs; inlining info, type declarations, that sort of thing. This information
-is all standard - any Common Lisp program can @code{(declare (integer x))} and
-such.
-
-This info ought to be accessible through the standard @code{&environment}
-parameters, but it is not. Several implementations keep the information for
-their own purposes but do not make it available to user programs, because
-there is no standard mechanism to do so.
-
-This library uses implementation-specific hooks to make information available
-to users. This is currently supported on SBCL, CCL, and CMUCL. Other
-implementations have implementations of the functions that do as much as they
-can and/or provide reasonable defaults.")
- (license license:wtfpl2))))
-
-(define-public cl-introspect-environment
- (sbcl-package->cl-source-package sbcl-introspect-environment))
-
-(define-public sbcl-type-i
- (let ((commit "dea233f45f94064105ec09f0767de338f67dcbe2")
- (revision "1"))
- (package
- (name "sbcl-type-i")
- (build-system asdf-build-system/sbcl)
- (version (git-version "0.1" revision commit))
- (home-page "https://github.com/guicho271828/type-i")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url home-page)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "039g5pbrhh65s0bhr9314gmd2nwc2y5lp2377c5qrc2lxky89qs3"))))
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("introspect-environment" ,sbcl-introspect-environment)
- ("trivia.trivial" ,sbcl-trivia.trivial)))
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)))
- (arguments
- `(#:test-asd-file "type-i.test.asd"))
- (synopsis "Type inference utility on unary predicates for Common Lisp")
- (description "This library tries to provide a way to detect what kind of
-type the given predicate is trying to check. This is different from inferring
-the return type of a function.")
- (license license:llgpl))))
-
-(define-public cl-type-i
- (sbcl-package->cl-source-package sbcl-type-i))
-
-(define-public sbcl-optima
- (let ((commit "373b245b928c1a5cce91a6cb5bfe5dd77eb36195")
- (revision "1"))
- (package
- (name "sbcl-optima")
- (build-system asdf-build-system/sbcl)
- (version (git-version "1.0" revision commit))
- (home-page "https://github.com/m2ym/optima")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url home-page)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "1yw4ymq7ms89342kkvb3aqxgv0w38m9kd8ikdqxxzyybnkjhndal"))))
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("closer-mop" ,sbcl-closer-mop)))
- (native-inputs
- `(("eos" ,sbcl-eos)))
- (arguments
- ;; XXX: Circular dependencies: tests depend on optima.ppcre which depends on optima.
- `(#:tests? #f
- #:test-asd-file "optima.test.asd"))
- (synopsis "Optimized pattern matching library for Common Lisp")
- (description "Optima is a fast pattern matching library which uses
-optimizing techniques widely used in the functional programming world.")
- (license license:expat))))
-
-(define-public cl-optima
- (sbcl-package->cl-source-package sbcl-optima))
-
-(define-public sbcl-fare-quasiquote
- (package
- (name "sbcl-fare-quasiquote")
- (build-system asdf-build-system/sbcl)
- (version "20171130")
- (home-page "http://common-lisp.net/project/fare-quasiquote")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "http://beta.quicklisp.org/archive/fare-quasiquote/"
- (date->string (string->date version "~Y~m~d") "~Y-~m-~d")
- "/fare-quasiquote-"
- version
- "-git.tgz"))
- (sha256
- (base32
- "00brmh7ndsi0c97nibi8cy10j3l4gmkyrfrr5jr5lzkfb7ngyfqa"))))
- (inputs
- `(("fare-utils" ,sbcl-fare-utils)))
- (arguments
- ;; XXX: Circular dependencies: Tests depend on subsystems, which depend on the main systems.
- `(#:tests? #f
- #:phases
- (modify-phases %standard-phases
- ;; XXX: Require 1.0.0 version of fare-utils, and we package some
- ;; commits after 1.0.0.5, but ASDF fails to read the
- ;; "-REVISION-COMMIT" part generated by Guix.
- (add-after 'unpack 'patch-requirement
- (lambda _
- (substitute* "fare-quasiquote.asd"
- (("\\(:version \"fare-utils\" \"1.0.0\"\\)") "\"fare-utils\"")))))))
- (synopsis "Pattern-matching friendly implementation of quasiquote for Common Lisp")
- (description "The main purpose of this n+2nd reimplementation of
-quasiquote is enable matching of quasiquoted patterns, using Optima or
-Trivia.")
- (license license:expat)))
-
-(define-public cl-fare-quasiquote
- (sbcl-package->cl-source-package sbcl-fare-quasiquote))
-
-(define-public sbcl-fare-quasiquote-optima
- (package
- (inherit sbcl-fare-quasiquote)
- (name "sbcl-fare-quasiquote-optima")
- (inputs
- `(("optima" ,sbcl-optima)
- ("fare-quasiquote" ,sbcl-fare-quasiquote)))
- (arguments
- '(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'patch-requirement
- (lambda _
- (substitute* "fare-quasiquote-optima.asd"
- (("\\(:version \"optima\" \"1\\.0\"\\)")
- "\"optima\""))
- #t)))))))
-
-(define-public cl-fare-quasiquote-optima
- (sbcl-package->cl-source-package sbcl-fare-quasiquote-optima))
-
-(define-public sbcl-fare-quasiquote-readtable
- (package
- (inherit sbcl-fare-quasiquote)
- (name "sbcl-fare-quasiquote-readtable")
- (inputs
- `(("fare-quasiquote" ,sbcl-fare-quasiquote)
- ("named-readtables" ,sbcl-named-readtables)))
- (description "The main purpose of this n+2nd reimplementation of
-quasiquote is enable matching of quasiquoted patterns, using Optima or
-Trivia.
-
-This package uses fare-quasiquote with named-readtable.")))
-
-(define-public cl-fare-quasiquote-readtable
- (sbcl-package->cl-source-package sbcl-fare-quasiquote-readtable))
-
-;; TODO: Add support for component-less system in asdf-build-system/sbcl.
-(define-public cl-fare-quasiquote-extras
- (package
- (inherit cl-fare-quasiquote)
- (name "cl-fare-quasiquote-extras")
- (build-system asdf-build-system/source)
- (propagated-inputs
- `(("fare-quasiquote" ,cl-fare-quasiquote)
- ("fare-quasiquote-optima" ,cl-fare-quasiquote-optima)
- ("fare-quasiquote-readtable" ,cl-fare-quasiquote-readtable)))
- (description "This library combines @code{fare-quasiquote-readtable} and
-@code{fare-quasiquote-optima}.")))
-
-(define-public sbcl-trivia.level0
- (let ((commit "902e0c65602bbfe96ae82e679330b3771ddc7603")
- (revision "1"))
- (package
- (name "sbcl-trivia.level0")
- (build-system asdf-build-system/sbcl)
- (version (git-version "0.0.0" revision commit))
- (home-page "https://github.com/guicho271828/trivia")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url home-page)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "11qbab30qqnfy9mx3x9fvgcw1jbvh1qn2cqv3p8xdn2m8981jvhr"))))
- (inputs
- `(("alexandria" ,sbcl-alexandria)))
- (synopsis "Pattern matching in Common Lisp")
- (description "Trivia is a pattern matching compiler that is compatible
-with Optima, another pattern matching library for Common Lisp. It is meant to
-be faster and more extensible than Optima.")
- (license license:llgpl))))
-
-(define-public sbcl-trivia.level1
- (package
- (inherit sbcl-trivia.level0)
- (name "sbcl-trivia.level1")
- (inputs
- `(("trivia.level0" ,sbcl-trivia.level0)))
- (description "Trivia is a pattern matching compiler that is compatible
-with Optima, another pattern matching library for Common Lisp. It is meant to
-be faster and more extensible than Optima.
-
-This system contains the core patterns of Trivia.")))
-
-(define-public sbcl-trivia.level2
- (package
- (inherit sbcl-trivia.level0)
- (name "sbcl-trivia.level2")
- (inputs
- `(("trivia.level1" ,sbcl-trivia.level1)
- ("lisp-namespace" ,sbcl-lisp-namespace)
- ("trivial-cltl2" ,sbcl-trivial-cltl2)
- ("closer-mop" ,sbcl-closer-mop)))
- (description "Trivia is a pattern matching compiler that is compatible
-with Optima, another pattern matching library for Common Lisp. It is meant to
-be faster and more extensible than Optima.
-
-This system contains a non-optimized pattern matcher compatible with Optima,
-with extensible optimizer interface.")))
-
-(define-public sbcl-trivia.trivial
- (package
- (inherit sbcl-trivia.level0)
- (name "sbcl-trivia.trivial")
- (inputs
- `(("trivia.level2" ,sbcl-trivia.level2)))
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (replace 'create-asd-file
- (lambda* (#:key outputs inputs #:allow-other-keys)
- (let* ((out (assoc-ref outputs "out"))
- (lib (string-append out "/lib/" (%lisp-type)))
- (level2 (assoc-ref inputs "trivia.level2")))
- (mkdir-p lib)
- (install-file "trivia.trivial.asd" lib)
- ;; XXX: This .asd does not have any component and the build
- ;; system fails to work in this case. We should update the
- ;; build system to handle component-less .asd.
- ;; TODO: How do we append to file in Guile? It seems that
- ;; (open-file ... "a") gets a "Permission denied".
- (substitute* (string-append lib "/trivia.trivial.asd")
- (("\"\\)")
- (string-append "\")
-
-(progn (asdf/source-registry:ensure-source-registry)
- (setf (gethash
- \"trivia.level2\"
- asdf/source-registry:*source-registry*)
- #p\""
- level2
- "/share/common-lisp/sbcl-bundle-systems/trivia.level2.asd\"))")))))))))
- (description "Trivia is a pattern matching compiler that is compatible
-with Optima, another pattern matching library for Common Lisp. It is meant to
-be faster and more extensible than Optima.
-
-This system contains the base level system of Trivia with a trivial optimizer.")))
-
-(define-public sbcl-trivia.balland2006
- (package
- (inherit sbcl-trivia.level0)
- (name "sbcl-trivia.balland2006")
- (inputs
- `(("trivia.trivial" ,sbcl-trivia.trivial)
- ("iterate" ,sbcl-iterate)
- ("type-i" ,sbcl-type-i)
- ("alexandria" ,sbcl-alexandria)))
- (arguments
- ;; Tests are done in trivia itself.
- `(#:tests? #f))
- (description "Trivia is a pattern matching compiler that is compatible
-with Optima, another pattern matching library for Common Lisp. It is meant to
-be faster and more extensible than Optima.
-
-This system contains the base level system of Trivia with a trivial optimizer.")))
-
-(define-public sbcl-trivia.ppcre
- (package
- (inherit sbcl-trivia.level0)
- (name "sbcl-trivia.ppcre")
- (inputs
- `(("trivia.trivial" ,sbcl-trivia.trivial)
- ("cl-ppcre" ,sbcl-cl-ppcre)))
- (description "Trivia is a pattern matching compiler that is compatible
-with Optima, another pattern matching library for Common Lisp. It is meant to
-be faster and more extensible than Optima.
-
-This system contains the PPCRE extension.")))
-
-(define-public sbcl-trivia.quasiquote
- (package
- (inherit sbcl-trivia.level0)
- (name "sbcl-trivia.quasiquote")
- (inputs
- `(("trivia.trivial" ,sbcl-trivia.trivial)
- ("fare-quasiquote" ,sbcl-fare-quasiquote)
- ("fare-quasiquote-readtable" ,sbcl-fare-quasiquote-readtable)))
- (description "Trivia is a pattern matching compiler that is compatible
-with Optima, another pattern matching library for Common Lisp. It is meant to
-be faster and more extensible than Optima.
-
-This system contains the fare-quasiquote extension.")))
-
-(define-public sbcl-trivia.cffi
- (package
- (inherit sbcl-trivia.level0)
- (name "sbcl-trivia.cffi")
- (inputs
- `(("cffi" ,sbcl-cffi)
- ("trivia.trivial" ,sbcl-trivia.trivial)))
- (description "Trivia is a pattern matching compiler that is compatible
-with Optima, another pattern matching library for Common Lisp. It is meant to
-be faster and more extensible than Optima.
-
-This system contains the CFFI foreign slot access extension.")))
-
-(define-public sbcl-trivia
- (package
- (inherit sbcl-trivia.level0)
- (name "sbcl-trivia")
- (inputs
- `(("trivia.balland2006" ,sbcl-trivia.balland2006)))
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)
- ("trivia.ppcre" ,sbcl-trivia.ppcre)
- ("trivia.quasiquote" ,sbcl-trivia.quasiquote)
- ("trivia.cffi" ,sbcl-trivia.cffi)
- ("optima" ,sbcl-optima)))
- (arguments
- `(#:test-asd-file "trivia.test.asd"
- #:phases
- (modify-phases %standard-phases
- (add-after 'create-asd 'remove-component
- ;; XXX: The original .asd has no components, but our build system
- ;; creates an entry nonetheless. We need to remove it for the
- ;; generated .asd to load properly. See trivia.trivial for a
- ;; similar problem.
- (lambda* (#:key outputs #:allow-other-keys)
- (let* ((out (assoc-ref outputs "out"))
- (asd (string-append out "/lib/" (%lisp-type) "/trivia.asd")))
- (substitute* asd
- ((" :components
-")
- ""))
- (substitute* asd
- ((" *\\(\\(:compiled-file \"trivia--system\"\\)\\)")
- ""))))))))
- (description "Trivia is a pattern matching compiler that is compatible
-with Optima, another pattern matching library for Common Lisp. It is meant to
-be faster and more extensible than Optima.")))
-
-(define-public cl-trivia
- (sbcl-package->cl-source-package sbcl-trivia))
-
-(define-public sbcl-mk-string-metrics
- (package
- (name "sbcl-mk-string-metrics")
- (version "0.1.2")
- (home-page "https://github.com/cbaggers/mk-string-metrics/")
- (source (origin
- (method git-fetch)
- (uri (git-reference
- (url home-page)
- (commit version)))
- (sha256
- (base32 "0bg0bv2mfd4k0g3x72x563hvmrx18xavaffr6xk5rh4if5j7kcf6"))
- (file-name (git-file-name name version))))
- (build-system asdf-build-system/sbcl)
- (synopsis "Calculate various string metrics efficiently in Common Lisp")
- (description "This library implements efficient algorithms that calculate
-various string metrics in Common Lisp:
-
-@itemize
-@item Damerau-Levenshtein distance
-@item Hamming distance
-@item Jaccard similarity coefficient
-@item Jaro distance
-@item Jaro-Winkler distance
-@item Levenshtein distance
-@item Normalized Damerau-Levenshtein distance
-@item Normalized Levenshtein distance
-@item Overlap coefficient
-@end itemize\n")
- (license license:x11)))
-
-(define-public cl-mk-string-metrics
- (sbcl-package->cl-source-package sbcl-mk-string-metrics))
-
-(define-public sbcl-cl-str
- (let ((commit "3d5ec86e3a0199e5973aacde951086dfd754b5e5"))
- (package
- (name "sbcl-cl-str")
- (version (git-version "0.8" "1" commit))
- (home-page "https://github.com/vindarel/cl-str")
- (source (origin
- (method git-fetch)
- (uri (git-reference
- (url home-page)
- (commit commit)))
- (sha256
- (base32 "0szzzbygw9h985yxz909vvqrp69pmpcpahn7hn350lnyjislk9ga"))
- (file-name (git-file-name name version))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("cl-ppcre" ,sbcl-cl-ppcre)
- ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)))
- (native-inputs
- `(("prove" ,sbcl-prove)
- ("prove-asdf" ,sbcl-prove-asdf)))
- (arguments
- `(#:asd-file "str.asd"
- #:asd-system-name "str"
- #:test-asd-file "str.test.asd"))
- (synopsis "Modern, consistent and terse Common Lisp string manipulation library")
- (description "A modern and consistent Common Lisp string manipulation
-library that focuses on modernity, simplicity and discoverability:
-@code{(str:trim s)} instead of @code{(string-trim '(#\\Space ...) s)}), or
-@code{str:concat strings} instead of an unusual format construct; one
-discoverable library instead of many; consistency and composability, where
-@code{s} is always the last argument, which makes it easier to feed pipes and
-arrows.")
- (license license:expat))))
-
-(define-public cl-str
- (sbcl-package->cl-source-package sbcl-cl-str))
-
-(define-public sbcl-cl-xmlspam
- (let ((commit "ea06abcca2a73a9779bcfb09081e56665f94e22a"))
- (package
- (name "sbcl-cl-xmlspam")
- (build-system asdf-build-system/sbcl)
- (version (git-version "0.0.0" "1" commit))
- (home-page "https://github.com/rogpeppe/cl-xmlspam")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url home-page)
- (commit commit)))
- (file-name (string-append name "-" version))
- (sha256
- (base32
- "0w4rqvrgdgk3fwfq3kx4r7wwdr2bv3b6n3bdqwsiriw9psqzpz2s"))))
- (inputs
- `(("cxml" ,sbcl-cxml)
- ("cl-ppcre" ,sbcl-cl-ppcre)))
- (synopsis "Concise, regexp-like pattern matching on streaming XML for Common Lisp")
- (description "CXML does an excellent job at parsing XML elements, but what
-do you do when you have a XML file that's larger than you want to fit in
-memory, and you want to extract some information from it? Writing code to deal
-with SAX events, or even using Klacks, quickly becomes tedious.
-@code{cl-xmlspam} (for XML Stream PAttern Matcher) is designed to make it easy
-to write code that mirrors the structure of the XML that it's parsing. It
-also makes it easy to shift paradigms when necessary - the usual Lisp control
-constructs can be used interchangeably with pattern matching, and the full
-power of CXML is available when necessary.")
- (license license:bsd-3))))
-
-;; TODO: dbus uses ASDF's package-inferred-system which is not supported by
-;; asdf-build-system/sbcl as of 2019-08-02. We should fix
-;; asdf-build-system/sbcl.
-(define-public cl-dbus
- (let ((commit "24b452df3a45ca5dc95015500f34baad175c981a")
- (revision "1"))
- (package
- (name "cl-dbus")
- (build-system asdf-build-system/source)
- (version (git-version "20190408" revision commit))
- (home-page "https://github.com/death/dbus")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url home-page)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "0fw2q866yddbf23nk9pxphm9gsasx35vjyss82xzvndnjmzlqfl5"))))
- ;; Inputs must be propagated or else packages depending on this won't have the necessary packages.
- (propagated-inputs
- `(("alexandria" ,sbcl-alexandria)
- ("trivial-garbage" ,sbcl-trivial-garbage)
- ("babel" ,sbcl-babel)
- ("iolib" ,sbcl-iolib)
- ("iolib+multiplex" ,(@@ (gnu packages lisp) sbcl-iolib+multiplex))
- ("iolib+syscalls" ,(@@ (gnu packages lisp) sbcl-iolib+syscalls))
- ("iolib+streams" ,(@@ (gnu packages lisp) sbcl-iolib+streams))
- ("iolib+sockets" ,(@@ (gnu packages lisp) sbcl-iolib+sockets))
- ("ieee-floats" ,sbcl-ieee-floats)
- ("flexi-streams" ,sbcl-flexi-streams)
- ("cl-xmlspam" ,sbcl-cl-xmlspam)
- ("ironclad" ,sbcl-ironclad)))
- (synopsis "D-Bus client library for Common Lisp")
- (description "This is a Common Lisp library that allows to publish D-Bus
-objects as well as send and notify other objects connected to a bus.")
- (license license:bsd-2))))
-
-(define-public sbcl-cl-hooks
- (let ((commit "5b638083f3b4f1221a52631d9c8a0a265565cac7")
- (revision "1"))
- (package
- (name "sbcl-cl-hooks")
- (build-system asdf-build-system/sbcl)
- (version (git-version "0.2.1" revision commit))
- (home-page "https://github.com/scymtym/architecture.hooks")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url home-page)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "0bg3l0a28lw5gqqjp6p6b5nhwqk46sgkb7184w5qbfngw1hk8x9y"))))
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("let-plus" ,sbcl-let-plus)
- ("trivial-garbage" ,sbcl-trivial-garbage)
- ("closer-mop" ,sbcl-closer-mop)))
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)))
- (synopsis "Hooks extension point mechanism (as in Emacs) for Common Lisp")
- (description "A hook, in the present context, is a certain kind of
-extension point in a program that allows interleaving the execution of
-arbitrary code with the execution of a the program without introducing any
-coupling between the two. Hooks are used extensively in the extensible editor
-Emacs.
-
-In the Common LISP Object System (CLOS), a similar kind of extensibility is
-possible using the flexible multi-method dispatch mechanism. It may even seem
-that the concept of hooks does not provide any benefits over the possibilities
-of CLOS. However, there are some differences:
-
-@itemize
-
-@item There can be only one method for each combination of specializers and
-qualifiers. As a result this kind of extension point cannot be used by
-multiple extensions independently.
-@item Removing code previously attached via a @code{:before}, @code{:after} or
-@code{:around} method can be cumbersome.
-@item There could be other or even multiple extension points besides @code{:before}
-and @code{:after} in a single method.
-@item Attaching codes to individual objects using eql specializers can be
-cumbersome.
-@item Introspection of code attached a particular extension point is
-cumbersome since this requires enumerating and inspecting the methods of a
-generic function.
-@end itemize
-
-This library tries to complement some of these weaknesses of method-based
-extension-points via the concept of hooks.")
- (license license:llgpl))))
-
-(define-public cl-hooks
- (sbcl-package->cl-source-package sbcl-cl-hooks))
-
-(define-public ecl-cl-hooks
- (sbcl-package->ecl-package sbcl-cl-hooks))
-
-(define-public sbcl-s-sysdeps
- (let ((commit "d28246b5dffef9e73a0e0e6cfbc4e878006fe34d")
- (revision "1"))
- (package
- (name "sbcl-s-sysdeps")
- (build-system asdf-build-system/sbcl)
- (version (git-version "1" revision commit))
- (home-page "https://github.com/svenvc/s-sysdeps")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url home-page)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "14b69b81yrxmjlvmm3lfxk04x5v7hqz4fql121334wh72czznfh9"))))
- (synopsis "Common Lisp abstraction layer over platform dependent functionality")
- (description "@code{s-sysdeps} is an abstraction layer over platform
-dependent functionality. This simple package is used as a building block in a
-number of other open source projects.
-
-@code{s-sysdeps} abstracts:
-
-@itemize
-@item managing processes,
-@item implementing a standard TCP/IP server,
-@item opening a client TCP/IP socket stream,
-@item working with process locks.
-@end itemize\n")
- (license license:llgpl))))
-
-(define-public cl-s-sysdeps
- (sbcl-package->cl-source-package sbcl-s-sysdeps))
-
-(define-public ecl-s-sysdeps
- (sbcl-package->ecl-package sbcl-s-sysdeps))
-
-(define-public sbcl-cl-prevalence
- (let ((commit "c163c227ed85d430b82cb1e3502f72d4f88e3cfa")
- (revision "1"))
- (package
- (name "sbcl-cl-prevalence")
- (build-system asdf-build-system/sbcl)
- (version (git-version "5" revision commit))
- (home-page "https://github.com/40ants/cl-prevalence")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url home-page)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "1i9zj1q2ahgwch56an21yzbgkynz0kab9fyxkq9mg8p3xrv38jjn"))))
- (inputs
- `(("s-sysdeps" ,sbcl-s-sysdeps)
- ("s-xml" ,sbcl-s-xml)))
- (synopsis "Implementation of object prevalence for Common Lisp")
- (description "This Common Lisp library implements object prevalence (see
-@url{https://en.wikipedia.org/wiki/System_prevalence}). It allows
-for (de)serializing to and from s-exps as well as XML. Serialization of arbitrary
-classes and cyclic data structures are supported.")
- (license license:llgpl))))
-
-(define-public cl-prevalence
- (sbcl-package->cl-source-package sbcl-cl-prevalence))
-
-(define-public ecl-cl-prevalence
- (sbcl-package->ecl-package sbcl-cl-prevalence))
-
-(define-public sbcl-series
- (let ((commit "da9061b336119d1e5214aff9117171d494d5a58a")
- (revision "1"))
- (package
- (name "sbcl-series")
- (version (git-version "2.2.11" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "git://git.code.sf.net/p/series/series")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "07hk2lhfx42zk018pxqvn4gs77vd4n4g8m4xxbqaxgca76mifwfw"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- ;; Disable the tests, they are apparently buggy and I didn't find
- ;; a simple way to make them run and pass.
- '(#:tests? #f))
- (synopsis "Series data structure for Common Lisp")
- (description
- "This Common Lisp library provides a series data structure much like
-a sequence, with similar kinds of operations. The difference is that in many
-situations, operations on series may be composed functionally and yet execute
-iteratively, without the need to construct intermediate series values
-explicitly. In this manner, series provide both the clarity of a functional
-programming style and the efficiency of an iterative programming style.")
- (home-page "http://series.sourceforge.net/")
- (license license:expat))))
-
-(define-public cl-series
- (sbcl-package->cl-source-package sbcl-series))
-
-(define-public ecl-series
- (sbcl-package->ecl-package sbcl-series))
-
-(define-public sbcl-periods
- (let ((commit "983d4a57325db3c8def942f163133cec5391ec28")
- (revision "1"))
- (package
- (name "sbcl-periods")
- (version (git-version "0.0.2" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/jwiegley/periods.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "0z30jr3lxz3cmi019fsl4lgcgwf0yqpn95v9zkkkwgymdrkd4lga"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("local-time" ,sbcl-local-time)))
- (synopsis "Common Lisp library for manipulating date/time objects")
- (description
- "Periods is a Common Lisp library providing a set of utilities for
-manipulating times, distances between times, and both contiguous and
-discontiguous ranges of time.")
- (home-page "https://github.com/jwiegley/periods")
- (license license:bsd-3))))
-
-(define-public cl-periods
- (sbcl-package->cl-source-package sbcl-periods))
-
-(define-public ecl-periods
- (sbcl-package->ecl-package sbcl-periods))
-
-(define-public sbcl-periods-series
- (package
- (inherit sbcl-periods)
- (name "sbcl-periods-series")
- (inputs
- `(("periods" ,sbcl-periods)
- ("series" ,sbcl-series)))
- (arguments
- '(#:asd-file "periods-series.asd"
- #:asd-system-name "periods-series"))
- (description
- "Periods-series is an extension of the periods Common Lisp library
-providing functions compatible with the series Common Lisp library.")))
-
-(define-public cl-periods-series
- (sbcl-package->cl-source-package sbcl-periods-series))
-
-(define-public ecl-periods-series
- (sbcl-package->ecl-package sbcl-periods-series))
-
-(define-public sbcl-metatilities-base
- (let ((commit "6eaa9e3ff0939a93a92109dd0fcd218de85417d5")
- (revision "1"))
- (package
- (name "sbcl-metatilities-base")
- (version (git-version "0.6.6" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/gwkkwg/metatilities-base.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "0xpa86pdzlnf4v5g64j3ifaplx71sx2ha8b7vvakswi652679ma0"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- `(("lift" ,sbcl-lift)))
- (synopsis "Core of the metatilities Common Lisp library")
- (description
- "Metatilities-base is the core of the metatilities Common Lisp library
-which implements a set of utilities.")
- (home-page "https://common-lisp.net/project/metatilities-base/")
- (license license:expat))))
-
-(define-public cl-metatilities-base
- (sbcl-package->cl-source-package sbcl-metatilities-base))
-
-(define-public ecl-metatilities-base
- (sbcl-package->ecl-package sbcl-metatilities-base))
-
-(define-public sbcl-cl-containers
- (let ((commit "810927e19d933bcf38ffeb7a23ce521efc432d45")
- (revision "1"))
- (package
- (name "sbcl-cl-containers")
- (version (git-version "0.12.1" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/gwkkwg/cl-containers.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "1s9faxw7svhbjpkhfrz2qxgjm3cvyjb8wpyb4m8dx4i5g7vvprkv"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- `(("lift" ,sbcl-lift)))
- (inputs
- `(("metatilities-base" ,sbcl-metatilities-base)))
- (arguments
- '(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'relax-version-checks
- (lambda _
- (substitute* "cl-containers.asd"
- (("\\(:version \"metatilities-base\" \"0\\.6\\.6\"\\)")
- "\"metatilities-base\""))
- (substitute* "cl-containers-test.asd"
- (("\\(:version \"lift\" \"1\\.7\\.0\"\\)")
- "\"lift\""))
- #t)))))
- (synopsis "Container library for Common Lisp")
- (description
- "Common Lisp ships with a set of powerful built in data structures
-including the venerable list, full featured arrays, and hash-tables.
-CL-containers enhances and builds on these structures by adding containers
-that are not available in native Lisp (for example: binary search trees,
-red-black trees, sparse arrays and so on), and by providing a standard
-interface so that they are simpler to use and so that changing design
-decisions becomes significantly easier.")
- (home-page "https://common-lisp.net/project/cl-containers/")
- (license license:expat))))
-
-(define-public cl-containers
- (sbcl-package->cl-source-package sbcl-cl-containers))
-
-(define-public ecl-cl-containers
- (sbcl-package->ecl-package sbcl-cl-containers))
-
-(define-public sbcl-xlunit
- (let ((commit "3805d34b1d8dc77f7e0ee527a2490194292dd0fc")
- (revision "1"))
- (package
- (name "sbcl-xlunit")
- (version (git-version "0.6.3" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "http://git.kpe.io/xlunit.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "0argfmp9nghs4sihyj3f8ch9qfib2b7ll07v5m9ziajgzsfl5xw3"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-tests
- (lambda _
- (substitute* "xlunit.asd"
- ((" :force t") ""))
- #t)))))
- (synopsis "Unit testing package for Common Lisp")
- (description
- "The XLUnit package is a toolkit for building test suites. It is based
-on the XPTest package by Craig Brozensky and the JUnit package by Kent Beck.")
- (home-page "http://quickdocs.org/xlunit/")
- (license license:bsd-3))))
-
-(define-public cl-xlunit
- (sbcl-package->cl-source-package sbcl-xlunit))
-
-(define-public ecl-xlunit
- (sbcl-package->ecl-package sbcl-xlunit))
-
-(define-public sbcl-fprog
- (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636")
- (revision "1"))
- (package
- (name "sbcl-fprog")
- (version (git-version "1.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/jwiegley/cambl.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "103mry04j2k9vznsxm7wcvccgxkil92cdrv52miwcmxl8daa4jiz"))))
- (build-system asdf-build-system/sbcl)
- (synopsis "Functional programming utilities for Common Lisp")
- (description
- "@code{fprog} is a Common Lisp library allowing iteration over
-immutable lists sharing identical sublists.")
- (home-page "https://github.com/jwiegley/cambl")
- (license license:bsd-3))))
-
-(define-public cl-fprog
- (sbcl-package->cl-source-package sbcl-fprog))
-
-(define-public ecl-fprog
- (sbcl-package->ecl-package sbcl-fprog))
-
-(define-public sbcl-cambl
- (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636")
- (revision "1"))
- (package
- (inherit sbcl-fprog)
- (name "sbcl-cambl")
- (version (git-version "4.0.0" revision commit))
- (native-inputs
- `(("xlunit" ,sbcl-xlunit)))
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-containers" ,sbcl-cl-containers)
- ("local-time" ,sbcl-local-time)
- ("periods" ,sbcl-periods)
- ("fprog" ,sbcl-fprog)))
- (synopsis "Commoditized amounts and balances for Common Lisp")
- (description
- "CAMBL is a Common Lisp library providing a convenient facility for
-working with commoditized values. It does not allow compound units (and so is
-not suited for scientific operations) but does work rather nicely for the
-purpose of financial calculations."))))
-
-(define-public cl-cambl
- (sbcl-package->cl-source-package sbcl-cambl))
-
-(define-public ecl-cambl
- (sbcl-package->ecl-package sbcl-cambl))
-
-(define-public sbcl-cl-ledger
- (let ((commit "08e0be41795e804cd36142e51756ad0b1caa377b")
- (revision "1"))
- (package
- (name "sbcl-cl-ledger")
- (version (git-version "4.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/ledger/cl-ledger.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "1via0qf6wjcyxnfbmfxjvms0ik9j8rqbifgpmnhrzvkhrq9pv8h1"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("cambl" ,sbcl-cambl)
- ("cl-ppcre" ,sbcl-cl-ppcre)
- ("local-time" ,sbcl-local-time)
- ("periods-series" ,sbcl-periods-series)))
- (arguments
- '(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-system-definition
- (lambda _
- (substitute* "cl-ledger.asd"
- ((" :build-operation program-op") "")
- ((" :build-pathname \"cl-ledger\"") "")
- ((" :entry-point \"ledger::main\"") ""))
- #t)))))
- (synopsis "Common Lisp port of the Ledger accounting system")
- (description
- "CL-Ledger is a Common Lisp port of the Ledger double-entry accounting
-system.")
- (home-page "https://github.com/ledger/cl-ledger")
- (license license:bsd-3))))
-
-(define-public cl-ledger
- (sbcl-package->cl-source-package sbcl-cl-ledger))
-
-(define-public ecl-cl-ledger
- (sbcl-package->ecl-package sbcl-cl-ledger))
-
-(define-public sbcl-bst
- (let ((commit "34f9c7e8e0a9f2c952fe310ab36cb630d5d9c15a")
- (revision "1"))
- (package
- (name "sbcl-bst")
- (version (git-version "1.1" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/glv2/bst.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "1amxns7hvvh4arwbh8ciwfzplg127vh37dnbamv1m1kmmnmihfc8"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- `(("alexandria" ,sbcl-alexandria)
- ("fiveam" ,sbcl-fiveam)))
- (synopsis "Binary search tree for Common Lisp")
- (description
- "BST is a Common Lisp library for working with binary search trees that
-can contain any kind of values.")
- (home-page "https://github.com/glv2/bst")
- (license license:gpl3))))
-
-(define-public cl-bst
- (sbcl-package->cl-source-package sbcl-bst))
-
-(define-public ecl-bst
- (sbcl-package->ecl-package sbcl-bst))
-
-(define-public sbcl-cl-octet-streams
- (package
- (name "sbcl-cl-octet-streams")
- (version "1.0")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/glv2/cl-octet-streams.git")
- (commit (string-append "v" version))))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "1d7mn6ydv0j2x4r7clpc9ijjwrnfpxmvhifv8n5j7jh7s744sf8d"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)))
- (inputs
- `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
- (synopsis "In-memory octet streams for Common Lisp")
- (description
- "CL-octet-streams is a library implementing in-memory octet
-streams for Common Lisp. It was inspired by the trivial-octet-streams and
-cl-plumbing libraries.")
- (home-page "https://github.com/glv2/cl-octet-streams")
- (license license:gpl3+)))
-
-(define-public cl-octet-streams
- (sbcl-package->cl-source-package sbcl-cl-octet-streams))
-
-(define-public ecl-cl-octet-streams
- (sbcl-package->ecl-package sbcl-cl-octet-streams))
-
-(define-public sbcl-lzlib
- (let ((commit "0de1db7129fef9a58a059d35a2fa2ecfc5b47b47")
- (revision "1"))
- (package
- (name "sbcl-lzlib")
- (version (git-version "1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/glv2/cl-lzlib.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "12ny7vj52fgnd8hb8fc8mry92vq4c1x72x2350191m4476j95clz"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)))
- (inputs
- `(("cffi" ,sbcl-cffi)
- ("cl-octet-streams" ,sbcl-cl-octet-streams)
- ("lzlib" ,lzlib)))
- (arguments
- '(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/lzlib.lisp"
- (("liblz\\.so")
- (string-append (assoc-ref inputs "lzlib") "/lib/liblz.so")))
- #t)))))
- (synopsis "Common Lisp library for lzip (de)compression")
- (description
- "This Common Lisp library provides functions for lzip (LZMA)
-compression/decompression using bindings to the lzlib C library.")
- (home-page "https://github.com/glv2/cl-lzlib")
- (license license:gpl3+))))
-
-(define-public cl-lzlib
- (sbcl-package->cl-source-package sbcl-lzlib))
-
-(define-public ecl-lzlib
- (sbcl-package->ecl-package sbcl-lzlib))
-
-(define-public sbcl-chanl
- (let ((commit "2362b57550c2c9238cc882d03553aaa1040b7340")
- (revision "0"))
- (package
- (name "sbcl-chanl")
- (version (git-version "0.4.1" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/zkat/chanl.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "0ag3wz7yrqwp0s5069wwda98z3rrqd25spg8sa8rdqghj084w28w"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)))
- (inputs
- `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
- (synopsis "Portable channel-based concurrency for Common Lisp")
- (description "Common Lisp library for channel-based concurrency. In
-a nutshell, you create various threads sequentially executing tasks you need
-done, and use channel objects to communicate and synchronize the state of these
-threads.")
- (home-page "https://github.com/zkat/chanl")
- (license (list license:expat license:bsd-3)))))
-
-(define-public cl-chanl
- (sbcl-package->cl-source-package sbcl-chanl))
-
-(define-public ecl-chanl
- (let ((base (sbcl-package->ecl-package sbcl-chanl)))
- (package
- (inherit base)
- (arguments
- (substitute-keyword-arguments (package-arguments base)
- ;; The CHANL.ACTORS package uses the :ARGUMENTS option of
- ;; DEFINE-METHOD-COMBINATION, which is not implemented in ECL yet
- ;; (see https://gitlab.com/embeddable-common-lisp/ecl/issues/305).
- ;; So let's disable it for now, as it allows compiling the library
- ;; and using the rest of it.
- ((#:phases phases '%standard-phases)
- `(modify-phases ,phases
- (add-after 'unpack 'disable-chanl-actors
- (lambda _
- (substitute* "chanl.asd"
- (("\\(:file \"actors\"\\)") ""))
- #t))))
- ;; Disable the tests for now, as the SEND-SEQUENCE test seems to
- ;; never end.
- ((#:tests? _ #f) #f))))))
-
-(define-public sbcl-cl-store
- (let ((commit "cd01f2610d3360dc01ab972bd9317407aaea7745")
- (revision "0"))
- (package
- (name "sbcl-cl-store")
- (version (git-version "0.8.11" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/skypher/cl-store.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "05b7kh5af2ax7vlmphpac4vbqr84j5ivppj96qzb64fxpjpqglm4"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- `(("rt" ,sbcl-rt)))
- (synopsis "Common Lisp library to serialize data")
- (description
- "CL-STORE is a portable serialization package which should give you the
-ability to store all Common Lisp data types into streams.")
- (home-page "http://www.common-lisp.net/project/cl-store/")
- (license license:expat))))
-
-(define-public cl-store
- (sbcl-package->cl-source-package sbcl-cl-store))
-
-(define-public ecl-cl-store
- (sbcl-package->ecl-package sbcl-cl-store))
-
-(define-public sbcl-cl-gobject-introspection
- (let ((commit "7b703e2384945ea0ac39d9b766de434a08d81560")
- (revision "0"))
- (package
- (name "sbcl-cl-gobject-introspection")
- (version (git-version "0.3" revision commit))
- (home-page "https://github.com/andy128k/cl-gobject-introspection")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url home-page)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "1zcqd2qj14f6b38vys8gr89s6cijsp9r8j43xa8lynilwva7bwyh"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cffi" ,sbcl-cffi)
- ("iterate" ,sbcl-iterate)
- ("trivial-garbage" ,sbcl-trivial-garbage)
- ("glib" ,glib)
- ("gobject-introspection" ,gobject-introspection)))
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)))
- (arguments
- ;; TODO: Tests fail, see
- ;; https://github.com/andy128k/cl-gobject-introspection/issues/70.
- '(#:tests? #f
- #:phases
- (modify-phases %standard-phases
- (add-after (quote unpack) (quote fix-paths)
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/init.lisp"
- (("libgobject-2\\.0\\.so")
- (string-append (assoc-ref inputs "glib") "/lib/libgobject-2.0.so"))
- (("libgirepository-1\\.0\\.so")
- (string-append (assoc-ref inputs "gobject-introspection")
- "/lib/libgirepository-1.0.so")))
- #t)))))
- (synopsis "Common Lisp bindings to GObject Introspection")
- (description
- "This library is a bridge between Common Lisp and GObject
-Introspection, which enables Common Lisp programs to access the full interface
-of C+GObject libraries without the need of writing dedicated bindings.")
- (license (list license:bsd-3
- ;; Tests are under a different license.
- license:llgpl)))))
-
-(define-public cl-gobject-introspection
- (sbcl-package->cl-source-package sbcl-cl-gobject-introspection))
-
-(define-public sbcl-string-case
- (let ((commit "718c761e33749e297cd2809c7ba3ade1985c49f7")
- (revision "0"))
- (package
- (name "sbcl-string-case")
- (version (git-version "0.0.2" revision commit))
- (home-page "https://github.com/pkhuong/string-case")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url home-page)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "1n5i3yh0h5s636rcnwn7jwqy3rjflikra04lymimhpcshhjsk0md"))))
- (build-system asdf-build-system/sbcl)
- (synopsis "Efficient string= case in Common Lisp")
- (description
- "@code{string-case} is a Common Lisp macro that generates specialised decision
-trees to dispatch on string equality.")
- (license license:bsd-3))))
-
-(define-public cl-string-case
- (sbcl-package->cl-source-package sbcl-string-case))
-
-(define-public ecl-string-case
- (sbcl-package->ecl-package sbcl-string-case))
-
-(define-public sbcl-global-vars
- (let ((commit "c749f32c9b606a1457daa47d59630708ac0c266e")
- (revision "0"))
- (package
- (name "sbcl-global-vars")
- (version (git-version "1.0.0" revision commit))
- (home-page "https://github.com/lmj/global-vars")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url home-page)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "06m3xc8l3pgsapl8fvsi9wf6y46zs75cp9zn7zh6dc65v4s5wz3d"))))
- (build-system asdf-build-system/sbcl)
- (synopsis "Efficient global variables in Common Lisp")
- (description
- "In Common Lisp, a special variable that is never dynamically bound
-typically serves as a stand-in for a global variable. The @code{global-vars}
-library provides true global variables that are implemented by some compilers.
-An attempt to rebind a global variable properly results in a compiler error.
-That is, a global variable cannot be dynamically bound.
-
-Global variables therefore allow us to communicate an intended usage that
-differs from special variables. Global variables are also more efficient than
-special variables, especially in the presence of threads.")
- (license license:expat))))
-
-(define-public cl-global-vars
- (sbcl-package->cl-source-package sbcl-global-vars))
-
-(define-public ecl-global-vars
- (sbcl-package->ecl-package sbcl-global-vars))
-
-(define-public sbcl-trivial-file-size
- (let ((commit "1c1d672a01a446ba0391dbb4ffc40be3b0476f23")
- (revision "0"))
- (package
- (name "sbcl-trivial-file-size")
- (version (git-version "0.0.0" revision commit))
- (home-page "https://github.com/ruricolist/trivial-file-size")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url home-page)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "17pp86c9zs4y7i1sh7q9gbfw9iqv6655k7fz8qbj9ly1ypgxp4qs"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)))
- (synopsis "Size of a file in bytes in Common Lisp")
- (description
- "The canonical way to determine the size of a file in bytes, using Common Lisp,
-is to open the file with an element type of (unsigned-byte 8) and then
-calculate the length of the stream. This is less than ideal. In most cases
-it is better to get the size of the file from its metadata, using a system
-call.
-
-This library exports a single function, file-size-in-octets. It returns the
-size of a file in bytes, using system calls when possible.")
- (license license:expat))))
-
-(define-public cl-trivial-file-size
- (sbcl-package->cl-source-package sbcl-trivial-file-size))
-
-(define-public ecl-trivial-file-size
- (sbcl-package->ecl-package sbcl-trivial-file-size))
-
-(define-public sbcl-trivial-macroexpand-all
- (let ((commit "933270ac7107477de1bc92c1fd641fe646a7a8a9")
- (revision "0"))
- (package
- (name "sbcl-trivial-macroexpand-all")
- (version (git-version "0.0.0" revision commit))
- (home-page "https://github.com/cbaggers/trivial-macroexpand-all")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url home-page)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "191hnn4b5j4i3crydmlzbm231kj0h7l8zj6mzj69r1npbzkas4bd"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)))
- (synopsis "Portable macroexpand-all for Common Lisp")
- (description
- "This library provides a macroexpand-all function that calls the
-implementation specific equivalent.")
- (license license:unlicense))))
-
-(define-public cl-trivial-macroexpand-all
- (sbcl-package->cl-source-package sbcl-trivial-macroexpand-all))
-
-(define-public ecl-trivial-macroexpand-all
- (sbcl-package->ecl-package sbcl-trivial-macroexpand-all))
-
-(define-public sbcl-serapeum
- (let ((commit "65837f8a0d65b36369ec8d000fff5c29a395b5fe")
- (revision "0"))
- (package
- (name "sbcl-serapeum")
- (version (git-version "0.0.0" revision commit))
- (home-page "https://github.com/ruricolist/serapeum")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url home-page)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "0clwf81r2lvk1rbfvk91s9zmbkas9imf57ilqclw12mxaxlfsnbw"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("trivia" ,sbcl-trivia)
- ("trivia.quasiquote" ,sbcl-trivia.quasiquote)
- ("split-sequence" ,sbcl-split-sequence)
- ("string-case" ,sbcl-string-case)
- ("parse-number" ,sbcl-parse-number)
- ("trivial-garbage" ,sbcl-trivial-garbage)
- ("bordeaux-threads" ,sbcl-bordeaux-threads)
- ("named-readtables" ,sbcl-named-readtables)
- ("fare-quasiquote-extras" ,cl-fare-quasiquote-extras)
- ("parse-declarations-1.0" ,sbcl-parse-declarations)
- ("global-vars" ,sbcl-global-vars)
- ("trivial-file-size" ,sbcl-trivial-file-size)
- ("trivial-macroexpand-all" ,sbcl-trivial-macroexpand-all)))
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)
- ("local-time" ,sbcl-local-time)))
- (arguments
- '(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'disable-failing-tests
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "serapeum.asd"
- ;; Guix does not have Quicklisp, and probably never will.
- (("\\(:file \"quicklisp\"\\)") ""))
- #t)))))
- (synopsis "Common Lisp utility library beyond Alexandria")
- (description
- "Serapeum is a conservative library of Common Lisp utilities. It is a
-supplement, not a competitor, to Alexandria.")
- (license license:expat))))
-
-(define-public cl-serapeum
- (sbcl-package->cl-source-package sbcl-serapeum))
-
-(define-public sbcl-arrows
- (let ((commit "df7cf0067e0132d9697ac8b1a4f1b9c88d4f5382")
- (revision "0"))
- (package
- (name "sbcl-arrows")
- (version (git-version "0.2.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://gitlab.com/Harleqin/arrows.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "042k9vkssrqx9nhp14wdzm942zgdxvp35mba0p2syz98i75im2yy"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- `(("hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
- (synopsis "Clojure-like arrow macros for Common Lisp")
- (description
- "This library implements the @code{->} and @code{->>} macros from
-Clojure, as well as several expansions on the idea.")
- (home-page "https://gitlab.com/Harleqin/arrows")
- (license license:public-domain))))
-
-(define-public cl-arrows
- (sbcl-package->cl-source-package sbcl-arrows))
-
-(define-public ecl-arrows
- (sbcl-package->ecl-package sbcl-arrows))
-
-(define-public sbcl-simple-parallel-tasks
- (let ((commit "db460f7a3f7bbfe2d3a2223ed21e162068d04dda")
- (revision "0"))
- (package
- (name "sbcl-simple-parallel-tasks")
- (version (git-version "1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/glv2/simple-parallel-tasks.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "0amw3qk23wnlyrsgzszs6rs7y4zvxv8dr03rnqhc60mnm8ds4dd5"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)))
- (inputs
- `(("chanl" ,sbcl-chanl)))
- (synopsis "Common Lisp library to evaluate some forms in parallel")
- (description "This is a simple Common Lisp library to evaluate some
-forms in parallel.")
- (home-page "https://github.com/glv2/simple-parallel-tasks")
- (license license:gpl3))))
-
-(define-public cl-simple-parallel-tasks
- (sbcl-package->cl-source-package sbcl-simple-parallel-tasks))
-
-(define-public ecl-simple-parallel-tasks
- (sbcl-package->ecl-package sbcl-simple-parallel-tasks))
-
-(define-public sbcl-cl-heap
- (package
- (name "sbcl-cl-heap")
- (version "0.1.6")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://common-lisp.net/project/cl-heap/releases/"
- "cl-heap_" version ".tar.gz"))
- (sha256
- (base32
- "163hb07p2nxz126rpq3cj5dyala24n0by5i5786n2qcr1w0bak4i"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- `(("xlunit" ,sbcl-xlunit)))
- (arguments
- `(#:test-asd-file "cl-heap-tests.asd"))
- (synopsis "Heap and priority queue data structures for Common Lisp")
- (description
- "CL-HEAP provides various implementations of heap data structures (a
-binary heap and a Fibonacci heap) as well as an efficient priority queue.")
- (home-page "https://common-lisp.net/project/cl-heap/")
- (license license:gpl3+)))
-
-(define-public cl-heap
- (sbcl-package->cl-source-package sbcl-cl-heap))
-
-(define-public ecl-cl-heap
- (sbcl-package->ecl-package sbcl-cl-heap))
-
-(define-public sbcl-curry-compose-reader-macros
- (let ((commit "beaa92dedf392726c042184bfd6149fa8d9e6ac2")
- (revision "0"))
- (package
- (name "sbcl-curry-compose-reader-macros")
- (version (git-version "1.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri
- (git-reference
- (url "https://github.com/eschulte/curry-compose-reader-macros.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "0rv9bl8xrad5wfcg5zs1dazvnpmvqz6297lbn8bywsrcfnlf7h98"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("named-readtables" ,sbcl-named-readtables)))
- (synopsis "Reader macros for partial application and composition")
- (description
- "This Common Lisp library provides reader macros for concise expression
-of function partial application and composition.")
- (home-page "https://eschulte.github.io/curry-compose-reader-macros/")
- (license license:public-domain))))
-
-(define-public cl-curry-compose-reader-macros
- (sbcl-package->cl-source-package sbcl-curry-compose-reader-macros))
-
-(define-public ecl-curry-compose-reader-macros
- (sbcl-package->ecl-package sbcl-curry-compose-reader-macros))
-
-(define-public sbcl-yason
- (package
- (name "sbcl-yason")
- (version "0.7.7")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/phmarek/yason.git")
- (commit (string-append "v" version))))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "0479rbjgbj80jpk5bby18inlv1kfp771a82rlcq5psrz65qqa9bj"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
- (synopsis "Common Lisp JSON parser/encoder")
- (description
- "YASON is a Common Lisp library for encoding and decoding data in the
-JSON interchange format.")
- (home-page "https://github.com/phmarek/yason")
- (license license:bsd-3)))
-
-(define-public cl-yason
- (sbcl-package->cl-source-package sbcl-yason))
-
-(define-public ecl-yason
- (sbcl-package->ecl-package sbcl-yason))
-
-(define-public sbcl-stefil
- (let ((commit "0398548ec95dceb50fc2c2c03e5fb0ce49b86c7a")
- (revision "0"))
- (package
- (name "sbcl-stefil")
- (version (git-version "0.1" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://gitlab.common-lisp.net/stefil/stefil.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "0bqz64q2szzhf91zyqyssmvrz7da6442rs01808pf3wrdq28bclh"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("iterate" ,sbcl-iterate)
- ("metabang-bind" ,sbcl-metabang-bind)))
- (propagated-inputs
- ;; Swank doesn't have a pre-compiled package, therefore we must
- ;; propagate its sources.
- `(("swank" ,cl-slime-swank)))
- (arguments
- '(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'drop-unnecessary-dependency
- (lambda _
- (substitute* "package.lisp"
- ((":stefil-system") ""))
- #t)))))
- (home-page "https://common-lisp.net/project/stefil/index-old.shtml")
- (synopsis "Simple test framework")
- (description
- "Stefil is a simple test framework for Common Lisp, with a focus on
-interactive development.")
- (license license:public-domain))))
-
-(define-public cl-stefil
- (sbcl-package->cl-source-package sbcl-stefil))
-
-(define-public sbcl-graph
- (let ((commit "78bf9ec930d8eae4f0861b5be76765fb1e45e24f")
- (revision "0"))
- (package
- (name "sbcl-graph")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri
- (git-reference
- (url "https://github.com/eschulte/graph.git")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "1qpij4xh8bqwc2myahpilcbh916v7vg0acz2fij14d3y0jm02h0g"))
- (patches (search-patches "sbcl-graph-asdf-definitions.patch"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- `(("stefil" ,sbcl-stefil)))
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-heap" ,sbcl-cl-heap)
- ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
- ("metabang-bind" ,sbcl-metabang-bind)
- ("named-readtables" ,sbcl-named-readtables)))
- (arguments
- '(#:test-asd-file "graph.test.asd"))
- (synopsis "Graph data structure and algorithms for Common Lisp")
- (description
- "The GRAPH Common Lisp library provides a data structures to represent
-graphs, as well as some graph manipulation and analysis algorithms (shortest
-path, maximum flow, minimum spanning tree, etc.).")
- (home-page "https://eschulte.github.io/graph/")
- (license license:gpl3+))))
-
-(define-public cl-graph
- (sbcl-package->cl-source-package sbcl-graph))
-
-(define-public sbcl-graph-dot
- (package
- (inherit sbcl-graph)
- (name "sbcl-graph-dot")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-ppcre" ,sbcl-cl-ppcre)
- ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
- ("graph" ,sbcl-graph)
- ("metabang-bind" ,sbcl-metabang-bind)
- ("named-readtables" ,sbcl-named-readtables)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-graph)
- ((#:asd-file _ "") "graph.dot.asd")
- ((#:asd-system-name _ #f) "graph-dot")))
- (synopsis "Serialize graphs to and from DOT format")))
-
-(define-public sbcl-graph-json
- (package
- (inherit sbcl-graph)
- (name "sbcl-graph-json")
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
- ("graph" ,sbcl-graph)
- ("metabang-bind" ,sbcl-metabang-bind)
- ("named-readtables" ,sbcl-named-readtables)
- ("yason" ,sbcl-yason)))
- (arguments
- (substitute-keyword-arguments (package-arguments sbcl-graph)
- ((#:asd-file _ "") "graph.json.asd")
- ((#:asd-system-name _ #f) "graph-json")))
- (synopsis "Serialize graphs to and from JSON format")))
diff --git a/gnu/packages/machine-learning.scm b/gnu/packages/machine-learning.scm
index b83b336d84..ff53ef5c2d 100644
--- a/gnu/packages/machine-learning.scm
+++ b/gnu/packages/machine-learning.scm
@@ -60,7 +60,7 @@
#:use-module (gnu packages gstreamer)
#:use-module (gnu packages image)
#:use-module (gnu packages linux)
- #:use-module (gnu packages lisp)
+ #:use-module (gnu packages lisp-xyz)
#:use-module (gnu packages maths)
#:use-module (gnu packages mpi)
#:use-module (gnu packages ocaml)
diff --git a/gnu/packages/web-browsers.scm b/gnu/packages/web-browsers.scm
index 6a59021ae9..29fbe17513 100644
--- a/gnu/packages/web-browsers.scm
+++ b/gnu/packages/web-browsers.scm
@@ -38,6 +38,7 @@
#:use-module (gnu packages libevent)
#:use-module (gnu packages libidn)
#:use-module (gnu packages lisp)
+ #:use-module (gnu packages lisp-xyz)
#:use-module (gnu packages lua)
#:use-module (gnu packages gnome)
#:use-module (gnu packages ncurses)
diff --git a/gnu/packages/web.scm b/gnu/packages/web.scm
index e2ca9de9e4..26c4105d2d 100644
--- a/gnu/packages/web.scm
+++ b/gnu/packages/web.scm
@@ -103,6 +103,7 @@
#:use-module (gnu packages guile)
#:use-module (gnu packages guile-xyz)
#:use-module (gnu packages java)
+ #:use-module (gnu packages javascript)
#:use-module (gnu packages jemalloc)
#:use-module (gnu packages image)
#:use-module (gnu packages imagemagick)
@@ -110,7 +111,6 @@
#:use-module (gnu packages libidn)
#:use-module (gnu packages libunistring)
#:use-module (gnu packages linux)
- #:use-module (gnu packages lisp)
#:use-module (gnu packages lua)
#:use-module (gnu packages markup)
#:use-module (gnu packages ncurses)
diff --git a/gnu/packages/wm.scm b/gnu/packages/wm.scm
index 87e62aa1aa..53dbda5942 100644
--- a/gnu/packages/wm.scm
+++ b/gnu/packages/wm.scm
@@ -25,6 +25,8 @@
;;; Copyright © 2019 Ingo Ruhnke <grumbel@gmail.com>
;;; Copyright © 2019 Tanguy Le Carrour <tanguy@bioneland.org>
;;; Copyright © 2019 John Soo <jsoo1@asu.edu>
+;;; Copyright © 2018, 2019 Pierre Langlois <pierre.langlois@gmx.com>
+;;; Copyright © 2016, 2017 Andy Patterson <ajpatter@uwaterloo.ca>
;;;
;;; This file is part of GNU Guix.
;;;
@@ -46,12 +48,14 @@
#:use-module (guix packages)
#:use-module (guix download)
#:use-module (guix git-download)
+ #:use-module (guix build-system asdf)
#:use-module (guix build-system cmake)
#:use-module (guix build-system gnu)
#:use-module (guix build-system haskell)
#:use-module (guix build-system meson)
#:use-module (guix build-system perl)
#:use-module (guix build-system python)
+ #:use-module (guix utils)
#:use-module (gnu packages)
#:use-module (gnu packages autotools)
#:use-module (gnu packages base)
@@ -73,6 +77,7 @@
#:use-module (gnu packages imagemagick)
#:use-module (gnu packages libevent)
#:use-module (gnu packages linux)
+ #:use-module (gnu packages lisp-xyz)
#:use-module (gnu packages logging)
#:use-module (gnu packages lua)
#:use-module (gnu packages m4)
@@ -87,6 +92,7 @@
#:use-module (gnu packages python)
#:use-module (gnu packages serialization)
#:use-module (gnu packages suckless)
+ #:use-module (gnu packages texinfo)
#:use-module (gnu packages textutils)
#:use-module (gnu packages version-control)
#:use-module (gnu packages video)
@@ -1485,3 +1491,118 @@ Wlroots based compositors.")
(description "Mako is a lightweight notification daemon for Wayland
compositors that support the layer-shell protocol.")
(license license:expat))) ; MIT license
+
+(define-public stumpwm
+ (package
+ (name "stumpwm")
+ (version "18.11")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/stumpwm/stumpwm.git")
+ (commit version)))
+ (file-name (git-file-name "stumpwm" version))
+ (sha256
+ (base32 "003g1fmh7446ws49866kzny4lrk1wf034dq5fa4m9mq1nzc7cwv7"))
+ (patches
+ ;; This patch is included in the post-18.11 git master tree
+ ;; and can be removed when we move to the next release.
+ (search-patches "stumpwm-fix-broken-read-one-line.patch"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs `(("fiasco" ,sbcl-fiasco)
+ ("texinfo" ,texinfo)))
+ (inputs `(("cl-ppcre" ,sbcl-cl-ppcre)
+ ("clx" ,sbcl-clx)
+ ("alexandria" ,sbcl-alexandria)))
+ (outputs '("out" "lib"))
+ (arguments
+ '(#:asd-system-name "stumpwm"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'create-symlinks 'build-program
+ (lambda* (#:key outputs #:allow-other-keys)
+ (build-program
+ (string-append (assoc-ref outputs "out") "/bin/stumpwm")
+ outputs
+ #:entry-program '((stumpwm:stumpwm) 0))))
+ (add-after 'build-program 'create-desktop-file
+ (lambda* (#:key outputs #:allow-other-keys)
+ (let* ((out (assoc-ref outputs "out"))
+ (xsessions (string-append out "/share/xsessions")))
+ (mkdir-p xsessions)
+ (call-with-output-file
+ (string-append xsessions "/stumpwm.desktop")
+ (lambda (file)
+ (format file
+ "[Desktop Entry]~@
+ Name=stumpwm~@
+ Comment=The Stump Window Manager~@
+ Exec=~a/bin/stumpwm~@
+ TryExec=~@*~a/bin/stumpwm~@
+ Icon=~@
+ Type=Application~%"
+ out)))
+ #t)))
+ (add-after 'install 'install-manual
+ (lambda* (#:key outputs #:allow-other-keys)
+ ;; The proper way to the manual is bootstrapping a full autotools
+ ;; build system and running ‘./configure && make stumpwm.info’ to
+ ;; do some macro substitution. We can get away with much less.
+ (let* ((out (assoc-ref outputs "out"))
+ (info (string-append out "/share/info")))
+ (invoke "makeinfo" "stumpwm.texi.in")
+ (install-file "stumpwm.info" info)
+ #t))))))
+ (synopsis "Window manager written in Common Lisp")
+ (description "Stumpwm is a window manager written entirely in Common Lisp.
+It attempts to be highly customizable while relying entirely on the keyboard
+for input. These design decisions reflect the growing popularity of
+productive, customizable lisp based systems.")
+ (home-page "https://github.com/stumpwm/stumpwm")
+ (license license:gpl2+)
+ (properties `((cl-source-variant . ,(delay cl-stumpwm))))))
+
+(define-public sbcl-stumpwm
+ (deprecated-package "sbcl-stumpwm" stumpwm))
+
+(define-public cl-stumpwm
+ (package
+ (inherit (sbcl-package->cl-source-package stumpwm))
+ (name "cl-stumpwm")))
+
+(define-public stumpwm+slynk
+ (package
+ (inherit stumpwm)
+ (name "stumpwm-with-slynk")
+ (outputs '("out"))
+ (inputs
+ `(("stumpwm" ,stumpwm "lib")
+ ("slynk" ,sbcl-slynk)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments stumpwm)
+ ((#:phases phases)
+ `(modify-phases ,phases
+ (replace 'build-program
+ (lambda* (#:key inputs outputs #:allow-other-keys)
+ (let* ((out (assoc-ref outputs "out"))
+ (program (string-append out "/bin/stumpwm")))
+ (build-program program outputs
+ #:entry-program '((stumpwm:stumpwm) 0)
+ #:dependencies '("stumpwm"
+ ,@(@@ (gnu packages lisp-xyz) slynk-systems))
+ #:dependency-prefixes
+ (map (lambda (input) (assoc-ref inputs input))
+ '("stumpwm" "slynk")))
+ ;; Remove unneeded file.
+ (delete-file (string-append out "/bin/stumpwm-exec.fasl"))
+ #t)))
+ (delete 'copy-source)
+ (delete 'build)
+ (delete 'check)
+ (delete 'create-asd-file)
+ (delete 'cleanup)
+ (delete 'create-symlinks)))))))
+
+(define-public sbcl-stumpwm+slynk
+ (deprecated-package "sbcl-stumpwm-with-slynk" stumpwm+slynk))