diff --git a/gnu/local.mk b/gnu/local.mk index 6c484e2046..06eb76cc2e 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 6293cf6b0f..74a44874ee 100644 --- a/gnu/packages/bioinformatics.scm +++ b/gnu/packages/bioinformatics.scm @@ -84,10 +84,10 @@ (define-module (gnu packages bioinformatics) #: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 765747ea3b..592200bb13 100644 --- a/gnu/packages/cran.scm +++ b/gnu/packages/cran.scm @@ -62,7 +62,6 @@ (define-module (gnu packages cran) #: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 @@ (define-module (gnu packages javascript) #: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 @@ (define-public mujs 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..a798eb156e --- /dev/null +++ b/gnu/packages/lisp-xyz.scm @@ -0,0 +1,7205 @@ +;;; GNU Guix --- Functional package management for GNU +;;; Copyright © 2014 John Darrington +;;; Copyright © 2015 Taylan Ulrich Bayırlı/Kammer +;;; Copyright © 2015 Mark H Weaver +;;; Copyright © 2016 Federico Beffa +;;; Copyright © 2016, 2017 ng0 +;;; Copyright © 2016, 2017 Andy Patterson +;;; Copyright © 2017, 2019 Ricardo Wurmus +;;; Copyright © 2017, 2018, 2019 Efraim Flashner +;;; Copyright © 2017, 2019 Tobias Geerinckx-Rice +;;; Copyright © 2018 Benjamin Slade +;;; Copyright © 2018 Alex Vong +;;; Copyright © 2018 Pierre Neidhardt +;;; Copyright © 2018, 2019 Pierre Langlois +;;; Copyright © 2019 Katherine Cox-Buday +;;; Copyright © 2019 Jesse Gildersleve +;;; Copyright © 2019 Guillaume Le Vaillant +;;; +;;; 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 . + +;;; 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 , 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 #. 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 #. 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 #. 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 #. 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 #. 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 #. 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 #. 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 # + '(#: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-xyz) sbcl-iolib+multiplex)) + ("iolib+syscalls" ,(@@ (gnu packages lisp-xyz) sbcl-iolib+syscalls)) + ("iolib+streams" ,(@@ (gnu packages lisp-xyz) sbcl-iolib+streams)) + ("iolib+sockets" ,(@@ (gnu packages lisp-xyz) 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 . +;;; 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 @@ (define-module (gnu packages lisp) #: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 @@ (define-module (gnu packages lisp) #: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 @@ (define-public lush2 (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 @@ (define-public confusion-mdl (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 , 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 #. 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 #. 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 #. 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 #. 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 #. 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 #. 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 #. 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 # - '(#: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 @@ (define-public txr 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 ab4150cbb1..d7df30e751 100644 --- a/gnu/packages/machine-learning.scm +++ b/gnu/packages/machine-learning.scm @@ -60,7 +60,7 @@ (define-module (gnu packages machine-learning) #: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 @@ (define-module (gnu packages web-browsers) #: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 2bcf36aef7..4c96422432 100644 --- a/gnu/packages/web.scm +++ b/gnu/packages/web.scm @@ -103,6 +103,7 @@ (define-module (gnu packages web) #: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 @@ (define-module (gnu packages web) #: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 ;;; Copyright © 2019 Tanguy Le Carrour ;;; Copyright © 2019 John Soo +;;; Copyright © 2018, 2019 Pierre Langlois +;;; Copyright © 2016, 2017 Andy Patterson ;;; ;;; This file is part of GNU Guix. ;;; @@ -46,12 +48,14 @@ (define-module (gnu packages wm) #: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 @@ (define-module (gnu packages wm) #: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 @@ (define-module (gnu packages wm) #: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 @@ (define-public mako (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)) diff --git a/guix/build-system/minify.scm b/guix/build-system/minify.scm index 21d84a179a..1418a71091 100644 --- a/guix/build-system/minify.scm +++ b/guix/build-system/minify.scm @@ -44,8 +44,8 @@ (define %minify-build-system-modules (define (default-uglify-js) "Return the default package to minify JavaScript source files." ;; Lazily resolve the binding to avoid a circular dependency. - (let ((lisp-mod (resolve-interface '(gnu packages lisp)))) - (module-ref lisp-mod 'uglify-js))) + (let ((js-mod (resolve-interface '(gnu packages javascript)))) + (module-ref js-mod 'uglify-js))) (define* (lower name #:key source inputs native-inputs outputs system