diff options
| author | Ricardo Wurmus <rekado@elephly.net> | 2019-11-28 21:09:24 +0100 |
|---|---|---|
| committer | Ricardo Wurmus <rekado@elephly.net> | 2019-11-28 21:09:24 +0100 |
| commit | 076527c354795e6e1b23a7fd827ac1ce846b06f2 (patch) | |
| tree | ef37fc4958212a370fd46b61e8a3868457cda487 /gnu/packages/lisp-xyz.scm | |
| parent | abf43a67d5929bf279edce3e790ef1348dda32a5 (diff) | |
| download | guix-076527c354795e6e1b23a7fd827ac1ce846b06f2.tar.gz | |
Revert "gnu: Move lisp libraries to lisp-xyz, uglify-js to javascript and stumpwm to wm."
This reverts commit abf43a67d5929bf279edce3e790ef1348dda32a5 as it broke "guix pull".
Diffstat (limited to 'gnu/packages/lisp-xyz.scm')
| -rw-r--r-- | gnu/packages/lisp-xyz.scm | 7205 |
1 files changed, 0 insertions, 7205 deletions
diff --git a/gnu/packages/lisp-xyz.scm b/gnu/packages/lisp-xyz.scm deleted file mode 100644 index 1f60e22150..0000000000 --- a/gnu/packages/lisp-xyz.scm +++ /dev/null @@ -1,7205 +0,0 @@ -;;; GNU Guix --- Functional package management for GNU -;;; Copyright © 2014 John Darrington <jmd@gnu.org> -;;; Copyright © 2015 Taylan Ulrich Bayırlı/Kammer <taylanbayirli@gmail.com> -;;; Copyright © 2015 Mark H Weaver <mhw@netris.org> -;;; Copyright © 2016 Federico Beffa <beffa@fbengineering.ch> -;;; Copyright © 2016, 2017 ng0 <ng0@n0.is> -;;; Copyright © 2016, 2017 Andy Patterson <ajpatter@uwaterloo.ca> -;;; Copyright © 2017, 2019 Ricardo Wurmus <rekado@elephly.net> -;;; Copyright © 2017, 2018, 2019 Efraim Flashner <efraim@flashner.co.il> -;;; Copyright © 2017, 2019 Tobias Geerinckx-Rice <me@tobias.gr> -;;; Copyright © 2018 Benjamin Slade <slade@jnanam.net> -;;; Copyright © 2018 Alex Vong <alexvong1995@gmail.com> -;;; Copyright © 2018 Pierre Neidhardt <mail@ambrevar.xyz> -;;; Copyright © 2018, 2019 Pierre Langlois <pierre.langlois@gmx.com> -;;; Copyright © 2019 Katherine Cox-Buday <cox.katherine.e@gmail.com> -;;; Copyright © 2019 Jesse Gildersleve <jessejohngildersleve@protonmail.com> -;;; Copyright © 2019 Guillaume Le Vaillant <glv@posteo.net> -;;; -;;; This file is part of GNU Guix. -;;; -;;; GNU Guix is free software; you can redistribute it and/or modify it -;;; under the terms of the GNU General Public License as published by -;;; the Free Software Foundation; either version 3 of the License, or (at -;;; your option) any later version. -;;; -;;; GNU Guix is distributed in the hope that it will be useful, but -;;; WITHOUT ANY WARRANTY; without even the implied warranty of -;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -;;; GNU General Public License for more details. -;;; -;;; You should have received a copy of the GNU General Public License -;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>. - -;;; This file only contains Common Lisp libraries. -;;; Common Lisp compilers and tooling go to lisp.scm. -;;; Common Lisp applications should go to the most appropriate file, -;;; e.g. StumpWM is in wm.scm. - -(define-module (gnu packages lisp-xyz) - #:use-module (gnu packages) - #:use-module ((guix licenses) #:prefix license:) - #:use-module (guix packages) - #:use-module (guix download) - #:use-module (guix git-download) - #:use-module (guix hg-download) - #:use-module (guix utils) - #:use-module (guix build-system asdf) - #:use-module (guix build-system trivial) - #:use-module (gnu packages c) - #:use-module (gnu packages compression) - #:use-module (gnu packages glib) - #:use-module (gnu packages gtk) - #:use-module (gnu packages libffi) - #:use-module (gnu packages lisp) - #:use-module (gnu packages pkg-config) - #:use-module (gnu packages python) - #:use-module (gnu packages python-xyz) - #:use-module (gnu packages sqlite) - #:use-module (gnu packages tls) - #:use-module (gnu packages webkit) - #:use-module (gnu packages xdisorg) - #:use-module (ice-9 match) - #:use-module (srfi srfi-19)) - -(define-public sbcl-alexandria - (let ((revision "1") - (commit "3b849bc0116ea70f215ee6b2fbf354e862aaa9dd")) - (package - (name "sbcl-alexandria") - (version (git-version "1.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://gitlab.common-lisp.net/alexandria/alexandria.git") - (commit commit))) - (sha256 - (base32 - "04amwvx2vl691f0plcfbqqwxgib9zimih7jrn5zl7mbwvrxy022b")) - (file-name (git-file-name name version)))) - (build-system asdf-build-system/sbcl) - (native-inputs - `(("rt" ,sbcl-rt))) - (synopsis "Collection of portable utilities for Common Lisp") - (description - "Alexandria is a collection of portable utilities. It does not contain -conceptual extensions to Common Lisp. It is conservative in scope, and -portable between implementations.") - (home-page "https://common-lisp.net/project/alexandria/") - (license license:public-domain)))) - -(define-public cl-alexandria - (sbcl-package->cl-source-package sbcl-alexandria)) - -(define-public ecl-alexandria - (sbcl-package->ecl-package sbcl-alexandria)) - -(define-public sbcl-net.didierverna.asdf-flv - (package - (name "sbcl-net.didierverna.asdf-flv") - (version "2.1") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/didierverna/asdf-flv") - (commit (string-append "version-" version)))) - (file-name (git-file-name "asdf-flv" version)) - (sha256 - (base32 "1fi2y4baxan103jbg4idjddzihy03kwnj2mzbwrknw4d4x7xlgwj")))) - (build-system asdf-build-system/sbcl) - (synopsis "Common Lisp ASDF extension to provide support for file-local variables") - (description "ASDF-FLV provides support for file-local variables through -ASDF. A file-local variable behaves like @code{*PACKAGE*} and -@code{*READTABLE*} with respect to @code{LOAD} and @code{COMPILE-FILE}: a new -dynamic binding is created before processing the file, so that any -modification to the variable becomes essentially file-local. - -In order to make one or several variables file-local, use the macros -@code{SET-FILE-LOCAL-VARIABLE(S)}.") - (home-page "https://www.lrde.epita.fr/~didier/software/lisp/misc.php#asdf-flv") - (license (license:non-copyleft - "https://www.gnu.org/prep/maintain/html_node/License-Notices-for-Other-Files.html" - "GNU All-Permissive License")))) - -(define-public cl-net.didierverna.asdf-flv - (sbcl-package->cl-source-package sbcl-net.didierverna.asdf-flv)) - -(define-public ecl-net.didierverna.asdf-flv - (sbcl-package->ecl-package sbcl-net.didierverna.asdf-flv)) - -(define-public sbcl-fiveam - (package - (name "sbcl-fiveam") - (version "1.4.1") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/sionescu/fiveam.git") - (commit (string-append "v" version)))) - (file-name (git-file-name "fiveam" version)) - (sha256 - (base32 "1q3d38pwafnwnw42clq0f8g5xw7pbzr287jl9jsqmb1vb0n1vrli")))) - (inputs - `(("alexandria" ,sbcl-alexandria) - ("net.didierverna.asdf-flv" ,sbcl-net.didierverna.asdf-flv) - ("trivial-backtrace" ,sbcl-trivial-backtrace))) - (build-system asdf-build-system/sbcl) - (synopsis "Common Lisp testing framework") - (description "FiveAM is a simple (as far as writing and running tests -goes) regression testing framework. It has been designed with Common Lisp's -interactive development model in mind.") - (home-page "https://common-lisp.net/project/fiveam/") - (license license:bsd-3))) - -(define-public cl-fiveam - (sbcl-package->cl-source-package sbcl-fiveam)) - -(define-public ecl-fiveam - (sbcl-package->ecl-package sbcl-fiveam)) - -(define-public sbcl-bordeaux-threads - (let ((commit "5dce49fbc829f4d136a734f5ef4f5d599660984f") - (revision "1")) - (package - (name "sbcl-bordeaux-threads") - (version (git-version "0.8.6" revision commit)) - (source (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/sionescu/bordeaux-threads.git") - (commit commit))) - (sha256 - (base32 "1gkh9rz7zw57n3110ikcf4835950wr4hgp8l79id5ai6nd86x7wv")) - (file-name - (git-file-name "bordeaux-threads" version)))) - (inputs `(("alexandria" ,sbcl-alexandria))) - (native-inputs `(("fiveam" ,sbcl-fiveam))) - (build-system asdf-build-system/sbcl) - (synopsis "Portable shared-state concurrency library for Common Lisp") - (description "BORDEAUX-THREADS is a proposed standard for a minimal -MP/Threading interface. It is similar to the CLIM-SYS threading and lock -support.") - (home-page "https://common-lisp.net/project/bordeaux-threads/") - (license license:x11)))) - -(define-public cl-bordeaux-threads - (sbcl-package->cl-source-package sbcl-bordeaux-threads)) - -(define-public ecl-bordeaux-threads - (sbcl-package->ecl-package sbcl-bordeaux-threads)) - -(define-public sbcl-trivial-gray-streams - (let ((revision "1") - (commit "0483ade330508b4b2edeabdb47d16ec9437ee1cb")) - (package - (name "sbcl-trivial-gray-streams") - (version (string-append "0.0.0-" revision "." (string-take commit 7))) - (source - (origin - (method git-fetch) - (uri - (git-reference - (url "https://github.com/trivial-gray-streams/trivial-gray-streams.git") - (commit commit))) - (sha256 - (base32 "0m3rpf2x0zmdk3nf1qfa01j6a55vj7gkwhyw78qslcgbjlgh8p4d")) - (file-name - (string-append "trivial-gray-streams-" version "-checkout")))) - (build-system asdf-build-system/sbcl) - (synopsis "Compatibility layer for Gray streams implementations") - (description "Gray streams is an interface proposed for inclusion with -ANSI CL by David N. Gray. The proposal did not make it into ANSI CL, but most -popular CL implementations implement it. This package provides an extremely -thin compatibility layer for gray streams.") - (home-page "http://www.cliki.net/trivial-gray-streams") - (license license:x11)))) - -(define-public cl-trivial-gray-streams - (sbcl-package->cl-source-package sbcl-trivial-gray-streams)) - -(define-public ecl-trivial-gray-streams - (sbcl-package->ecl-package sbcl-trivial-gray-streams)) - -(define-public sbcl-fiasco - (let ((commit "d62f7558b21addc89f87e306f65d7f760632655f") - (revision "1")) - (package - (name "sbcl-fiasco") - (version (git-version "0.0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/joaotavora/fiasco.git") - (commit commit))) - (file-name (git-file-name "fiasco" version)) - (sha256 - (base32 - "1zwxs3d6iswayavcmb49z2892xhym7n556d8dnmvalc32pm9bkjh")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("alexandria" ,sbcl-alexandria) - ("trivial-gray-streams" ,sbcl-trivial-gray-streams))) - (synopsis "Simple and powerful test framework for Common Lisp") - (description "A Common Lisp test framework that treasures your failures, -logical continuation of Stefil. It focuses on interactive debugging.") - (home-page "https://github.com/joaotavora/fiasco") - ;; LICENCE specifies this is public-domain unless the legislation - ;; doesn't allow or recognize it. In that case it falls back to a - ;; permissive licence. - (license (list license:public-domain - (license:x11-style "file://LICENCE")))))) - -(define-public cl-fiasco - (sbcl-package->cl-source-package sbcl-fiasco)) - -(define-public ecl-fiasco - (sbcl-package->ecl-package sbcl-fiasco)) - -(define-public sbcl-flexi-streams - (package - (name "sbcl-flexi-streams") - (version "1.0.16") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/edicl/flexi-streams.git") - (commit (string-append "v" version)))) - (file-name (git-file-name "flexi-streams" version)) - (sha256 - (base32 "0gvykjlmja060zqq6nn6aqxlshh6r6ijahmmgf20q0d839rwpgxc")))) - (build-system asdf-build-system/sbcl) - (arguments - `(#:phases - (modify-phases %standard-phases - (add-after 'unpack 'make-git-checkout-writable - (lambda _ - (for-each make-file-writable (find-files ".")) - #t))))) - (inputs `(("trivial-gray-streams" ,sbcl-trivial-gray-streams))) - (synopsis "Implementation of virtual bivalent streams for Common Lisp") - (description "Flexi-streams is an implementation of \"virtual\" bivalent -streams that can be layered atop real binary or bivalent streams and that can -be used to read and write character data in various single- or multi-octet -encodings which can be changed on the fly. It also supplies in-memory binary -streams which are similar to string streams.") - (home-page "http://weitz.de/flexi-streams/") - (license license:bsd-3))) - -(define-public cl-flexi-streams - (sbcl-package->cl-source-package sbcl-flexi-streams)) - -(define-public ecl-flexi-streams - (sbcl-package->ecl-package sbcl-flexi-streams)) - -(define-public sbcl-cl-ppcre - (package - (name "sbcl-cl-ppcre") - (version "2.0.11") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/edicl/cl-ppcre.git") - (commit (string-append "v" version)))) - (file-name (git-file-name "cl-ppcre" version)) - (sha256 - (base32 "0q3iany07vgqm144lw6pj0af2d3vsikpbkwcxr30fci3kzsq4f49")))) - (build-system asdf-build-system/sbcl) - (native-inputs `(("flexi-streams" ,sbcl-flexi-streams))) - (synopsis "Portable regular expression library for Common Lisp") - (description "CL-PPCRE is a portable regular expression library for Common -Lisp, which is compatible with perl. It is pretty fast, thread-safe, and -compatible with ANSI-compliant Common Lisp implementations.") - (home-page "http://weitz.de/cl-ppcre/") - (license license:bsd-2))) - -(define-public cl-ppcre - (sbcl-package->cl-source-package sbcl-cl-ppcre)) - -(define-public ecl-cl-ppcre - (sbcl-package->ecl-package sbcl-cl-ppcre)) - -(define sbcl-cl-unicode-base - (let ((revision "1") - (commit "9fcd06fba1ddc9e66aed2f2d6c32dc9b764f03ea")) - (package - (name "sbcl-cl-unicode-base") - (version (string-append "0.1.5-" revision "." (string-take commit 7))) - (source (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/edicl/cl-unicode.git") - (commit commit))) - (file-name (string-append "cl-unicode-" version "-checkout")) - (sha256 - (base32 - "1jicprb5b3bv57dy1kg03572gxkcaqdjhak00426s76g0plmx5ki")))) - (build-system asdf-build-system/sbcl) - (arguments - '(#:asd-file "cl-unicode.asd" - #:asd-system-name "cl-unicode/base")) - (inputs - `(("cl-ppcre" ,sbcl-cl-ppcre))) - (home-page "http://weitz.de/cl-unicode/") - (synopsis "Portable Unicode library for Common Lisp") - (description "CL-UNICODE is a portable Unicode library Common Lisp, which -is compatible with perl. It is pretty fast, thread-safe, and compatible with -ANSI-compliant Common Lisp implementations.") - (license license:bsd-2)))) - -(define-public sbcl-cl-unicode - (package - (inherit sbcl-cl-unicode-base) - (name "sbcl-cl-unicode") - (inputs - `(("cl-unicode/base" ,sbcl-cl-unicode-base) - ,@(package-inputs sbcl-cl-unicode-base))) - (native-inputs - `(("flexi-streams" ,sbcl-flexi-streams))) - (arguments '()))) - -(define-public ecl-cl-unicode - (sbcl-package->ecl-package sbcl-cl-unicode)) - -(define-public cl-unicode - (sbcl-package->cl-source-package sbcl-cl-unicode)) - -(define-public sbcl-clx - (package - (name "sbcl-clx") - (version "0.7.5") - (source - (origin - (method git-fetch) - (uri - (git-reference - (url "https://github.com/sharplispers/clx.git") - (commit version))) - (sha256 - (base32 - "1vi67z9hpj5rr4xcmfbfwzmlcc0ah7hzhrmfid6lqdkva238v2wf")) - (file-name (string-append "clx-" version)))) - (build-system asdf-build-system/sbcl) - (native-inputs - `(("fiasco" ,sbcl-fiasco))) - (home-page "http://www.cliki.net/portable-clx") - (synopsis "X11 client library for Common Lisp") - (description "CLX is an X11 client library for Common Lisp. The code was -originally taken from a CMUCL distribution, was modified somewhat in order to -make it compile and run under SBCL, then a selection of patches were added -from other CLXes around the net.") - (license license:x11))) - -(define-public cl-clx - (sbcl-package->cl-source-package sbcl-clx)) - -(define-public ecl-clx - (sbcl-package->ecl-package sbcl-clx)) - -(define-public sbcl-cl-ppcre-unicode - (package (inherit sbcl-cl-ppcre) - (name "sbcl-cl-ppcre-unicode") - (arguments - `(#:tests? #f ; tests fail with "Component :CL-PPCRE-TEST not found" - #:asd-file "cl-ppcre-unicode.asd")) - (inputs - `(("sbcl-cl-ppcre" ,sbcl-cl-ppcre) - ("sbcl-cl-unicode" ,sbcl-cl-unicode))))) - -;; The slynk that users expect to install includes all of slynk's contrib -;; modules. Therefore, we build the base module and all contribs first; then -;; we expose the union of these as `sbcl-slynk'. The following variable -;; describes the base module. -(define sbcl-slynk-boot0 - (let ((revision "2") - (commit "cbf84c36c4eca8b032e3fd16177a7bc02df3ec4c")) - (package - (name "sbcl-slynk-boot0") - (version (string-append "1.0.0-beta-" revision "." (string-take commit 7))) - (source - (origin - (method git-fetch) - (uri - (git-reference - (url "https://github.com/joaotavora/sly.git") - (commit commit))) - (sha256 - (base32 "13dyhsravn591p7g6is01mp2ynzjnnj7pwgi57r6xqmd4611y9vh")) - (file-name (string-append "slynk-" version "-checkout")) - (modules '((guix build utils) - (ice-9 ftw))) - (snippet - '(begin - ;; Move the contribs into the main source directory for easier - ;; access - (substitute* "slynk/slynk.asd" - (("\\.\\./contrib") - "contrib") - (("\\(defsystem :slynk/util") - "(defsystem :slynk/util :depends-on (:slynk)") - ((":depends-on \\(:slynk :slynk/util\\)") - ":depends-on (:slynk :slynk-util)")) - (substitute* "contrib/slynk-trace-dialog.lisp" - (("\\(slynk::reset-inspector\\)") ; Causes problems on load - "nil")) - (substitute* "contrib/slynk-profiler.lisp" - (("slynk:to-line") - "slynk-pprint-to-line")) - (substitute* "contrib/slynk-fancy-inspector.lisp" - (("slynk/util") "slynk-util") - ((":compile-toplevel :load-toplevel") "")) - (rename-file "contrib" "slynk/contrib") - ;; Move slynk's contents into the base directory for easier - ;; access - (for-each (lambda (file) - (unless (string-prefix? "." file) - (rename-file (string-append "slynk/" file) - (string-append "./" (basename file))))) - (scandir "slynk")) - #t)))) - (build-system asdf-build-system/sbcl) - (arguments - `(#:tests? #f ; No test suite - #:asd-system-name "slynk")) - (synopsis "Common Lisp IDE for Emacs") - (description "SLY is a fork of SLIME, an IDE backend for Common Lisp. -It also features a completely redesigned REPL based on Emacs's own -full-featured comint.el, live code annotations, and a consistent interactive -button interface. Everything can be copied to the REPL. One can create -multiple inspectors with independent history.") - (home-page "https://github.com/joaotavora/sly") - (license license:public-domain) - (properties `((cl-source-variant . ,(delay cl-slynk))))))) - -(define-public cl-slynk - (package - (inherit (sbcl-package->cl-source-package sbcl-slynk-boot0)) - (name "cl-slynk"))) - -(define ecl-slynk-boot0 - (sbcl-package->ecl-package sbcl-slynk-boot0)) - -(define sbcl-slynk-arglists - (package - (inherit sbcl-slynk-boot0) - (name "sbcl-slynk-arglists") - (inputs `(("slynk" ,sbcl-slynk-boot0))) - (arguments - (substitute-keyword-arguments (package-arguments sbcl-slynk-boot0) - ((#:asd-file _ "") "slynk.asd") - ((#:asd-system-name _ #f) "slynk/arglists"))))) - -(define ecl-slynk-arglists - (sbcl-package->ecl-package sbcl-slynk-arglists)) - -(define sbcl-slynk-util - (package - (inherit sbcl-slynk-boot0) - (name "sbcl-slynk-util") - (inputs `(("slynk" ,sbcl-slynk-boot0))) - (arguments - (substitute-keyword-arguments (package-arguments sbcl-slynk-boot0) - ((#:asd-file _ "") "slynk.asd") - ((#:asd-system-name _ #f) "slynk/util"))))) - -(define ecl-slynk-util - (sbcl-package->ecl-package sbcl-slynk-util)) - -(define sbcl-slynk-fancy-inspector - (package - (inherit sbcl-slynk-arglists) - (name "sbcl-slynk-fancy-inspector") - (inputs `(("slynk-util" ,sbcl-slynk-util) - ,@(package-inputs sbcl-slynk-arglists))) - (arguments - (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists) - ((#:asd-system-name _ #f) "slynk/fancy-inspector"))))) - -(define ecl-slynk-fancy-inspector - (sbcl-package->ecl-package sbcl-slynk-fancy-inspector)) - -(define sbcl-slynk-package-fu - (package - (inherit sbcl-slynk-arglists) - (name "sbcl-slynk-package-fu") - (arguments - (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists) - ((#:asd-system-name _ #f) "slynk/package-fu"))))) - -(define ecl-slynk-package-fu - (sbcl-package->ecl-package sbcl-slynk-package-fu)) - -(define sbcl-slynk-mrepl - (package - (inherit sbcl-slynk-fancy-inspector) - (name "sbcl-slynk-mrepl") - (arguments - (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists) - ((#:asd-system-name _ #f) "slynk/mrepl"))))) - -(define ecl-slynk-mrepl - (sbcl-package->ecl-package sbcl-slynk-mrepl)) - -(define sbcl-slynk-trace-dialog - (package - (inherit sbcl-slynk-arglists) - (name "sbcl-slynk-trace-dialog") - (arguments - (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists) - ((#:asd-system-name _ #f) "slynk/trace-dialog"))))) - -(define ecl-slynk-trace-dialog - (sbcl-package->ecl-package sbcl-slynk-trace-dialog)) - -(define sbcl-slynk-profiler - (package - (inherit sbcl-slynk-arglists) - (name "sbcl-slynk-profiler") - (arguments - (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists) - ((#:asd-system-name _ #f) "slynk/profiler"))))) - -(define ecl-slynk-profiler - (sbcl-package->ecl-package sbcl-slynk-profiler)) - -(define sbcl-slynk-stickers - (package - (inherit sbcl-slynk-arglists) - (name "sbcl-slynk-stickers") - (arguments - (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists) - ((#:asd-system-name _ #f) "slynk/stickers"))))) - -(define ecl-slynk-stickers - (sbcl-package->ecl-package sbcl-slynk-stickers)) - -(define sbcl-slynk-indentation - (package - (inherit sbcl-slynk-arglists) - (name "sbcl-slynk-indentation") - (arguments - (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists) - ((#:asd-system-name _ #f) "slynk/indentation"))))) - -(define ecl-slynk-indentation - (sbcl-package->ecl-package sbcl-slynk-indentation)) - -(define sbcl-slynk-retro - (package - (inherit sbcl-slynk-arglists) - (name "sbcl-slynk-retro") - (arguments - (substitute-keyword-arguments (package-arguments sbcl-slynk-arglists) - ((#:asd-system-name _ #f) "slynk/retro"))))) - -(define ecl-slynk-retro - (sbcl-package->ecl-package sbcl-slynk-retro)) - -(define slynk-systems - '("slynk" - "slynk-util" - "slynk-arglists" - "slynk-fancy-inspector" - "slynk-package-fu" - "slynk-mrepl" - "slynk-profiler" - "slynk-trace-dialog" - "slynk-stickers" - "slynk-indentation" - "slynk-retro")) - -(define-public sbcl-slynk - (package - (inherit sbcl-slynk-boot0) - (name "sbcl-slynk") - (inputs - `(("slynk" ,sbcl-slynk-boot0) - ("slynk-util" ,sbcl-slynk-util) - ("slynk-arglists" ,sbcl-slynk-arglists) - ("slynk-fancy-inspector" ,sbcl-slynk-fancy-inspector) - ("slynk-package-fu" ,sbcl-slynk-package-fu) - ("slynk-mrepl" ,sbcl-slynk-mrepl) - ("slynk-profiler" ,sbcl-slynk-profiler) - ("slynk-trace-dialog" ,sbcl-slynk-trace-dialog) - ("slynk-stickers" ,sbcl-slynk-stickers) - ("slynk-indentation" ,sbcl-slynk-indentation) - ("slynk-retro" ,sbcl-slynk-retro))) - (native-inputs `(("sbcl" ,sbcl))) - (build-system trivial-build-system) - (source #f) - (outputs '("out" "image")) - (arguments - `(#:modules ((guix build union) - (guix build utils) - (guix build lisp-utils)) - #:builder - (begin - (use-modules (ice-9 match) - (srfi srfi-1) - (guix build union) - (guix build lisp-utils)) - - (union-build - (assoc-ref %outputs "out") - (filter-map - (match-lambda - ((name . path) - (if (string-prefix? "slynk" name) path #f))) - %build-inputs)) - - (prepend-to-source-registry - (string-append (assoc-ref %outputs "out") "//")) - - (parameterize ((%lisp-type "sbcl") - (%lisp (string-append (assoc-ref %build-inputs "sbcl") - "/bin/sbcl"))) - (build-image (string-append - (assoc-ref %outputs "image") - "/bin/slynk") - %outputs - #:dependencies ',slynk-systems)) - #t))))) - -(define-public ecl-slynk - (package - (inherit sbcl-slynk) - (name "ecl-slynk") - (inputs - (map (match-lambda - ((name pkg . _) - (list name (sbcl-package->ecl-package pkg)))) - (package-inputs sbcl-slynk))) - (native-inputs '()) - (outputs '("out")) - (arguments - '(#:modules ((guix build union)) - #:builder - (begin - (use-modules (ice-9 match) - (guix build union)) - (match %build-inputs - (((names . paths) ...) - (union-build (assoc-ref %outputs "out") - paths) - #t))))))) - -(define-public sbcl-parse-js - (let ((commit "fbadc6029bec7039602abfc06c73bb52970998f6") - (revision "1")) - (package - (name "sbcl-parse-js") - (version (string-append "0.0.0-" revision "." (string-take commit 9))) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "http://marijn.haverbeke.nl/git/parse-js") - (commit commit))) - (file-name (string-append name "-" commit "-checkout")) - (sha256 - (base32 - "1wddrnr5kiya5s3gp4cdq6crbfy9fqcz7fr44p81502sj3bvdv39")))) - (build-system asdf-build-system/sbcl) - (home-page "http://marijnhaverbeke.nl/parse-js/") - (synopsis "Parse JavaScript") - (description "Parse-js is a Common Lisp package for parsing -JavaScript (ECMAScript 3). It has basic support for ECMAScript 5.") - (license license:zlib)))) - -(define-public cl-parse-js - (sbcl-package->cl-source-package sbcl-parse-js)) - -(define-public sbcl-parse-number - (package - (name "sbcl-parse-number") - (version "1.7") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/sharplispers/parse-number/") - (commit (string-append "v" version)))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "0sk06ib1bhqv9y39vwnnw44vmbc4b0kvqm37xxmkxd4dwchq82d7")))) - (build-system asdf-build-system/sbcl) - (home-page "http://www.cliki.net/PARSE-NUMBER") - (synopsis "Parse numbers") - (description "@code{parse-number} is a library of functions for parsing -strings into one of the standard Common Lisp number types without using the -reader. @code{parse-number} accepts an arbitrary string and attempts to parse -the string into one of the standard Common Lisp number types, if possible, or -else @code{parse-number} signals an error of type @code{invalid-number}.") - (license license:bsd-3))) - -(define-public cl-parse-number - (sbcl-package->cl-source-package sbcl-parse-number)) - -(define-public sbcl-iterate - (package - (name "sbcl-iterate") - ;; The latest official release (1.4.3) fails to build so we have to take - ;; the current darcs tarball from quicklisp. - (version "20160825") - (source - (origin - (method url-fetch) - (uri (string-append "http://beta.quicklisp.org/archive/iterate/" - "2016-08-25/iterate-" - version "-darcs.tgz")) - (sha256 - (base32 - "0kvz16gnxnkdz0fy1x8y5yr28nfm7i2qpvix7mgwccdpjmsb4pgm")))) - (build-system asdf-build-system/sbcl) - (native-inputs - `(("rt" ,sbcl-rt))) - (home-page "https://common-lisp.net/project/iterate/") - (synopsis "Iteration construct for Common Lisp") - (description "@code{iterate} is an iteration construct for Common Lisp. -It is similar to the @code{CL:LOOP} macro, with these distinguishing marks: - -@itemize -@item it is extensible, -@item it helps editors like Emacs indent iterate forms by having a more - lisp-like syntax, and -@item it isn't part of the ANSI standard for Common Lisp. -@end itemize\n") - (license license:expat))) - -(define-public cl-iterate - (sbcl-package->cl-source-package sbcl-iterate)) - -(define-public ecl-iterate - (sbcl-package->ecl-package sbcl-iterate)) - -(define-public sbcl-cl-uglify-js - ;; There have been many bug fixes since the 2010 release. - (let ((commit "429c5e1d844e2f96b44db8fccc92d6e8e28afdd5") - (revision "1")) - (package - (name "sbcl-cl-uglify-js") - (version (string-append "0.1-" revision "." (string-take commit 9))) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/mishoo/cl-uglify-js.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "0k39y3c93jgxpr7gwz7w0d8yknn1fdnxrjhd03057lvk5w8js27a")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("sbcl-parse-js" ,sbcl-parse-js) - ("sbcl-cl-ppcre" ,sbcl-cl-ppcre) - ("sbcl-cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode) - ("sbcl-parse-number" ,sbcl-parse-number) - ("sbcl-iterate" ,sbcl-iterate))) - (home-page "https://github.com/mishoo/cl-uglify-js") - (synopsis "JavaScript compressor library for Common Lisp") - (description "This is a Common Lisp version of UglifyJS, a JavaScript -compressor. It works on data produced by @code{parse-js} to generate a -@dfn{minified} version of the code. Currently it can: - -@itemize -@item reduce variable names (usually to single letters) -@item join consecutive @code{var} statements -@item resolve simple binary expressions -@item group most consecutive statements using the @code{sequence} operator (comma) -@item remove unnecessary blocks -@item convert @code{IF} expressions in various ways that result in smaller code -@item remove some unreachable code -@end itemize\n") - (license license:zlib)))) - -(define-public cl-uglify-js - (sbcl-package->cl-source-package sbcl-cl-uglify-js)) - -(define-public sbcl-cl-strings - (let ((revision "1") - (commit "c5c5cbafbf3e6181d03c354d66e41a4f063f00ae")) - (package - (name "sbcl-cl-strings") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/diogoalexandrefranco/cl-strings") - (commit commit))) - (sha256 - (base32 - "00754mfaqallj480lwd346nkfb6ra8pa8xcxcylf4baqn604zlmv")) - (file-name (string-append "cl-strings-" version "-checkout")))) - (build-system asdf-build-system/sbcl) - (synopsis "Portable, dependency-free set of utilities to manipulate strings in Common Lisp") - (description - "@command{cl-strings} is a small, portable, dependency-free set of -utilities that make it even easier to manipulate text in Common Lisp. It has -100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.") - (home-page "https://github.com/diogoalexandrefranco/cl-strings") - (license license:expat)))) - -(define-public cl-strings - (sbcl-package->cl-source-package sbcl-cl-strings)) - -(define-public ecl-cl-strings - (sbcl-package->ecl-package sbcl-cl-strings)) - -(define-public sbcl-trivial-features - (package - (name "sbcl-trivial-features") - (version "0.8") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/trivial-features/trivial-features.git") - (commit (string-append "v" version)))) - (file-name (git-file-name "trivial-features" version)) - (sha256 - (base32 "0ccv7dqyrk55xga78i5vzlic7mdwp28in3g1a8fqhlk6626scsq9")))) - (build-system asdf-build-system/sbcl) - (arguments '(#:tests? #f)) - (home-page "http://cliki.net/trivial-features") - (synopsis "Ensures consistency of @code{*FEATURES*} in Common Lisp") - (description "Trivial-features ensures that @code{*FEATURES*} is -consistent across multiple Common Lisp implementations.") - (license license:expat))) - -(define-public cl-trivial-features - (sbcl-package->cl-source-package sbcl-trivial-features)) - -(define-public ecl-trivial-features - (sbcl-package->ecl-package sbcl-trivial-features)) - -(define-public sbcl-hu.dwim.asdf - (package - (name "sbcl-hu.dwim.asdf") - (version "20190521") - (source - (origin - (method url-fetch) - (uri (string-append "http://beta.quicklisp.org/archive/hu.dwim.asdf/" - "2019-05-21/hu.dwim.asdf-" version "-darcs.tgz")) - (sha256 - (base32 - "0rsbv71vyszy8w35yjwb5h6zcmknjq223hkzir79y72qdsc6sabn")))) - (build-system asdf-build-system/sbcl) - (home-page "https://hub.darcs.net/hu.dwim/hu.dwim.asdf") - (synopsis "Extensions to ASDF") - (description "Various ASDF extensions such as attached test and -documentation system, explicit development support, etc.") - (license license:public-domain))) - -(define-public cl-hu.dwim.asdf - (sbcl-package->cl-source-package sbcl-hu.dwim.asdf)) - -(define-public ecl-hu.dwim.asdf - (sbcl-package->ecl-package sbcl-hu.dwim.asdf)) - -(define-public sbcl-hu.dwim.stefil - (let ((commit "ab6d1aa8995878a1b66d745dfd0ba021090bbcf9")) - (package - (name "sbcl-hu.dwim.stefil") - (version (git-version "0.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri - (git-reference - (url "https://gitlab.common-lisp.net/xcvb/hu.dwim.stefil.git") - (commit commit))) - (sha256 - (base32 "1d8yccw65zj3zh46cbi3x6nmn1dwdb76s9d0av035077mvyirqqp")) - (file-name (git-file-name "hu.dwim.stefil" version)))) - (build-system asdf-build-system/sbcl) - (native-inputs - `(("asdf:cl-hu.dwim.asdf" ,sbcl-hu.dwim.asdf))) - (inputs - `(("sbcl-alexandria" ,sbcl-alexandria))) - (home-page "https://hub.darcs.net/hu.dwim/hu.dwim.stefil") - (synopsis "Simple test framework") - (description "Stefil is a simple test framework for Common Lisp, -with a focus on interactive development.") - (license license:public-domain)))) - -(define-public cl-hu.dwim.stefil - (sbcl-package->cl-source-package sbcl-hu.dwim.stefil)) - -(define-public ecl-hu.dwim.stefil - (sbcl-package->ecl-package sbcl-hu.dwim.stefil)) - -(define-public sbcl-babel - (package - (name "sbcl-babel") - (version "0.5.0") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/cl-babel/babel.git") - (commit (string-append "v" version)))) - (file-name (git-file-name "babel" version)) - (sha256 - (base32 "139a8rn2gnhj082n8jg01gc8fyr63hkj57hgrnmb3d1r327yc77f")))) - (build-system asdf-build-system/sbcl) - (native-inputs - `(("tests:cl-hu.dwim.stefil" ,sbcl-hu.dwim.stefil))) - (inputs - `(("sbcl-alexandria" ,sbcl-alexandria) - ("sbcl-trivial-features" ,sbcl-trivial-features))) - (home-page "https://common-lisp.net/project/babel/") - (synopsis "Charset encoding and decoding library") - (description "Babel is a charset encoding and decoding library, not unlike -GNU libiconv, but completely written in Common Lisp.") - (license license:expat))) - -(define-public cl-babel - (sbcl-package->cl-source-package sbcl-babel)) - -(define-public ecl-babel - (sbcl-package->ecl-package sbcl-babel)) - -(define-public sbcl-cl-yacc - (package - (name "sbcl-cl-yacc") - (version "0.3") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/jech/cl-yacc") - (commit (string-append "cl-yacc-" version)))) - (sha256 - (base32 - "16946pzf8vvadnyfayvj8rbh4zjzw90h0azz2qk1mxrvhh5wklib")) - (file-name (string-append "cl-yacc-" version "-checkout")))) - (build-system asdf-build-system/sbcl) - (arguments - `(#:asd-file "yacc.asd" - #:asd-system-name "yacc")) - (synopsis "LALR(1) parser generator for Common Lisp, similar in spirit to Yacc") - (description - "CL-Yacc is a LALR(1) parser generator for Common Lisp, similar in spirit -to AT&T Yacc, Berkeley Yacc, GNU Bison, Zebu, lalr.cl or lalr.scm. - -CL-Yacc uses the algorithm due to Aho and Ullman, which is the one also used -by AT&T Yacc, Berkeley Yacc and Zebu. It does not use the faster algorithm due -to DeRemer and Pennello, which is used by Bison and lalr.scm (not lalr.cl).") - (home-page "https://www.irif.fr/~jch//software/cl-yacc/") - (license license:expat))) - -(define-public cl-yacc - (sbcl-package->cl-source-package sbcl-cl-yacc)) - -(define-public ecl-cl-yacc - (sbcl-package->ecl-package sbcl-cl-yacc)) - -(define-public sbcl-jpl-util - (let ((commit "0311ed374e19a49d43318064d729fe3abd9a3b62")) - (package - (name "sbcl-jpl-util") - (version "20151005") - (source - (origin - (method git-fetch) - (uri (git-reference - ;; Quicklisp uses this fork. - (url "https://github.com/hawkir/cl-jpl-util") - (commit commit))) - (file-name - (git-file-name "jpl-util" version)) - (sha256 - (base32 - "0nc0rk9n8grkg3045xsw34whmcmddn2sfrxki4268g7kpgz0d2yz")))) - (build-system asdf-build-system/sbcl) - (synopsis "Collection of Common Lisp utility functions and macros") - (description - "@command{cl-jpl-util} is a collection of Common Lisp utility functions -and macros, primarily for software projects written in CL by the author.") - (home-page "https://www.thoughtcrime.us/software/cl-jpl-util/") - (license license:isc)))) - -(define-public cl-jpl-util - (sbcl-package->cl-source-package sbcl-jpl-util)) - -(define-public ecl-jpl-util - (sbcl-package->ecl-package sbcl-jpl-util)) - -(define-public sbcl-jpl-queues - (package - (name "sbcl-jpl-queues") - (version "0.1") - (source - (origin - (method url-fetch) - (uri (string-append - "http://www.thoughtcrime.us/software/jpl-queues/jpl-queues-" - version - ".tar.gz")) - (sha256 - (base32 - "1wvvv7j117h9a42qaj1g4fh4mji28xqs7s60rn6d11gk9jl76h96")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("jpl-util" ,sbcl-jpl-util) - ("bordeaux-threads" ,sbcl-bordeaux-threads))) - (arguments - ;; Tests seem to be broken. - `(#:tests? #f)) - (synopsis "Common Lisp library implementing a few different kinds of queues") - (description - "A Common Lisp library implementing a few different kinds of queues: - -@itemize -@item Bounded and unbounded FIFO queues. -@item Lossy bounded FIFO queues that drop elements when full. -@item Unbounded random-order queues that use less memory than unbounded FIFO queues. -@end itemize - -Additionally, a synchronization wrapper is provided to make any queue -conforming to the @command{jpl-queues} API thread-safe for lightweight -multithreading applications. (See Calispel for a more sophisticated CL -multithreaded message-passing library with timeouts and alternation among -several blockable channels.)") - (home-page "https://www.thoughtcrime.us/software/jpl-queues/") - (license license:isc))) - -(define-public cl-jpl-queues - (sbcl-package->cl-source-package sbcl-jpl-queues)) - -(define-public ecl-jpl-queues - (sbcl-package->ecl-package sbcl-jpl-queues)) - -(define-public sbcl-eos - (let ((commit "b0faca83781ead9a588661e37bd47f90362ccd94")) - (package - (name "sbcl-eos") - (version (git-version "0.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/adlai/Eos") - (commit commit))) - (sha256 - (base32 - "1bq8cfg087iyxmxi1mwgx5cfgy3b8ydrf81xljcis8qbgb2vszph")) - (file-name (git-file-name "eos" version)))) - (build-system asdf-build-system/sbcl) - (synopsis "Unit Testing for Common Lisp") - (description - "Eos was a unit testing library for Common Lisp. -It began as a fork of FiveAM; however, FiveAM development has continued, while -that of Eos has not. Thus, Eos is now deprecated in favor of FiveAM.") - (home-page "https://github.com/adlai/Eos") - (license license:expat)))) - -(define-public cl-eos - (sbcl-package->cl-source-package sbcl-eos)) - -(define-public ecl-eos - (sbcl-package->ecl-package sbcl-eos)) - -(define-public sbcl-esrap - (let ((commit "133be8b05c2aae48696fe5b739eea2fa573fa48d")) - (package - (name "sbcl-esrap") - (version (git-version "0.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/nikodemus/esrap") - (commit commit))) - (sha256 - (base32 - "02d5clihsdryhf7pix8c5di2571fdsffh75d40fkzhws90r5mksl")) - (file-name (git-file-name "esrap" version)))) - (build-system asdf-build-system/sbcl) - (native-inputs - `(("eos" ,sbcl-eos))) ;For testing only. - (inputs - `(("alexandria" ,sbcl-alexandria))) - (synopsis "Common Lisp packrat parser") - (description - "A packrat parser for Common Lisp. -In addition to regular Packrat / Parsing Grammar / TDPL features ESRAP supports: - -@itemize -@item dynamic redefinition of nonterminals -@item inline grammars -@item semantic predicates -@item introspective facilities (describing grammars, tracing, setting breaks) -@end itemize\n") - (home-page "https://nikodemus.github.io/esrap/") - (license license:expat)))) - -(define-public cl-esrap - (sbcl-package->cl-source-package sbcl-esrap)) - -(define-public ecl-esrap - (sbcl-package->ecl-package sbcl-esrap)) - -(define-public sbcl-split-sequence - (package - (name "sbcl-split-sequence") - (version "1.4.1") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/sharplispers/split-sequence") - (commit (string-append "v" version)))) - (sha256 - (base32 - "0c3zp6b7fmmp93sfhq112ind4zkld49ycw68z409xpnz3gc0wpf0")) - (file-name (git-file-name "split-sequence" version)))) - (build-system asdf-build-system/sbcl) - (arguments - ;; TODO: Tests seem to be broken. - ;; https://github.com/sharplispers/split-sequence/issues/8 - `(#:tests? #f)) - (synopsis "Member of the Common Lisp Utilities family of programs") - (description - "Splits sequence into a list of subsequences delimited by objects -satisfying the test.") - (home-page "https://cliki.net/split-sequence") - (license license:expat))) - -(define-public cl-split-sequence - (sbcl-package->cl-source-package sbcl-split-sequence)) - -(define-public ecl-split-sequence - (sbcl-package->ecl-package sbcl-split-sequence)) - -(define-public sbcl-html-encode - (package - (name "sbcl-html-encode") - (version "1.2") - (source - (origin - (method url-fetch) - (uri (string-append - "http://beta.quicklisp.org/archive/html-encode/2010-10-06/html-encode-" - version ".tgz")) - (sha256 - (base32 - "06mf8wn95yf5swhmzk4vp0xr4ylfl33dgfknkabbkd8n6jns8gcf")) - (file-name (string-append "colorize" version "-checkout")))) - (build-system asdf-build-system/sbcl) - (synopsis "Common Lisp library for encoding text in various web-savvy encodings") - (description - "A library for encoding text in various web-savvy encodings.") - (home-page "http://quickdocs.org/html-encode/") - (license license:expat))) - -(define-public cl-html-encode - (sbcl-package->cl-source-package sbcl-html-encode)) - -(define-public ecl-html-encode - (sbcl-package->ecl-package sbcl-html-encode)) - -(define-public sbcl-colorize - (let ((commit "ea676b584e0899cec82f21a9e6871172fe3c0eb5")) - (package - (name "sbcl-colorize") - (version (git-version "0.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/kingcons/colorize") - (commit commit))) - (sha256 - (base32 - "1pdg4kiaczmr3ivffhirp7m3lbr1q27rn7dhaay0vwghmi31zcw9")) - (file-name (git-file-name "colorize" version)))) - (build-system asdf-build-system/sbcl) - (inputs - `(("alexandria" ,sbcl-alexandria) - ("split-sequence" ,sbcl-split-sequence) - ("html-encode" ,sbcl-html-encode))) - (synopsis "Common Lisp for syntax highlighting") - (description - "@command{colorize} is a Lisp library for syntax highlighting -supporting the following languages: Common Lisp, Emacs Lisp, Scheme, Clojure, -C, C++, Java, Python, Erlang, Haskell, Objective-C, Diff, Webkit.") - (home-page "https://github.com/kingcons/colorize") - ;; TODO: Missing license? - (license license:expat)))) - -(define-public cl-colorize - (sbcl-package->cl-source-package sbcl-colorize)) - -(define-public ecl-colorize - (sbcl-package->ecl-package sbcl-colorize)) - -(define-public sbcl-3bmd - (let ((commit "192ea13435b605a96ef607df51317056914cabbd")) - (package - (name "sbcl-3bmd") - (version (git-version "0.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/3b/3bmd") - (commit commit))) - (sha256 - (base32 - "1rgv3gi7wf963ikmmpk132wgn0icddf226gq3bmcnk1fr3v9gf2f")) - (file-name (git-file-name "3bmd" version)))) - (build-system asdf-build-system/sbcl) - (arguments - ;; FIXME: We need to specify the name because the build-system thinks - ;; "3" is a version marker. - `(#:asd-system-name "3bmd")) - (inputs - `(("esrap" ,sbcl-esrap) - ("split-sequence" ,sbcl-split-sequence))) - (synopsis "Markdown processor in Command Lisp using esrap parser") - (description - "Common Lisp Markdown -> HTML converter, using @command{esrap} for -parsing, and grammar based on @command{peg-markdown}.") - (home-page "https://github.com/3b/3bmd") - (license license:expat)))) - -(define-public cl-3bmd - (sbcl-package->cl-source-package sbcl-3bmd)) - -(define-public ecl-3bmd - (sbcl-package->ecl-package sbcl-3bmd)) - -(define-public sbcl-3bmd-ext-code-blocks - (let ((commit "192ea13435b605a96ef607df51317056914cabbd")) - (package - (inherit sbcl-3bmd) - (name "sbcl-3bmd-ext-code-blocks") - (arguments - `(#:asd-system-name "3bmd-ext-code-blocks" - #:asd-file "3bmd-ext-code-blocks.asd")) - (inputs - `(("3bmd" ,sbcl-3bmd) - ("colorize" ,sbcl-colorize))) - (synopsis "3bmd extension which adds support for GitHub-style fenced -code blocks") - (description - "3bmd extension which adds support for GitHub-style fenced code blocks, -with @command{colorize} support.")))) - -(define-public cl-3bmd-ext-code-blocks - (sbcl-package->cl-source-package sbcl-3bmd-ext-code-blocks)) - -(define-public ecl-3bmd-ext-code-blocks - (sbcl-package->ecl-package sbcl-3bmd-ext-code-blocks)) - -(define-public sbcl-cl-fad - (package - (name "sbcl-cl-fad") - (version "0.7.5") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/edicl/cl-fad/") - (commit (string-append "v" version)))) - (sha256 - (base32 - "1l1qmk9z57q84bz5r04sxsksggsnd7dgkxlybzh9imz6ma7sm52m")) - (file-name (string-append "cl-fad" version "-checkout")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("bordeaux-threads" ,sbcl-bordeaux-threads))) - (synopsis "Portable pathname library for Common Lisp") - (description - "CL-FAD (for \"Files and Directories\") is a thin layer atop Common -Lisp's standard pathname functions. It is intended to provide some -unification between current CL implementations on Windows, OS X, Linux, and -Unix. Most of the code was written by Peter Seibel for his book Practical -Common Lisp.") - (home-page "https://edicl.github.io/cl-fad/") - (license license:bsd-2))) - -(define-public cl-fad - (sbcl-package->cl-source-package sbcl-cl-fad)) - -(define-public ecl-cl-fad - (sbcl-package->ecl-package sbcl-cl-fad)) - -(define-public sbcl-rt - (package - (name "sbcl-rt") - (version "1990.12.19") - (source - (origin - (method url-fetch) - (uri (string-append "http://beta.quicklisp.org/archive/rt/2010-10-06/rt-" - "20101006-git" ".tgz")) - (sha256 - (base32 - "1jncar0xwkqk8yrc2dln389ivvgzs7ijdhhs3zpfyi5d21f0qa1v")))) - (build-system asdf-build-system/sbcl) - (synopsis "MIT Regression Tester") - (description - "RT provides a framework for writing regression test suites.") - (home-page "https://github.com/sharplispers/nibbles") - (license license:unlicense))) - -(define-public cl-rt - (sbcl-package->cl-source-package sbcl-rt)) - -(define-public ecl-rt - (sbcl-package->ecl-package sbcl-rt)) - -(define-public sbcl-nibbles - (package - (name "sbcl-nibbles") - (version "0.14") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/sharplispers/nibbles/") - (commit (string-append "v" version)))) - (sha256 - (base32 - "1v7qfgpvdr6nz7v63dj69d26dis0kff3rd8xamr1llfdvza2pm8f")) - (file-name (git-file-name "nibbles" version)))) - (build-system asdf-build-system/sbcl) - (native-inputs - ;; Tests only. - `(("rt" ,sbcl-rt))) - (synopsis "Common Lisp library for accessing octet-addressed blocks of data") - (description - "When dealing with network protocols and file formats, it's common to -have to read or write 16-, 32-, or 64-bit datatypes in signed or unsigned -flavors. Common Lisp sort of supports this by specifying :element-type for -streams, but that facility is underspecified and there's nothing similar for -read/write from octet vectors. What most people wind up doing is rolling their -own small facility for their particular needs and calling it a day. - -This library attempts to be comprehensive and centralize such -facilities. Functions to read 16-, 32-, and 64-bit quantities from octet -vectors in signed or unsigned flavors are provided; these functions are also -SETFable. Since it's sometimes desirable to read/write directly from streams, -functions for doing so are also provided. On some implementations, -reading/writing IEEE singles/doubles (i.e. single-float and double-float) will -also be supported.") - (home-page "https://github.com/sharplispers/nibbles") - (license license:bsd-3))) - -(define-public cl-nibbles - (sbcl-package->cl-source-package sbcl-nibbles)) - -(define-public ecl-nibbles - (sbcl-package->ecl-package sbcl-nibbles)) - -(define-public sbcl-ironclad - (package - (name "sbcl-ironclad") - (version "0.46") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/sharplispers/ironclad/") - (commit (string-append "v" version)))) - (sha256 - (base32 - "1s391awi2lsl7m1dbjirgpkm4p9p8wd076pakgvsvpn1rrznisnd")) - (file-name (git-file-name name version)))) - (build-system asdf-build-system/sbcl) - (native-inputs - ;; Tests only. - `(("rt" ,sbcl-rt))) - (inputs - `(("bordeaux-threads" ,sbcl-bordeaux-threads) - ("flexi-streams" ,sbcl-flexi-streams) - ("nibbles" ,sbcl-nibbles))) - (synopsis "Cryptographic toolkit written in Common Lisp") - (description - "Ironclad is a cryptography library written entirely in Common Lisp. -It includes support for several popular ciphers, digests, MACs and public key -cryptography algorithms. For several implementations that support Gray -streams, support is included for convenient stream wrappers.") - (home-page "https://github.com/sharplispers/ironclad") - (license license:bsd-3))) - -(define-public cl-ironclad - (sbcl-package->cl-source-package sbcl-ironclad)) - -(define-public ecl-ironclad - (sbcl-package->ecl-package sbcl-ironclad)) - -(define-public sbcl-named-readtables - (let ((commit "4dfb89fa1af6b305b6492b8af042f5190c11e9fc") - (revision "1")) - (package - (name "sbcl-named-readtables") - (version (string-append "0.9-" revision "." (string-take commit 7))) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/melisgl/named-readtables.git") - (commit commit))) - (sha256 - (base32 "083kgh5462iqbb4px6kq8s7sggvpvkm36hx4qi9rnaw53b6ilqkk")) - (file-name (git-file-name "named-readtables" version)))) - (build-system asdf-build-system/sbcl) - (arguments - ;; Tests seem to be broken. - `(#:tests? #f)) - (home-page "https://github.com/melisgl/named-readtables/") - (synopsis "Library that creates a namespace for named readtables") - (description "Named readtables is a library that creates a namespace for -named readtables, which is akin to package namespacing in Common Lisp.") - (license license:bsd-3)))) - -(define-public cl-named-readtables - (sbcl-package->cl-source-package sbcl-named-readtables)) - -(define-public ecl-named-readtables - (sbcl-package->ecl-package sbcl-named-readtables)) - -(define-public sbcl-pythonic-string-reader - (let ((commit "47a70ba1e32362e03dad6ef8e6f36180b560f86a")) - (package - (name "sbcl-pythonic-string-reader") - (version (git-version "0.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/smithzvk/pythonic-string-reader/") - (commit commit))) - (sha256 - (base32 "1b5iryqw8xsh36swckmz8rrngmc39k92si33fgy5pml3n9l5rq3j")) - (file-name (git-file-name "pythonic-string-reader" version)))) - (build-system asdf-build-system/sbcl) - (inputs - `(("named-readtables" ,sbcl-named-readtables))) - (home-page "https://github.com/smithzvk/pythonic-string-reader") - (synopsis "Read table modification inspired by Python's three quote strings") - (description "This piece of code sets up some reader macros that make it -simpler to input string literals which contain backslashes and double quotes -This is very useful for writing complicated docstrings and, as it turns out, -writing code that contains string literals that contain code themselves.") - (license license:bsd-3)))) - -(define-public cl-pythonic-string-reader - (sbcl-package->cl-source-package sbcl-pythonic-string-reader)) - -(define-public ecl-pythonic-string-reader - (sbcl-package->ecl-package sbcl-pythonic-string-reader)) - -;; SLIME does not have a ASDF system definition to build all of Swank. As a -;; result, the asdf-build-system/sbcl will produce an almost empty package. -;; Some work was done to fix this at -;; https://github.com/sionescu/slime/tree/swank-asdf but it was never merged -;; and is now lagging behind. Building SBCL fasls might not be worth the -;; hassle, so let's just ship the source then. -(define-public cl-slime-swank - (package - (name "cl-slime-swank") - (version "2.24") - (source - (origin - (file-name (string-append name "-" version ".tar.gz")) - (method git-fetch) - (uri (git-reference - (url "https://github.com/slime/slime/") - (commit (string-append "v" version)))) - (sha256 - (base32 - "0js24x42m7b5iymb4rxz501dff19vav5pywnzv50b673rbkaaqvh")))) - (build-system asdf-build-system/source) - (home-page "https://github.com/slime/slime") - (synopsis "Common Lisp Swank server") - (description - "This is only useful if you want to start a Swank server in a Lisp -processes that doesn't run under Emacs. Lisp processes created by -@command{M-x slime} automatically start the server.") - (license (list license:gpl2+ license:public-domain)))) - -(define-public sbcl-slime-swank - (deprecated-package "sbcl-slime-swank" cl-slime-swank)) - -(define-public sbcl-mgl-pax - (let ((commit "818448418d6b9de74620f606f5b23033c6082769")) - (package - (name "sbcl-mgl-pax") - (version (git-version "0.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/melisgl/mgl-pax") - (commit commit))) - (sha256 - (base32 - "1p97zfkh130bdxqqxwaw2j9psv58751wakx7czbfpq410lg7dd7i")) - (file-name (git-file-name "mgl-pax" version)))) - (build-system asdf-build-system/sbcl) - (inputs - `(("3bmd" ,sbcl-3bmd) - ("3bmd-ext-code-blocks" ,sbcl-3bmd-ext-code-blocks) - ("babel" ,sbcl-babel) - ("cl-fad" ,sbcl-cl-fad) - ("ironclad" ,sbcl-ironclad) - ("named-readtables" ,sbcl-named-readtables) - ("pythonic-string-reader" ,sbcl-pythonic-string-reader) - ("swank" ,cl-slime-swank))) - (synopsis "Exploratory programming environment and documentation generator") - (description - "PAX provides an extremely poor man's Explorable Programming -environment. Narrative primarily lives in so called sections that mix markdown -docstrings with references to functions, variables, etc, all of which should -probably have their own docstrings. - -The primary focus is on making code easily explorable by using SLIME's -@command{M-.} (@command{slime-edit-definition}). See how to enable some -fanciness in Emacs Integration. Generating documentation from sections and all -the referenced items in Markdown or HTML format is also implemented. - -With the simplistic tools provided, one may accomplish similar effects as with -Literate Programming, but documentation is generated from code, not vice versa -and there is no support for chunking yet. Code is first, code must look -pretty, documentation is code.") - (home-page "http://quotenil.com/") - (license license:expat)))) - -(define-public cl-mgl-pax - (sbcl-package->cl-source-package sbcl-mgl-pax)) - -(define-public ecl-mgl-pax - (sbcl-package->ecl-package sbcl-mgl-pax)) - -(define-public sbcl-lisp-unit - (let ((commit "89653a232626b67400bf9a941f9b367da38d3815")) - (package - (name "sbcl-lisp-unit") - (version (git-version "0.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/OdonataResearchLLC/lisp-unit") - (commit commit))) - (sha256 - (base32 - "0p6gdmgr7p383nvd66c9y9fp2bjk4jx1lpa5p09g43hr9y9pp9ry")) - (file-name (git-file-name "lisp-unit" version)))) - (build-system asdf-build-system/sbcl) - (synopsis "Common Lisp Test framework inspired by JUnit to be simple of use") - (description - "@command{lisp-unit} is a Common Lisp library that supports unit -testing. It is an extension of the library written by Chris Riesbeck.") - (home-page "https://github.com/OdonataResearchLLC/lisp-unit") - (license license:expat)))) - -(define-public cl-lisp-unit - (sbcl-package->cl-source-package sbcl-lisp-unit)) - -(define-public ecl-lisp-unit - (sbcl-package->ecl-package sbcl-lisp-unit)) - -(define-public sbcl-anaphora - (package - (name "sbcl-anaphora") - (version "0.9.6") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/tokenrove/anaphora") - (commit version))) - (sha256 - (base32 - "19wfrk3asimznkli0x2rfy637hwpdgqyvwj3vhq9x7vjvyf5vv6x")) - (file-name (git-file-name "anaphora" version)))) - (build-system asdf-build-system/sbcl) - (native-inputs - `(("rt" ,sbcl-rt))) - (synopsis "The anaphoric macro collection from Hell") - (description - "Anaphora is the anaphoric macro collection from Hell: it includes many -new fiends in addition to old friends like @command{aif} and -@command{awhen}.") - (home-page "https://github.com/tokenrove/anaphora") - (license license:public-domain))) - -(define-public cl-anaphora - (sbcl-package->cl-source-package sbcl-anaphora)) - -(define-public ecl-anaphora - (sbcl-package->ecl-package sbcl-anaphora)) - -(define-public sbcl-lift - (let ((commit "7d49a66c62759535624037826891152223d4206c")) - (package - (name "sbcl-lift") - (version (git-version "1.7.1" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/gwkkwg/lift") - (commit commit))) - (sha256 - (base32 - "127v5avpz1i4m0lkaxqrq8hrl69rdazqaxf6s8awf0nd7wj2g4dp")) - (file-name (git-file-name "lift" version)) - (modules '((guix build utils))) - (snippet - ;; Don't keep the bundled website - `(begin - (delete-file-recursively "website") - #t)))) - (build-system asdf-build-system/sbcl) - (arguments - ;; The tests require a debugger, but we run with the debugger disabled. - '(#:tests? #f)) - (synopsis "LIsp Framework for Testing") - (description - "The LIsp Framework for Testing (LIFT) is a unit and system test tool for LISP. -Though inspired by SUnit and JUnit, it's built with Lisp in mind. In LIFT, -testcases are organized into hierarchical testsuites each of which can have -its own fixture. When run, a testcase can succeed, fail, or error. LIFT -supports randomized testing, benchmarking, profiling, and reporting.") - (home-page "https://github.com/gwkkwg/lift") - (license license:expat)))) - -(define-public cl-lift - (sbcl-package->cl-source-package sbcl-lift)) - -(define-public ecl-lift - (sbcl-package->ecl-package sbcl-lift)) - -(define-public sbcl-let-plus - (let ((commit "5f14af61d501ecead02ec6b5a5c810efc0c9fdbb")) - (package - (name "sbcl-let-plus") - (version (git-version "0.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/sharplispers/let-plus") - (commit commit))) - (sha256 - (base32 - "0i050ca2iys9f5mb7dgqgqdxfnc3b0rnjdwv95sqd490vkiwrsaj")) - (file-name (git-file-name "let-plus" version)))) - (build-system asdf-build-system/sbcl) - (inputs - `(("alexandria" ,sbcl-alexandria) - ("anaphora" ,sbcl-anaphora))) - (native-inputs - `(("lift" ,sbcl-lift))) - (synopsis "Destructuring extension of let*") - (description - "This library implements the let+ macro, which is a dectructuring -extension of let*. It features: - -@itemize -@item Clean, consistent syntax and small implementation (less than 300 LOC, -not counting tests) -@item Placeholder macros allow editor hints and syntax highlighting -@item @command{&ign} for ignored values (in forms where that makes sense) -@item Very easy to extend -@end itemize\n") - (home-page "https://github.com/sharplispers/let-plus") - (license license:boost1.0)))) - -(define-public cl-let-plus - (sbcl-package->cl-source-package sbcl-let-plus)) - -(define-public ecl-let-plus - (sbcl-package->ecl-package sbcl-let-plus)) - -(define-public sbcl-cl-colors - (let ((commit "827410584553f5c717eec6182343b7605f707f75")) - (package - (name "sbcl-cl-colors") - (version (git-version "0.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/tpapp/cl-colors") - (commit commit))) - (sha256 - (base32 - "0l446lday4hybsm9bq3jli97fvv8jb1d33abg79vbylpwjmf3y9a")) - (file-name (git-file-name "cl-colors" version)))) - (build-system asdf-build-system/sbcl) - (inputs - `(("alexandria" ,sbcl-alexandria) - ("let-plus" ,sbcl-let-plus))) - (synopsis "Simple color library for Common Lisp") - (description - "This is a very simple color library for Common Lisp, providing - -@itemize -@item Types for representing colors in HSV and RGB spaces. -@item Simple conversion functions between the above types (and also -hexadecimal representation for RGB). -@item Some predefined colors (currently X11 color names – of course the -library does not depend on X11).Because color in your terminal is nice. -@end itemize - -This library is no longer supported by its author.") - (home-page "https://github.com/tpapp/cl-colors") - (license license:boost1.0)))) - -(define-public cl-colors - (sbcl-package->cl-source-package sbcl-cl-colors)) - -(define-public ecl-cl-colors - (sbcl-package->ecl-package sbcl-cl-colors)) - -(define-public sbcl-cl-ansi-text - (let ((commit "53badf7878f27f22f2d4a2a43e6df458e43acbe9")) - (package - (name "sbcl-cl-ansi-text") - (version (git-version "1.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/pnathan/cl-ansi-text") - (commit commit))) - (sha256 - (base32 - "11i27n0dbz5lmygiw65zzr8lx0rac6b6yysqranphn31wls6ja3v")) - (file-name (git-file-name "cl-ansi-text" version)))) - (build-system asdf-build-system/sbcl) - (inputs - `(("alexandria" ,sbcl-alexandria) - ("cl-colors" ,sbcl-cl-colors))) - (native-inputs - `(("fiveam" ,sbcl-fiveam))) - (synopsis "ANSI terminal color implementation for Common Lisp") - (description - "@command{cl-ansi-text} provides utilities which enable printing to an -ANSI terminal with colored text. It provides the macro @command{with-color} -which causes everything printed in the body to be displayed with the provided -color. It further provides functions which will print the argument with the -named color.") - (home-page "https://github.com/pnathan/cl-ansi-text") - (license license:llgpl)))) - -(define-public cl-ansi-text - (sbcl-package->cl-source-package sbcl-cl-ansi-text)) - -(define-public ecl-cl-ansi-text - (sbcl-package->ecl-package sbcl-cl-ansi-text)) - -(define-public sbcl-prove-asdf - (let ((commit "4f9122bd393e63c5c70c1fba23070622317cfaa0")) - (package - (name "sbcl-prove-asdf") - (version (git-version "1.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/fukamachi/prove") - (commit commit))) - (sha256 - (base32 - "07sbfw459z8bbjvx1qlmfa8qk2mvbjnnzi2mi0x72blaj8bkl4vc")) - (file-name (git-file-name "prove" version)))) - (build-system asdf-build-system/sbcl) - (arguments - `(#:asd-file "prove-asdf.asd")) - (synopsis "Test requirement for the Common Lisp 'prove' library") - (description - "Test requirement for the Common Lisp @command{prove} library.") - (home-page "https://github.com/fukamachi/prove") - (license license:expat)))) - -(define-public cl-prove-asdf - (sbcl-package->cl-source-package sbcl-prove-asdf)) - -(define-public ecl-prove-asdf - (sbcl-package->ecl-package sbcl-prove-asdf)) - -(define-public sbcl-prove - (package - (inherit sbcl-prove-asdf) - (name "sbcl-prove") - (inputs - `(("alexandria" ,sbcl-alexandria) - ("cl-ppcre" ,sbcl-cl-ppcre) - ("cl-ansi-text" ,sbcl-cl-ansi-text))) - (native-inputs - `(("prove-asdf" ,sbcl-prove-asdf))) - (arguments - `(#:asd-file "prove.asd")) - (synopsis "Yet another unit testing framework for Common Lisp") - (description - "This project was originally called @command{cl-test-more}. -@command{prove} is yet another unit testing framework for Common Lisp. The -advantages of @command{prove} are: - -@itemize -@item Various simple functions for testing and informative error messages -@item ASDF integration -@item Extensible test reporters -@item Colorizes the report if it's available (note for SLIME) -@item Reports test durations -@end itemize\n"))) - -(define-public cl-prove - (sbcl-package->cl-source-package sbcl-prove)) - -(define-public ecl-prove - (sbcl-package->ecl-package sbcl-prove)) - -(define-public sbcl-proc-parse - (let ((commit "ac3636834d561bdc2686c956dbd82494537285fd")) - (package - (name "sbcl-proc-parse") - (version (git-version "0.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/fukamachi/proc-parse") - (commit commit))) - (sha256 - (base32 - "06rnl0h4cx6xv2wj3jczmmcxqn2703inmmvg1s4npbghmijsybfh")) - (file-name (git-file-name "proc-parse" version)))) - (build-system asdf-build-system/sbcl) - (inputs - `(("alexandria" ,sbcl-alexandria) - ("babel" ,sbcl-babel))) - (native-inputs - `(("prove" ,sbcl-prove) - ("prove-asdf" ,sbcl-prove-asdf))) - (arguments - ;; TODO: Tests don't find "proc-parse-test", why? - `(#:tests? #f)) - (synopsis "Procedural vector parser") - (description - "This is a string/octets parser library for Common Lisp with speed and -readability in mind. Unlike other libraries, the code is not a -pattern-matching-like, but a char-by-char procedural parser.") - (home-page "https://github.com/fukamachi/proc-parse") - (license license:bsd-2)))) - -(define-public cl-proc-parse - (sbcl-package->cl-source-package sbcl-proc-parse)) - -(define-public ecl-proc-parse - (sbcl-package->ecl-package sbcl-proc-parse)) - -(define-public sbcl-parse-float - (let ((commit "2aae569f2a4b2eb3bfb5401a959425dcf151b09c")) - (package - (name "sbcl-parse-float") - (version (git-version "0.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/soemraws/parse-float") - (commit commit))) - (sha256 - (base32 - "08xw8cchhmqcc0byng69m3f5a2izc9y2290jzz2k0qrbibp1fdk7")) - (file-name (git-file-name "proc-parse" version)))) - (build-system asdf-build-system/sbcl) - (inputs - `(("alexandria" ,sbcl-alexandria) - ("babel" ,sbcl-babel))) - (native-inputs - `(("prove" ,sbcl-prove) - ("prove-asdf" ,sbcl-prove-asdf))) - (arguments - ;; TODO: Tests don't find "proc-parse-test", why? - `(#:tests? #f)) - (synopsis "Parse a floating point value from a string in Common Lisp") - (description - "This package exports the following function to parse floating-point -values from a string in Common Lisp.") - (home-page "https://github.com/soemraws/parse-float") - (license license:public-domain)))) - -(define-public cl-parse-float - (sbcl-package->cl-source-package sbcl-parse-float)) - -(define-public ecl-parse-float - (sbcl-package->ecl-package sbcl-parse-float)) - -(define-public sbcl-ascii-strings - (let ((revision "1") - (changeset "5048480a61243e6f1b02884012c8f25cdbee6d97")) - (package - (name "sbcl-ascii-strings") - (version (string-append "0-" revision "." (string-take changeset 7))) - (source - (origin - (method hg-fetch) - (uri (hg-reference - (url "https://bitbucket.org/vityok/cl-string-match/") - (changeset changeset))) - (sha256 - (base32 - "01wn5qx562w43ssy92xlfgv79w7p0nv0wbl76mpmba131n9ziq2y")) - (file-name (git-file-name "cl-string-match" version)))) - (build-system asdf-build-system/sbcl) - (inputs - `(("alexandria" ,sbcl-alexandria) - ("babel" ,sbcl-babel))) - (arguments - `(#:asd-file "ascii-strings.asd")) - (synopsis "Operations on ASCII strings") - (description - "Operations on ASCII strings. Essentially this can be any kind of -single-byte encoded strings.") - (home-page "https://bitbucket.org/vityok/cl-string-match/") - (license license:bsd-3)))) - -(define-public cl-ascii-strings - (sbcl-package->cl-source-package sbcl-ascii-strings)) - -(define-public ecl-ascii-strings - (sbcl-package->ecl-package sbcl-ascii-strings)) - -(define-public sbcl-simple-scanf - (package - (inherit sbcl-ascii-strings) - (name "sbcl-simple-scanf") - (inputs - `(("alexandria" ,sbcl-alexandria) - ("iterate" ,sbcl-iterate) - ("proc-parse" ,sbcl-proc-parse) - ("parse-float" ,sbcl-parse-float))) - (arguments - `(#:asd-file "simple-scanf.asd")) - (synopsis "Simple scanf-like functionality implementation") - (description - "A simple scanf-like functionality implementation."))) - -(define-public cl-simple-scanf - (sbcl-package->cl-source-package sbcl-simple-scanf)) - -(define-public ecl-simple-scanf - (sbcl-package->ecl-package sbcl-simple-scanf)) - -(define-public sbcl-cl-string-match - (package - (inherit sbcl-ascii-strings) - (name "sbcl-cl-string-match") - (inputs - `(("alexandria" ,sbcl-alexandria) - ("ascii-strings" ,sbcl-ascii-strings) - ("yacc" ,sbcl-cl-yacc) - ("jpl-util" ,sbcl-jpl-util) - ("jpl-queues" ,sbcl-jpl-queues) - ("mgl-pax" ,sbcl-mgl-pax) - ("iterate" ,sbcl-iterate))) - ;; TODO: Tests are not evaluated properly. - (native-inputs - ;; For testing: - `(("lisp-unit" ,sbcl-lisp-unit) - ("simple-scanf" ,sbcl-simple-scanf))) - (arguments - `(#:tests? #f - #:asd-file "cl-string-match.asd")) - (synopsis "Portable, dependency-free set of utilities to manipulate strings in Common Lisp") - (description - "@command{cl-strings} is a small, portable, dependency-free set of -utilities that make it even easier to manipulate text in Common Lisp. It has -100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp."))) - -(define-public cl-string-match - (sbcl-package->cl-source-package sbcl-cl-string-match)) - -(define-public ecl-cl-string-match - (sbcl-package->ecl-package sbcl-cl-string-match)) - -(define-public sbcl-ptester - (package - (name "sbcl-ptester") - (version "20160929") - (source - (origin - (method url-fetch) - (uri (string-append "http://beta.quicklisp.org/archive/ptester/" - (date->string (string->date version "~Y~m~d") "~Y-~m-~d") - "/ptester-" - version - "-git.tgz")) - (sha256 - (base32 - "04rlq1zljhxc65pm31bah3sq3as24l0sdivz440s79qlnnyh13hz")))) - (build-system asdf-build-system/sbcl) - (home-page "http://quickdocs.org/ptester/") - (synopsis "Portable test harness package") - (description - "@command{ptester} is a portable testing framework based on Franz's -tester module.") - (license license:lgpl3+))) - -(define-public cl-ptester - (sbcl-package->cl-source-package sbcl-ptester)) - -(define-public ecl-ptester - (sbcl-package->ecl-package sbcl-ptester)) - -(define-public sbcl-puri - (package - (name "sbcl-puri") - (version "20180228") - (source - (origin - (method url-fetch) - (uri (string-append "http://beta.quicklisp.org/archive/puri/" - (date->string (string->date version "~Y~m~d") "~Y-~m-~d") - "/puri-" - version - "-git.tgz")) - (sha256 - (base32 - "1s4r5adrjy5asry45xbcbklxhdjydvf6n55z897nvyw33bigrnbz")))) - (build-system asdf-build-system/sbcl) - ;; REVIEW: Webiste down? - (native-inputs - `(("ptester" ,sbcl-ptester))) - (home-page "http://files.kpe.io/puri/") - (synopsis "Portable URI Library") - (description - "This is portable Universal Resource Identifier library for Common Lisp -programs. It parses URI according to the RFC 2396 specification") - (license license:lgpl3+))) - -(define-public cl-puri - (sbcl-package->cl-source-package sbcl-puri)) - -(define-public ecl-puri - (sbcl-package->ecl-package sbcl-puri)) - -(define-public sbcl-queues - (let ((commit "47d4da65e9ea20953b74aeeab7e89a831b66bc94")) - (package - (name "sbcl-queues") - (version (git-version "0.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/oconnore/queues") - (commit commit))) - (file-name (git-file-name "queues" version)) - (sha256 - (base32 - "0wdhfnzi4v6d97pggzj2aw55si94w4327br94jrmyvwf351wqjvv")))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/oconnore/queues") - (synopsis "Common Lisp queue library") - (description - "This is a simple queue library for Common Lisp with features such as -non-consing thread safe queues and fibonacci priority queues.") - (license license:expat)))) - -(define-public cl-queues - (sbcl-package->cl-source-package sbcl-queues)) - -(define-public ecl-queues - (sbcl-package->ecl-package sbcl-queues)) - -(define-public sbcl-queues.simple-queue - (package - (inherit sbcl-queues) - (name "sbcl-queues.simple-queue") - (inputs - `(("sbcl-queues" ,sbcl-queues))) - (arguments - `(#:asd-file "queues.simple-queue.asd")) - (synopsis "Simple queue implementation") - (description - "This is a simple queue library for Common Lisp with features such as -non-consing thread safe queues and fibonacci priority queues.") - (license license:expat))) - -(define-public cl-queues.simple-queue - (sbcl-package->cl-source-package sbcl-queues.simple-queue)) - -(define-public ecl-queues.simple-queue - (sbcl-package->ecl-package sbcl-queues.simple-queue)) - -(define-public sbcl-queues.simple-cqueue - (package - (inherit sbcl-queues) - (name "sbcl-queues.simple-cqueue") - (inputs - `(("sbcl-queues" ,sbcl-queues) - ("sbcl-queues.simple-queue" ,sbcl-queues.simple-queue) - ("bordeaux-threads" ,sbcl-bordeaux-threads))) - (arguments - `(#:asd-file "queues.simple-cqueue.asd")) - (synopsis "Thread safe queue implementation") - (description - "This is a simple queue library for Common Lisp with features such as -non-consing thread safe queues and fibonacci priority queues.") - (license license:expat))) - -(define-public cl-queues.simple-cqueue - (sbcl-package->cl-source-package sbcl-queues.simple-cqueue)) - -(define-public ecl-queues.simple-cqueue - (sbcl-package->ecl-package sbcl-queues.simple-cqueue)) - -(define-public sbcl-queues.priority-queue - (package - (inherit sbcl-queues) - (name "sbcl-queues.priority-queue") - (inputs - `(("sbcl-queues" ,sbcl-queues))) - (arguments - `(#:asd-file "queues.priority-queue.asd")) - (synopsis "Priority queue (Fibonacci) implementation") - (description - "This is a simple queue library for Common Lisp with features such as -non-consing thread safe queues and fibonacci priority queues.") - (license license:expat))) - -(define-public cl-queues.priority-queue - (sbcl-package->cl-source-package sbcl-queues.priority-queue)) - -(define-public ecl-queues.priority-queue - (sbcl-package->ecl-package sbcl-queues.priority-queue)) - -(define-public sbcl-queues.priority-cqueue - (package - (inherit sbcl-queues) - (name "sbcl-queues.priority-cqueue") - (inputs - `(("sbcl-queues" ,sbcl-queues) - ("sbcl-queues.priority-queue" ,sbcl-queues.priority-queue) - ("bordeaux-threads" ,sbcl-bordeaux-threads))) - (arguments - `(#:asd-file "queues.priority-cqueue.asd")) - (synopsis "Thread safe fibonacci priority queue implementation") - (description - "This is a simple queue library for Common Lisp with features such as -non-consing thread safe queues and fibonacci priority queues.") - (license license:expat))) - -(define-public cl-queues.priority-cqueue - (sbcl-package->cl-source-package sbcl-queues.priority-cqueue)) - -(define-public ecl-queues.priority-cqueue - (sbcl-package->ecl-package sbcl-queues.priority-cqueue)) - -(define sbcl-cffi-bootstrap - (package - (name "sbcl-cffi-bootstrap") - (version "0.19.0") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/cffi/cffi.git") - (commit (string-append "v" version)))) - (file-name (git-file-name "cffi-bootstrap" version)) - (sha256 - (base32 "09sfgc6r7ihmbkwfpvkq5fxc7h45cabpvgbvs47i5cvnmv3k72xy")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("libffi" ,libffi) - ("alexandria" ,sbcl-alexandria) - ("babel" ,sbcl-babel) - ("trivial-features" ,sbcl-trivial-features))) - (native-inputs - `(("pkg-config" ,pkg-config))) - (arguments - '(#:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "libffi/libffi.lisp" - (("libffi.so.6" all) (string-append - (assoc-ref inputs "libffi") - "/lib/" all))) - (substitute* "toolchain/c-toolchain.lisp" - (("\"cc\"") (format #f "~S" (which "gcc"))))))) - #:asd-system-name "cffi" - #:tests? #f)) - (home-page "https://common-lisp.net/project/cffi/") - (synopsis "Common Foreign Function Interface for Common Lisp") - (description "The Common Foreign Function Interface (CFFI) -purports to be a portable foreign function interface for Common Lisp. -The CFFI library is composed of a Lisp-implementation-specific backend -in the CFFI-SYS package, and a portable frontend in the CFFI -package.") - (license license:expat))) - -(define-public sbcl-cffi-toolchain - (package - (inherit sbcl-cffi-bootstrap) - (name "sbcl-cffi-toolchain") - (inputs - `(("libffi" ,libffi) - ("sbcl-cffi" ,sbcl-cffi-bootstrap))) - (arguments - (substitute-keyword-arguments (package-arguments sbcl-cffi-bootstrap) - ((#:asd-system-name _) #f) - ((#:tests? _) #t))))) - -(define-public sbcl-cffi-libffi - (package - (inherit sbcl-cffi-toolchain) - (name "sbcl-cffi-libffi") - (inputs - `(("cffi" ,sbcl-cffi-bootstrap) - ("cffi-grovel" ,sbcl-cffi-grovel) - ("trivial-features" ,sbcl-trivial-features) - ("libffi" ,libffi))))) - -(define-public sbcl-cffi-grovel - (package - (inherit sbcl-cffi-toolchain) - (name "sbcl-cffi-grovel") - (inputs - `(("libffi" ,libffi) - ("cffi" ,sbcl-cffi-bootstrap) - ("cffi-toolchain" ,sbcl-cffi-toolchain) - ("alexandria" ,sbcl-alexandria))) - (arguments - (substitute-keyword-arguments (package-arguments sbcl-cffi-toolchain) - ((#:phases phases) - `(modify-phases ,phases - (add-after 'build 'install-headers - (lambda* (#:key outputs #:allow-other-keys) - (install-file "grovel/common.h" - (string-append - (assoc-ref outputs "out") - "/include/grovel")))))))))) - -(define-public sbcl-cffi - (package - (inherit sbcl-cffi-toolchain) - (name "sbcl-cffi") - (inputs (package-inputs sbcl-cffi-bootstrap)) - (native-inputs - `(("cffi-grovel" ,sbcl-cffi-grovel) - ("cffi-libffi" ,sbcl-cffi-libffi) - ("rt" ,sbcl-rt) - ("bordeaux-threads" ,sbcl-bordeaux-threads) - ,@(package-native-inputs sbcl-cffi-bootstrap))))) - -(define-public cl-cffi - (sbcl-package->cl-source-package sbcl-cffi)) - -(define-public sbcl-cl-sqlite - (let ((commit "c738e66d4266ef63a1debc4ef4a1b871a068c112")) - (package - (name "sbcl-cl-sqlite") - (version (git-version "0.2" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/dmitryvk/cl-sqlite") - (commit commit))) - (file-name (git-file-name "cl-sqlite" version)) - (sha256 - (base32 - "1ng45k1hdb84sqjryrfx93g66bsbybmpy301wd0fdybnc5jzr36q")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("iterate" ,sbcl-iterate) - ("cffi" ,sbcl-cffi) - ("sqlite" ,sqlite))) - (native-inputs - `(("fiveam" ,sbcl-fiveam) - ("bordeaux-threads" ,sbcl-bordeaux-threads))) - (arguments - `(#:tests? #f ; Upstream seems to have issues with tests: https://github.com/dmitryvk/cl-sqlite/issues/7 - #:asd-file "sqlite.asd" - #:asd-system-name "sqlite" - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "sqlite-ffi.lisp" - (("libsqlite3" all) (string-append - (assoc-ref inputs "sqlite")"/lib/" all)))))))) - (home-page "https://common-lisp.net/project/cl-sqlite/") - (synopsis "Common Lisp binding for SQLite") - (description - "The @command{cl-sqlite} package is an interface to the SQLite embedded -relational database engine.") - (license license:public-domain)))) - -(define-public cl-sqlite - (sbcl-package->cl-source-package sbcl-cl-sqlite)) - -(define-public sbcl-parenscript - (let ((commit "061d8e286c81c3f45c84fb2b11ee7d83f590a8f8")) - (package - (name "sbcl-parenscript") - (version (git-version "2.6" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://gitlab.common-lisp.net/parenscript/parenscript") - (commit commit))) - (file-name (git-file-name "parenscript" version)) - (sha256 - (base32 - "1kbhgsjbikc73m5cwdp4d4fdafyqcr1b7b630qjrziql0nh6mi3k")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("cl-ppcre" ,sbcl-cl-ppcre) - ("anaphora" ,sbcl-anaphora) - ("named-readtables" ,sbcl-named-readtables))) - (home-page "https://common-lisp.net/project/parenscript/") - (synopsis "Translator from a subset of Common Lisp to JavaScript") - (description - "Parenscript is a translator from an extended subset of Common Lisp to -JavaScript. Parenscript code can run almost identically on both the -browser (as JavaScript) and server (as Common Lisp). - -Parenscript code is treated the same way as Common Lisp code, making the full -power of Lisp macros available for JavaScript. This provides a web -development environment that is unmatched in its ability to reduce code -duplication and provide advanced meta-programming facilities to web -developers. - -At the same time, Parenscript is different from almost all other \"language -X\" to JavaScript translators in that it imposes almost no overhead: - -@itemize -@item No run-time dependencies: Any piece of Parenscript code is runnable -as-is. There are no JavaScript files to include. -@item Native types: Parenscript works entirely with native JavaScript data -types. There are no new types introduced, and object prototypes are not -touched. -@item Native calling convention: Any JavaScript code can be called without the -need for bindings. Likewise, Parenscript can be used to make efficient, -self-contained JavaScript libraries. -@item Readable code: Parenscript generates concise, formatted, idiomatic -JavaScript code. Identifier names are preserved. This enables seamless -debugging in tools like Firebug. -@item Efficiency: Parenscript introduces minimal overhead for advanced Common -Lisp features. The generated code is almost as fast as hand-written -JavaScript. -@end itemize\n") - (license license:bsd-3)))) - -(define-public cl-parenscript - (sbcl-package->cl-source-package sbcl-parenscript)) - -(define-public ecl-parenscript - (sbcl-package->ecl-package sbcl-parenscript)) - -(define-public sbcl-cl-json - (let ((commit "6dfebb9540bfc3cc33582d0c03c9ec27cb913e79")) - (package - (name "sbcl-cl-json") - (version (git-version "0.5" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/hankhero/cl-json") - (commit commit))) - (file-name (git-file-name "cl-json" version)) - (sha256 - (base32 - "0fx3m3x3s5ji950yzpazz4s0img3l6b3d6l3jrfjv0lr702496lh")))) - (build-system asdf-build-system/sbcl) - (native-inputs - `(("fiveam" ,sbcl-fiveam))) - (home-page "https://github.com/hankhero/cl-json") - (synopsis "JSON encoder and decoder for Common-Lisp") - (description - "@command{cl-json} provides an encoder of Lisp objects to JSON format -and a corresponding decoder of JSON data to Lisp objects. Both the encoder -and the decoder are highly customizable; at the same time, the default -settings ensure a very simple mode of operation, similar to that provided by -@command{yason} or @command{st-json}.") - (license license:expat)))) - -(define-public cl-json - (sbcl-package->cl-source-package sbcl-cl-json)) - -(define-public ecl-cl-json - (sbcl-package->ecl-package sbcl-cl-json)) - -(define-public sbcl-unix-opts - (package - (name "sbcl-unix-opts") - (version "0.1.7") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/libre-man/unix-opts") - (commit version))) - (file-name (git-file-name "unix-opts" version)) - (sha256 - (base32 - "08djdi1ard09fijb7w9bdmhmwd98b1hzmcnjw9fqjiqa0g3b44rr")))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/hankhero/cl-json") - (synopsis "Unix-style command line options parser") - (description - "This is a minimalistic parser of command line options. The main -advantage of the library is the ability to concisely define command line -options once and then use this definition for parsing and extraction of -command line arguments, as well as printing description of command line -options (you get --help for free). This way you don't need to repeat -yourself. Also, @command{unix-opts} doesn't depend on anything and allows to -precisely control behavior of the parser via Common Lisp restarts.") - (license license:expat))) - -(define-public cl-unix-opts - (sbcl-package->cl-source-package sbcl-unix-opts)) - -(define-public ecl-unix-opts - (sbcl-package->ecl-package sbcl-unix-opts)) - -(define-public sbcl-trivial-garbage - (package - (name "sbcl-trivial-garbage") - (version "0.21") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/trivial-garbage/trivial-garbage.git") - (commit (string-append "v" version)))) - (file-name (git-file-name "trivial-garbage" version)) - (sha256 - (base32 "0122jicfg7pca1wxw8zak1n92h5friqy60988ns0ysksj3fphw9n")))) - (build-system asdf-build-system/sbcl) - (native-inputs - `(("rt" ,sbcl-rt))) - (home-page "https://common-lisp.net/project/trivial-garbage/") - (synopsis "Portable GC-related APIs for Common Lisp") - (description "@command{trivial-garbage} provides a portable API to -finalizers, weak hash-tables and weak pointers on all major implementations of -the Common Lisp programming language.") - (license license:public-domain))) - -(define-public cl-trivial-garbage - (sbcl-package->cl-source-package sbcl-trivial-garbage)) - -(define-public ecl-trivial-garbage - (sbcl-package->ecl-package sbcl-trivial-garbage)) - -(define-public sbcl-closer-mop - (let ((commit "fac29ce90e3a46e1fc6cf182190e193526fa9dbc")) - (package - (name "sbcl-closer-mop") - (version (git-version "1.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/pcostanza/closer-mop") - (commit commit))) - (sha256 - (base32 "0hvh77y869h8fg9di5snyg85fxq6fdh9gj1igmx1g6j6j5x915dl")) - (file-name (git-file-name "closer-mop" version )))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/pcostanza/closer-mop") - (synopsis "Rectifies absent or incorrect CLOS MOP features") - (description "Closer to MOP is a compatibility layer that rectifies many -of the absent or incorrect CLOS MOP features across a broad range of Common -Lisp implementations.") - (license license:expat)))) - -(define-public cl-closer-mop - (sbcl-package->cl-source-package sbcl-closer-mop)) - -(define-public ecl-closer-mop - (sbcl-package->ecl-package sbcl-closer-mop)) - -(define sbcl-cl-cffi-gtk-boot0 - (let ((commit "29443c5aaca975709df8025c4649366d882033cb")) - (package - (name "sbcl-cl-cffi-gtk-boot0") - (version (git-version "0.11.2" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Ferada/cl-cffi-gtk/") - (commit commit))) - (file-name (git-file-name "cl-cffi-gtk" version)) - (sha256 - (base32 - "0f6s92sf8xyzh1yksqx8bsy1sv0zmy0c13j3b8bavaba5hlxpxah")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("iterate" ,sbcl-iterate) - ("cffi" ,sbcl-cffi) - ("trivial-features" ,sbcl-trivial-features))) - (home-page "https://github.com/Ferada/cl-cffi-gtk/") - (synopsis "Common Lisp binding for GTK+3") - (description - "@command{cl-cffi-gtk} is a Lisp binding to GTK+ 3 (GIMP Toolkit) which -is a library for creating graphical user interfaces.") - (license license:lgpl3)))) - -(define-public sbcl-cl-cffi-gtk-glib - (package - (inherit sbcl-cl-cffi-gtk-boot0) - (name "sbcl-cl-cffi-gtk-glib") - (inputs - `(("glib" ,glib) - ,@(package-inputs sbcl-cl-cffi-gtk-boot0))) - (arguments - `(#:asd-file "glib/cl-cffi-gtk-glib.asd" - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "glib/glib.init.lisp" - (("libglib|libgthread" all) (string-append - (assoc-ref inputs "glib") "/lib/" all)))))))))) - -(define-public sbcl-cl-cffi-gtk-gobject - (package - (inherit sbcl-cl-cffi-gtk-boot0) - (name "sbcl-cl-cffi-gtk-gobject") - (inputs - `(("glib" ,glib) - ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib) - ("trivial-garbage" ,sbcl-trivial-garbage) - ("bordeaux-threads" ,sbcl-bordeaux-threads) - ("closer-mop" ,sbcl-closer-mop) - ,@(package-inputs sbcl-cl-cffi-gtk-boot0))) - (arguments - `(#:asd-file "gobject/cl-cffi-gtk-gobject.asd" - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "gobject/gobject.init.lisp" - (("libgobject" all) (string-append - (assoc-ref inputs "glib") "/lib/" all)))))))))) - -(define-public sbcl-cl-cffi-gtk-gio - (package - (inherit sbcl-cl-cffi-gtk-boot0) - (name "sbcl-cl-cffi-gtk-gio") - (inputs - `(("glib" ,glib) - ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib) - ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject) - ,@(package-inputs sbcl-cl-cffi-gtk-boot0))) - (arguments - `(#:asd-file "gio/cl-cffi-gtk-gio.asd" - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "gio/gio.init.lisp" - (("libgio" all) - (string-append - (assoc-ref inputs "glib") "/lib/" all)))))))))) - -(define-public sbcl-cl-cffi-gtk-cairo - (package - (inherit sbcl-cl-cffi-gtk-boot0) - (name "sbcl-cl-cffi-gtk-cairo") - (inputs - `(("cairo" ,cairo) - ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib) - ,@(package-inputs sbcl-cl-cffi-gtk-boot0))) - (arguments - `(#:asd-file "cairo/cl-cffi-gtk-cairo.asd" - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "cairo/cairo.init.lisp" - (("libcairo" all) - (string-append - (assoc-ref inputs "cairo") "/lib/" all)))))))))) - -(define-public sbcl-cl-cffi-gtk-pango - (package - (inherit sbcl-cl-cffi-gtk-boot0) - (name "sbcl-cl-cffi-gtk-pango") - (inputs - `(("pango" ,pango) - ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib) - ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject) - ("cl-cffi-gtk-cairo" ,sbcl-cl-cffi-gtk-cairo) - ,@(package-inputs sbcl-cl-cffi-gtk-boot0))) - (arguments - `(#:asd-file "pango/cl-cffi-gtk-pango.asd" - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "pango/pango.init.lisp" - (("libpango" all) - (string-append - (assoc-ref inputs "pango") "/lib/" all)))))))))) - -(define-public sbcl-cl-cffi-gtk-gdk-pixbuf - (package - (inherit sbcl-cl-cffi-gtk-boot0) - (name "sbcl-cl-cffi-gtk-gdk-pixbuf") - (inputs - `(("gdk-pixbuf" ,gdk-pixbuf) - ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject) - ,@(package-inputs sbcl-cl-cffi-gtk-boot0))) - (arguments - `(#:asd-file "gdk-pixbuf/cl-cffi-gtk-gdk-pixbuf.asd" - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "gdk-pixbuf/gdk-pixbuf.init.lisp" - (("libgdk_pixbuf" all) - (string-append - (assoc-ref inputs "gdk-pixbuf") "/lib/" all)))))))))) - -(define-public sbcl-cl-cffi-gtk-gdk - (package - (inherit sbcl-cl-cffi-gtk-boot0) - (name "sbcl-cl-cffi-gtk-gdk") - (inputs - `(("gtk" ,gtk+) - ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject) - ("cl-cffi-gtk-gio" ,sbcl-cl-cffi-gtk-gio) - ("cl-cffi-gtk-gdk-pixbuf" ,sbcl-cl-cffi-gtk-gdk-pixbuf) - ("cl-cffi-gtk-cairo" ,sbcl-cl-cffi-gtk-cairo) - ("cl-cffi-gtk-pango" ,sbcl-cl-cffi-gtk-pango) - ,@(package-inputs sbcl-cl-cffi-gtk-boot0))) - (arguments - `(#:asd-file "gdk/cl-cffi-gtk-gdk.asd" - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "gdk/gdk.init.lisp" - (("libgdk" all) - (string-append - (assoc-ref inputs "gtk") "/lib/" all))) - (substitute* "gdk/gdk.package.lisp" - (("libgtk" all) - (string-append - (assoc-ref inputs "gtk") "/lib/" all)))))))))) - -(define-public sbcl-cl-cffi-gtk - (package - (inherit sbcl-cl-cffi-gtk-boot0) - (name "sbcl-cl-cffi-gtk") - (inputs - `(("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib) - ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject) - ("cl-cffi-gtk-gio" ,sbcl-cl-cffi-gtk-gio) - ("cl-cffi-gtk-gdk" ,sbcl-cl-cffi-gtk-gdk) - ,@(package-inputs sbcl-cl-cffi-gtk-boot0))) - (native-inputs - `(("fiveam" ,sbcl-fiveam))) - (arguments - `(#:asd-file "gtk/cl-cffi-gtk.asd" - #:test-asd-file "test/cl-cffi-gtk-test.asd" - ;; TODO: Tests fail with memory fault. - ;; See https://github.com/Ferada/cl-cffi-gtk/issues/24. - #:tests? #f)))) - -(define-public cl-cffi-gtk - (sbcl-package->cl-source-package sbcl-cl-cffi-gtk)) - -(define-public sbcl-cl-webkit - (let ((commit "cd2a9008e0c152e54755e8a7f07b050fe36bab31")) - (package - (name "sbcl-cl-webkit") - (version (git-version "2.4" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/jmercouris/cl-webkit") - (commit commit))) - (file-name (git-file-name "cl-webkit" version)) - (sha256 - (base32 - "0f5lyn9i7xrn3g1bddga377mcbawkbxydijpg389q4n04gqj0vwf")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("cffi" ,sbcl-cffi) - ("cl-cffi-gtk" ,sbcl-cl-cffi-gtk) - ("webkitgtk" ,webkitgtk))) - (arguments - `(#:asd-file "webkit2/cl-webkit2.asd" - #:asd-system-name "cl-webkit2" - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "webkit2/webkit2.init.lisp" - (("libwebkit2gtk" all) - (string-append - (assoc-ref inputs "webkitgtk") "/lib/" all)))))))) - (home-page "https://github.com/jmercouris/cl-webkit") - (synopsis "Binding to WebKitGTK+ for Common Lisp") - (description - "@command{cl-webkit} is a binding to WebKitGTK+ for Common Lisp, -currently targeting WebKit version 2. The WebKitGTK+ library adds web -browsing capabilities to an application, leveraging the full power of the -WebKit browsing engine.") - (license license:expat)))) - -(define-public cl-webkit - (sbcl-package->cl-source-package sbcl-cl-webkit)) - -(define-public sbcl-lparallel - (package - (name "sbcl-lparallel") - (version "2.8.4") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/lmj/lparallel/") - (commit (string-append "lparallel-" version)))) - (file-name (git-file-name "lparallel" version)) - (sha256 - (base32 - "0g0aylrbbrqsz0ahmwhvnk4cmc2931fllbpcfgzsprwnqqd7vwq9")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("alexandria" ,sbcl-alexandria) - ("bordeaux-threads" ,sbcl-bordeaux-threads) - ("trivial-garbage" ,sbcl-trivial-garbage))) - (home-page "https://lparallel.org/") - (synopsis "Parallelism for Common Lisp") - (description - "@command{lparallel} is a library for parallel programming in Common -Lisp, featuring: - -@itemize -@item a simple model of task submission with receiving queue, -@item constructs for expressing fine-grained parallelism, -@item asynchronous condition handling across thread boundaries, -@item parallel versions of map, reduce, sort, remove, and many others, -@item promises, futures, and delayed evaluation constructs, -@item computation trees for parallelizing interconnected tasks, -@item bounded and unbounded FIFO queues, -@item high and low priority tasks, -@item task killing by category, -@item integrated timeouts. -@end itemize\n") - (license license:expat))) - -(define-public cl-lparallel - (sbcl-package->cl-source-package sbcl-lparallel)) - -(define-public ecl-lparallel - (sbcl-package->ecl-package sbcl-lparallel)) - -(define-public sbcl-cl-markup - (let ((commit "e0eb7debf4bdff98d1f49d0f811321a6a637b390")) - (package - (name "sbcl-cl-markup") - (version (git-version "0.1" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/arielnetworks/cl-markup/") - (commit commit))) - (file-name (git-file-name "cl-markup" version)) - (sha256 - (base32 - "10l6k45971dl13fkdmva7zc6i453lmq9j4xax2ci6pjzlc6xjhp7")))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/arielnetworks/cl-markup/") - (synopsis "Markup generation library for Common Lisp") - (description - "A modern markup generation library for Common Lisp that features: - -@itemize -@item Fast (even faster through compiling the code) -@item Safety -@item Support for multiple document types (markup, xml, html, html5, xhtml) -@item Output with doctype -@item Direct output to stream -@end itemize\n") - (license license:lgpl3+)))) - -(define-public cl-markup - (sbcl-package->cl-source-package sbcl-cl-markup)) - -(define-public ecl-cl-markup - (sbcl-package->ecl-package sbcl-cl-markup)) - -(define-public sbcl-cl-css - (let ((commit "8fe654c8f0cf95b300718101cce4feb517f78e2f")) - (package - (name "sbcl-cl-css") - (version (git-version "0.1" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/inaimathi/cl-css/") - (commit commit))) - (file-name (git-file-name "cl-css" version)) - (sha256 - (base32 - "1lc42zi2sw11fl2589sc19nr5sd2p0wy7wgvgwaggxa5f3ajhsmd")))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/inaimathi/cl-css/") - (synopsis "Non-validating, inline CSS generator for Common Lisp") - (description - "This is a dead-simple, non validating, inline CSS generator for Common -Lisp. Its goals are axiomatic syntax, simple implementation to support -portability, and boilerplate reduction in CSS.") - (license license:expat)))) - -(define-public cl-css - (sbcl-package->cl-source-package sbcl-cl-css)) - -(define-public ecl-cl-css - (sbcl-package->ecl-package sbcl-cl-css)) - -(define-public sbcl-portable-threads - (let ((commit "c0e61a1faeb0583c80fd3f20b16cc4c555226920")) - (package - (name "sbcl-portable-threads") - (version (git-version "2.3" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/binghe/portable-threads/") - (commit commit))) - (file-name (git-file-name "portable-threads" version)) - (sha256 - (base32 - "03fmxyarc0xf4kavwkfa0a2spkyfrz6hbgbi9y4q7ny5aykdyfaq")))) - (build-system asdf-build-system/sbcl) - (arguments - `(;; Tests seem broken. - #:tests? #f)) - (home-page "https://github.com/binghe/portable-threads") - (synopsis "Portable threads (and scheduled and periodic functions) API for Common Lisp") - (description - "Portable Threads (and Scheduled and Periodic Functions) API for Common -Lisp (from GBBopen project).") - (license license:asl2.0)))) - -(define-public cl-portable-threads - (sbcl-package->cl-source-package sbcl-portable-threads)) - -(define-public ecl-portable-threada - (sbcl-package->ecl-package sbcl-portable-threads)) - -(define-public sbcl-usocket-boot0 - ;; usocket's test rely on usocket-server which depends on usocket itself. - ;; We break this cyclic dependency with -boot0 that packages usocket. - (let ((commit "86e7efbfe50101931edf4b67cdcfa7e221ecfde9")) - (package - (name "sbcl-usocket-boot0") - (version (git-version "0.7.1" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/usocket/usocket/") - (commit commit))) - (file-name (git-file-name "usocket" version)) - (sha256 - (base32 - "1lk6ipakrib7kdgzw44hrgmls9akp5pz4h35yynw0k5zwmmq6374")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("split-sequence" ,sbcl-split-sequence))) - (arguments - `(#:tests? #f - #:asd-system-name "usocket")) - (home-page "https://common-lisp.net/project/usocket/") - (synopsis "Universal socket library for Common Lisp (server side)") - (description - "This library strives to provide a portable TCP/IP and UDP/IP socket -interface for as many Common Lisp implementations as possible, while keeping -the abstraction and portability layer as thin as possible.") - (license license:expat)))) - -(define-public sbcl-usocket-server - (package - (inherit sbcl-usocket-boot0) - (name "sbcl-usocket-server") - (inputs - `(("usocket" ,sbcl-usocket-boot0) - ("portable-threads" ,sbcl-portable-threads))) - (arguments - '(#:asd-system-name "usocket-server")) - (synopsis "Universal socket library for Common Lisp (server side)"))) - -(define-public cl-usocket-server - (sbcl-package->cl-source-package sbcl-usocket-server)) - -(define-public ecl-socket-server - (sbcl-package->ecl-package sbcl-usocket-server)) - -(define-public sbcl-usocket - (package - (inherit sbcl-usocket-boot0) - (name "sbcl-usocket") - (arguments - ;; FIXME: Tests need network access? - `(#:tests? #f)) - (native-inputs - ;; Testing only. - `(("usocket-server" ,sbcl-usocket-server) - ("rt" ,sbcl-rt))))) - -(define-public cl-usocket - (sbcl-package->cl-source-package sbcl-usocket)) - -(define-public ecl-socket - (sbcl-package->ecl-package sbcl-usocket)) - -(define-public sbcl-s-xml - (package - (name "sbcl-s-xml") - (version "3") - (source - (origin - (method url-fetch) - (uri "https://common-lisp.net/project/s-xml/s-xml.tgz") - (sha256 - (base32 - "061qcr0dzshsa38s5ma4ay924cwak2nq9gy59dw6v9p0qb58nzjf")))) - (build-system asdf-build-system/sbcl) - (home-page "https://common-lisp.net/project/s-xml/") - (synopsis "Simple XML parser implemented in Common Lisp") - (description - "S-XML is a simple XML parser implemented in Common Lisp. This XML -parser implementation has the following features: - -@itemize -@item It works (handling many common XML usages). -@item It is very small (the core is about 700 lines of code, including -comments and whitespace). -@item It has a core API that is simple, efficient and pure functional, much -like that from SSAX (see also http://ssax.sourceforge.net). -@item It supports different DOM models: an XSML-based one, an LXML-based one -and a classic xml-element struct based one. -@item It is reasonably time and space efficient (internally avoiding garbage -generatation as much as possible). -@item It does support CDATA. -@item It should support the same character sets as your Common Lisp -implementation. -@item It does support XML name spaces. -@end itemize - -This XML parser implementation has the following limitations: - -@itemize -@item It does not support any special tags (like processing instructions). -@item It is not validating, even skips DTD's all together. -@end itemize\n") - (license license:lgpl3+))) - -(define-public cl-s-xml - (sbcl-package->cl-source-package sbcl-s-xml)) - -(define-public ecl-s-xml - (sbcl-package->ecl-package sbcl-s-xml)) - -(define-public sbcl-s-xml-rpc - (package - (name "sbcl-s-xml-rpc") - (version "7") - (source - (origin - (method url-fetch) - (uri "https://common-lisp.net/project/s-xml-rpc/s-xml-rpc.tgz") - (sha256 - (base32 - "02z7k163d51v0pzk8mn1xb6h5s6x64gjqkslhwm3a5x26k2gfs11")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("s-xml" ,sbcl-s-xml))) - (home-page "https://common-lisp.net/project/s-xml-rpc/") - (synopsis "Implementation of XML-RPC in Common Lisp for both client and server") - (description - "S-XML-RPC is an implementation of XML-RPC in Common Lisp for both -client and server.") - (license license:lgpl3+))) - -(define-public cl-s-xml-rpc - (sbcl-package->cl-source-package sbcl-s-xml-rpc)) - -(define-public ecl-s-xml-rpc - (sbcl-package->ecl-package sbcl-s-xml-rpc)) - -(define-public sbcl-trivial-clipboard - (let ((commit "5af3415d1484e6d69a1b5c178f24680d9fd01796")) - (package - (name "sbcl-trivial-clipboard") - (version (git-version "0.0.0.0" "2" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/snmsts/trivial-clipboard") - (commit commit))) - (file-name (git-file-name "trivial-clipboard" version)) - (sha256 - (base32 - "1gb515z5yq6h5548pb1fwhmb0hhq1ssyb78pvxh4alq799xipxs9")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("xclip" ,xclip))) - (native-inputs - `(("fiveam" ,sbcl-fiveam))) - (arguments - `(#:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "src/text.lisp" - (("\\(executable-find \"xclip\"\\)") - (string-append "(executable-find \"" - (assoc-ref inputs "xclip") - "/bin/xclip\")")))))))) - (home-page "https://github.com/snmsts/trivial-clipboard") - (synopsis "Access system clipboard in Common Lisp") - (description - "@command{trivial-clipboard} gives access to the system clipboard.") - (license license:expat)))) - -(define-public cl-trivial-clipboard - (sbcl-package->cl-source-package sbcl-trivial-clipboard)) - -(define-public ecl-trivial-clipboard - (sbcl-package->ecl-package sbcl-trivial-clipboard)) - -(define-public sbcl-trivial-backtrace - (let ((commit "ca81c011b86424a381a7563cea3b924f24e6fbeb") - (revision "1")) - (package - (name "sbcl-trivial-backtrace") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/gwkkwg/trivial-backtrace.git") - (commit commit))) - (file-name (git-file-name "trivial-backtrace" version)) - (sha256 - (base32 "10p41p43skj6cimdg8skjy7372s8v2xpkg8djjy0l8rm45i654k1")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("sbcl-lift" ,sbcl-lift))) - (home-page "https://common-lisp.net/project/trivial-backtrace/") - (synopsis "Portable simple API to work with backtraces in Common Lisp") - (description - "On of the many things that didn't quite get into the Common Lisp -standard was how to get a Lisp to output its call stack when something has -gone wrong. As such, each Lisp has developed its own notion of what to -display, how to display it, and what sort of arguments can be used to -customize it. @code{trivial-backtrace} is a simple solution to generating a -backtrace portably.") - (license license:expat)))) - -(define-public cl-trivial-backtrace - (sbcl-package->cl-source-package sbcl-trivial-backtrace)) - -(define-public sbcl-rfc2388 - (let ((commit "591bcf7e77f2c222c43953a80f8c297751dc0c4e") - (revision "1")) - (package - (name "sbcl-rfc2388") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/jdz/rfc2388.git") - (commit commit))) - (file-name (git-file-name "rfc2388" version)) - (sha256 - (base32 "0phh5n3clhl9ji8jaxrajidn22d3f0aq87mlbfkkxlnx2pnw694k")))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/jdz/rfc2388/") - (synopsis "An implementation of RFC 2388 in Common Lisp") - (description - "This package contains an implementation of RFC 2388, which is used to -process form data posted with HTTP POST method using enctype -\"multipart/form-data\".") - (license license:bsd-2)))) - -(define-public cl-rfc2388 - (sbcl-package->cl-source-package sbcl-rfc2388)) - -(define-public sbcl-md5 - (package - (name "sbcl-md5") - (version "2.0.4") - (source - (origin - (method url-fetch) - (uri (string-append - "https://github.com/pmai/md5/archive/release-" version ".tar.gz")) - (sha256 - (base32 "19yl9n0pjdz5gw4qi711lka97xcd9f81ylg434hk7jwn9f2s6w11")))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/pmai/md5") - (synopsis - "Common Lisp implementation of the MD5 Message-Digest Algorithm (RFC 1321)") - (description - "This package implements The MD5 Message-Digest Algorithm, as defined in -RFC 1321 by R. Rivest, published April 1992.") - (license license:public-domain))) - -(define-public cl-md5 - (sbcl-package->cl-source-package sbcl-md5)) - -(define-public sbcl-cl+ssl - (let ((commit "141ae91416bc40f1618dc07e48429b84388aa599") - (revision "1")) - (package - (name "sbcl-cl+ssl") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/cl-plus-ssl/cl-plus-ssl.git") - (commit commit))) - (file-name (git-file-name "cl+ssl" version)) - (sha256 - (base32 "1s0hg1h9sf8q89v0yrxmzg5f5sng29rgx3n21r9h9yql8351myan")))) - (build-system asdf-build-system/sbcl) - (arguments - '(#:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "src/reload.lisp" - (("libssl.so" all) - (string-append - (assoc-ref inputs "openssl") "/lib/" all)))))))) - (inputs - `(("openssl" ,openssl) - ("sbcl-cffi" ,sbcl-cffi) - ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams) - ("sbcl-flexi-streams" ,sbcl-flexi-streams) - ("sbcl-bordeaux-threads" ,sbcl-bordeaux-threads) - ("sbcl-trivial-garbage" ,sbcl-trivial-garbage) - ("sbcl-alexandria" ,sbcl-alexandria) - ("sbcl-trivial-features" ,sbcl-trivial-features))) - (home-page "http://common-lisp.net/project/cl-plus-ssl/") - (synopsis "Common Lisp bindings to OpenSSL") - (description - "This library is a fork of SSL-CMUCL. The original SSL-CMUCL source -code was written by Eric Marsden and includes contributions by Jochen Schmidt. -Development into CL+SSL was done by David Lichteblau.") - (license license:expat)))) - -(define-public cl-cl+ssl - (sbcl-package->cl-source-package sbcl-cl+ssl)) - -(define-public sbcl-kmrcl - (let ((version "1.109.0") - (commit "5260068b2eb735af6796740c2db4955afac21636") - (revision "1")) - (package - (name "sbcl-kmrcl") - (version (git-version version revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "http://git.kpe.io/kmrcl.git/") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1va7xjgzfv674bpsli674i7zj3f7wg5kxic41kz18r6hh4n52dfv")))) - (build-system asdf-build-system/sbcl) - (arguments - ;; Tests fail with: :FORCE and :FORCE-NOT arguments not allowed in a - ;; nested call to ASDF/OPERATE:OPERATE unless identically to toplevel - '(#:tests? #f)) - (inputs - `(("sbcl-rt" ,sbcl-rt))) - (home-page "http://files.kpe.io/kmrcl/") - (synopsis "General utilities for Common Lisp programs") - (description - "KMRCL is a collection of utilities used by a number of Kevin -Rosenberg's CL packages.") - (license license:llgpl)))) - -(define-public cl-kmrcl - (sbcl-package->cl-source-package sbcl-kmrcl)) - -(define-public sbcl-cl-base64 - (let ((version "3.3.3")) - (package - (name "sbcl-cl-base64") - (version version) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "http://git.kpe.io/cl-base64.git") - (commit (string-append "v" version)))) - (file-name (git-file-name "cl-base64" version)) - (sha256 - (base32 "1dw6j7n6gsd2qa0p0rbsjxj00acxx3i9ca1qkgl0liy8lpnwkypl")))) - (build-system asdf-build-system/sbcl) - (arguments - ;; Tests fail with: :FORCE and :FORCE-NOT arguments not allowed - ;; in a nested call to ASDF/OPERATE:OPERATE unless identically - ;; to toplevel - '(#:tests? #f)) - (inputs - `(("sbcl-ptester" ,sbcl-ptester) - ("sbcl-kmrcl" ,sbcl-kmrcl))) - (home-page "http://files.kpe.io/cl-base64/") - (synopsis - "Common Lisp package to encode and decode base64 with URI support") - (description - "This package provides highly optimized base64 encoding and decoding. -Besides conversion to and from strings, integer conversions are supported. -Encoding with Uniform Resource Identifiers is supported by using a modified -encoding table that uses only URI-compatible characters.") - (license license:bsd-3)))) - -(define-public cl-base64 - (sbcl-package->cl-source-package sbcl-cl-base64)) - -(define-public sbcl-chunga - (package - (name "sbcl-chunga") - (version "1.1.7") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/edicl/chunga.git") - (commit (string-append "v" version)))) - (file-name (git-file-name name version)) - (sha256 - (base32 "0jzn3nyb3f22gm983rfk99smqs3mhb9ivjmasvhq9qla5cl9pyhd")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams))) - (home-page "https://edicl.github.io/chunga/") - (synopsis "Portable chunked streams for Common Lisp") - (description - "Chunga implements streams capable of chunked encoding on demand as -defined in RFC 2616.") - (license license:bsd-2))) - -(define-public cl-chunga - (sbcl-package->cl-source-package sbcl-chunga)) - -(define-public sbcl-cl-who - (let ((version "1.1.4") - (commit "2c08caa4bafba720409af9171feeba3f32e86d32") - (revision "1")) - (package - (name "sbcl-cl-who") - (version (git-version version revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/edicl/cl-who.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "0yjb6sr3yazm288m318kqvj9xk8rm9n1lpimgf65ymqv0i5agxsb")))) - (build-system asdf-build-system/sbcl) - (native-inputs - `(("sbcl-flexi-streams" ,sbcl-flexi-streams))) - (home-page "https://edicl.github.io/cl-who/") - (synopsis "Yet another Lisp markup language") - (description - "There are plenty of Lisp Markup Languages out there - every Lisp -programmer seems to write at least one during his career - and CL-WHO (where -WHO means \"with-html-output\" for want of a better acronym) is probably just -as good or bad as the next one.") - (license license:bsd-2)))) - -(define-public cl-cl-who - (sbcl-package->cl-source-package sbcl-cl-who)) - -(define-public sbcl-chipz - (let ((version "0.8") - (commit "75dfbc660a5a28161c57f115adf74c8a926bfc4d") - (revision "1")) - (package - (name "sbcl-chipz") - (version (git-version version revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/froydnj/chipz.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "0plx4rs39zbs4gjk77h4a2q11zpy75fh9v8hnxrvsf8fnakajhwg")))) - (build-system asdf-build-system/sbcl) - (native-inputs - `(("sbcl-flexi-streams" ,sbcl-flexi-streams))) - (home-page "http://method-combination.net/lisp/chipz/") - (synopsis - "Common Lisp library for decompressing deflate, zlib, gzip, and bzip2 -data") - (description - "DEFLATE data, defined in RFC1951, forms the core of popular -compression formats such as zlib (RFC 1950) and gzip (RFC 1952). As such, -Chipz also provides for decompressing data in those formats as well. BZIP2 is -the format used by the popular compression tool bzip2.") - ;; The author describes it as "MIT-like" - (license license:expat)))) - -(define-public cl-chipz - (sbcl-package->cl-source-package sbcl-chipz)) - -(define-public sbcl-drakma - (let ((version "2.0.4") - (commit "7647c0ae842ff2058624e53979c7f297760c97a7") - (revision "1")) - (package - (name "sbcl-drakma") - (version (git-version version revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/edicl/drakma.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "1c4i9wakhj5pxfyyykxshdmv3180sbkrx6fcyynikmc0jd0rh84r")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("sbcl-puri" ,sbcl-puri) - ("sbcl-cl-base64" ,sbcl-cl-base64) - ("sbcl-chunga" ,sbcl-chunga) - ("sbcl-flexi-streams" ,sbcl-flexi-streams) - ("sbcl-cl-ppcre" ,sbcl-cl-ppcre) - ("sbcl-chipz" ,sbcl-chipz) - ("sbcl-usocket" ,sbcl-usocket) - ("sbcl-cl+ssl" ,sbcl-cl+ssl))) - (native-inputs - `(("sbcl-fiveam" ,sbcl-fiveam))) - (home-page "https://edicl.github.io/drakma/") - (synopsis "HTTP client written in Common Lisp") - (description - "Drakma is a full-featured HTTP client implemented in Common Lisp. It -knows how to handle HTTP/1.1 chunking, persistent connections, re-usable -sockets, SSL, continuable uploads, file uploads, cookies, and more.") - (license license:bsd-2)))) - -(define-public cl-drakma - (sbcl-package->cl-source-package sbcl-drakma)) - -(define-public sbcl-hunchentoot - (package - (name "sbcl-hunchentoot") - (version "1.2.38") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/edicl/hunchentoot.git") - (commit (string-append "v" version)))) - (file-name (git-file-name "hunchentoot" version)) - (sha256 - (base32 "1anpcad7w045m4rsjs1f3xdhjwx5cppq1h0vlb3q7dz81fi3i6yq")))) - (build-system asdf-build-system/sbcl) - (native-inputs - `(("sbcl-cl-who" ,sbcl-cl-who) - ("sbcl-drakma" ,sbcl-drakma))) - (inputs - `(("sbcl-chunga" ,sbcl-chunga) - ("sbcl-cl-base64" ,sbcl-cl-base64) - ("sbcl-cl-fad" ,sbcl-cl-fad) - ("sbcl-cl-ppcre" ,sbcl-cl-ppcre) - ("sbcl-flexi-streams" ,sbcl-flexi-streams) - ("sbcl-cl+ssl" ,sbcl-cl+ssl) - ("sbcl-md5" ,sbcl-md5) - ("sbcl-rfc2388" ,sbcl-rfc2388) - ("sbcl-trivial-backtrace" ,sbcl-trivial-backtrace) - ("sbcl-usocket" ,sbcl-usocket))) - (home-page "https://edicl.github.io/hunchentoot/") - (synopsis "Web server written in Common Lisp") - (description - "Hunchentoot is a web server written in Common Lisp and at the same -time a toolkit for building dynamic websites. As a stand-alone web server, -Hunchentoot is capable of HTTP/1.1 chunking (both directions), persistent -connections (keep-alive), and SSL.") - (license license:bsd-2))) - -(define-public cl-hunchentoot - (sbcl-package->cl-source-package sbcl-hunchentoot)) - -(define-public sbcl-trivial-types - (package - (name "sbcl-trivial-types") - (version "0.0.1") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/m2ym/trivial-types.git") - (commit "ee869f2b7504d8aa9a74403641a5b42b16f47d88"))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1s4cp9bdlbn8447q7w7f1wkgwrbvfzp20mgs307l5pxvdslin341")))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/m2ym/trivial-types") - (synopsis "Trivial type definitions for Common Lisp") - (description - "TRIVIAL-TYPES provides missing but important type definitions such as -PROPER-LIST, ASSOCIATION-LIST, PROPERTY-LIST and TUPLE.") - (license license:llgpl))) - -(define-public cl-trivial-types - (sbcl-package->cl-source-package sbcl-trivial-types)) - -(define-public sbcl-cl-syntax - (package - (name "sbcl-cl-syntax") - (version "0.0.3") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/m2ym/cl-syntax.git") - (commit "03f0c329bbd55b8622c37161e6278366525e2ccc"))) - (file-name (git-file-name "cl-syntax" version)) - (sha256 - (base32 "17ran8xp77asagl31xv8w819wafh6whwfc9p6dgx22ca537gyl4y")))) - (build-system asdf-build-system/sbcl) - (arguments - '(#:asd-file "cl-syntax.asd" - #:asd-system-name "cl-syntax")) - (inputs `(("sbcl-trivial-types" ,sbcl-trivial-types) - ("sbcl-named-readtables" ,sbcl-named-readtables))) - (home-page "https://github.com/m2ym/cl-syntax") - (synopsis "Reader Syntax Coventions for Common Lisp and SLIME") - (description - "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp and SLIME.") - (license license:llgpl))) - -(define-public cl-syntax - (sbcl-package->cl-source-package sbcl-cl-syntax)) - -(define-public sbcl-cl-annot - (let ((commit "c99e69c15d935eabc671b483349a406e0da9518d") - (revision "1")) - (package - (name "sbcl-cl-annot") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/m2ym/cl-annot.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1wq1gs9jjd5m6iwrv06c2d7i5dvqsfjcljgbspfbc93cg5xahk4n")))) - (build-system asdf-build-system/sbcl) - (arguments - '(#:asd-file "cl-annot.asd" - #:asd-system-name "cl-annot")) - (inputs - `(("sbcl-alexandria" ,sbcl-alexandria))) - (home-page "https://github.com/m2ym/cl-annot") - (synopsis "Python-like Annotation Syntax for Common Lisp.") - (description - "@code{cl-annot} is an general annotation library for Common Lisp.") - (license license:llgpl)))) - -(define-public cl-annot - (sbcl-package->cl-source-package sbcl-cl-annot)) - -(define-public sbcl-cl-syntax-annot - (package - (name "sbcl-cl-syntax-annot") - (version "0.0.3") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/m2ym/cl-syntax.git") - (commit "03f0c329bbd55b8622c37161e6278366525e2ccc"))) - (file-name (git-file-name name version)) - (sha256 - (base32 "17ran8xp77asagl31xv8w819wafh6whwfc9p6dgx22ca537gyl4y")))) - (build-system asdf-build-system/sbcl) - (arguments - '(#:asd-file "cl-syntax-annot.asd" - #:asd-system-name "cl-syntax-annot")) - (inputs - `(("sbcl-cl-syntax" ,sbcl-cl-syntax) - ("sbcl-cl-annot" ,sbcl-cl-annot))) - (home-page "https://github.com/m2ym/cl-syntax") - (synopsis "Reader Syntax Coventions for Common Lisp and SLIME") - (description - "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp and -SLIME.") - (license license:llgpl))) - -(define-public cl-syntax-annot - (sbcl-package->cl-source-package sbcl-cl-syntax-annot)) - -(define-public sbcl-cl-utilities - (let ((commit "dce2d2f6387091ea90357a130fa6d13a6776884b") - (revision "1")) - (package - (name "sbcl-cl-utilities") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method url-fetch) - (uri - (string-append - "https://gitlab.common-lisp.net/cl-utilities/cl-utilities/-/" - "archive/" commit "/cl-utilities-" commit ".tar.gz")) - (sha256 - (base32 "1r46v730yf96nk2vb24qmagv9x96xvd08abqwhf02ghgydv1a7z2")))) - (build-system asdf-build-system/sbcl) - (arguments - '(#:asd-file "cl-utilities.asd" - #:asd-system-name "cl-utilities" - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "rotate-byte.lisp" - (("in-package :cl-utilities)" all) - "in-package :cl-utilities)\n\n#+sbcl\n(require :sb-rotate-byte)"))))))) - (home-page "http://common-lisp.net/project/cl-utilities") - (synopsis "A collection of semi-standard utilities") - (description - "On Cliki.net <http://www.cliki.net/Common%20Lisp%20Utilities>, there -is a collection of Common Lisp Utilities, things that everybody writes since -they're not part of the official standard. There are some very useful things -there; the only problems are that they aren't implemented as well as you'd -like (some aren't implemented at all) and they aren't conveniently packaged -and maintained. It takes quite a bit of work to carefully implement utilities -for common use, commented and documented, with error checking placed -everywhere some dumb user might make a mistake.") - (license license:public-domain)))) - -(define-public cl-utilities - (sbcl-package->cl-source-package sbcl-cl-utilities)) - -(define-public sbcl-map-set - (let ((commit "7b4b545b68b8") - (revision "1")) - (package - (name "sbcl-map-set") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method url-fetch) - (uri (string-append - "https://bitbucket.org/tarballs_are_good/map-set/get/" - commit ".tar.gz")) - (sha256 - (base32 "1sx5j5qdsy5fklspfammwb16kjrhkggdavm922a9q86jm5l0b239")))) - (build-system asdf-build-system/sbcl) - (home-page "https://bitbucket.org/tarballs_are_good/map-set") - (synopsis "Set-like data structure") - (description - "Implementation of a set-like data structure with constant time -addition, removal, and random selection.") - (license license:bsd-3)))) - -(define-public cl-map-set - (sbcl-package->cl-source-package sbcl-map-set)) - -(define-public sbcl-quri - (let ((commit "76b75103f21ead092c9f715512fa82441ef61185") - (revision "1")) - (package - (name "sbcl-quri") - (version (git-version "0.1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/fukamachi/quri.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1ccbxsgzdibmzq33mmbmmz9vwl6l03xh6nbpsh1hkdvdcl7q0a60")))) - (build-system asdf-build-system/sbcl) - (arguments - ;; Tests fail with: Component QURI-ASD::QURI-TEST not found, - ;; required by #<SYSTEM "quri">. Why? - '(#:tests? #f)) - (native-inputs `(("sbcl-prove-asdf" ,sbcl-prove-asdf) - ("sbcl-prove" ,sbcl-prove))) - (inputs `(("sbcl-babel" ,sbcl-babel) - ("sbcl-split-sequence" ,sbcl-split-sequence) - ("sbcl-cl-utilities" ,sbcl-cl-utilities) - ("sbcl-alexandria" ,sbcl-alexandria))) - (home-page "https://github.com/fukamachi/quri") - (synopsis "Yet another URI library for Common Lisp") - (description - "QURI (pronounced \"Q-ree\") is yet another URI library for Common -Lisp. It is intended to be a replacement of PURI.") - (license license:bsd-3)))) - -(define-public cl-quri - (sbcl-package->cl-source-package sbcl-quri)) - -(define-public sbcl-myway - (let ((commit "286230082a11f879c18b93f17ca571c5f676bfb7") - (revision "1")) - (package - (name "sbcl-myway") - (version (git-version "0.1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/fukamachi/myway.git") - (commit commit))) - (file-name (git-file-name "myway" version)) - (sha256 - (base32 "0briia9bk3lbr0frnx39d1qg6i38dm4j6z9w3yga3d40k6df4a90")))) - (build-system asdf-build-system/sbcl) - (arguments - ;; Tests fail with: Component MYWAY-ASD::MYWAY-TEST not found, required - ;; by #<SYSTEM "myway">. Why? - '(#:tests? #f)) - (native-inputs - `(("sbcl-prove-asdf" ,sbcl-prove-asdf) - ("sbcl-prove" ,sbcl-prove))) - (inputs - `(("sbcl-cl-ppcre" ,sbcl-cl-ppcre) - ("sbcl-quri" ,sbcl-quri) - ("sbcl-map-set" ,sbcl-map-set))) - (home-page "https://github.com/fukamachi/myway") - (synopsis "Sinatra-compatible URL routing library for Common Lisp") - (description "My Way is a Sinatra-compatible URL routing library.") - (license license:llgpl)))) - -(define-public cl-myway - (sbcl-package->cl-source-package sbcl-myway)) - -(define-public sbcl-xsubseq - (let ((commit "5ce430b3da5cda3a73b9cf5cee4df2843034422b") - (revision "1")) - (package - (name "sbcl-xsubseq") - (version (git-version "0.0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/fukamachi/xsubseq") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1xz79q0p2mclf3sqjiwf6izdpb6xrsr350bv4mlmdlm6rg5r99px")))) - (build-system asdf-build-system/sbcl) - (arguments - ;; Tests fail with: Component XSUBSEQ-ASD::XSUBSEQ-TEST not found, - ;; required by #<SYSTEM "xsubseq">. Why? - '(#:tests? #f)) - (native-inputs - `(("sbcl-prove-asdf" ,sbcl-prove-asdf) - ("sbcl-prove" ,sbcl-prove))) - (home-page "https://github.com/fukamachi/xsubseq") - (synopsis "Efficient way to use \"subseq\"s in Common Lisp") - (description - "XSubseq provides functions to be able to handle \"subseq\"s more -effieiently.") - (license license:bsd-2)))) - -(define-public cl-xsubseq - (sbcl-package->cl-source-package sbcl-xsubseq)) - -(define-public sbcl-smart-buffer - (let ((commit "09b9a9a0b3abaa37abe9a730f5aac2643dca4e62") - (revision "1")) - (package - (name "sbcl-smart-buffer") - (version (git-version "0.0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/fukamachi/smart-buffer") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "0qz1zzxx0wm5ff7gpgsq550a59p0qj594zfmm2rglj97dahj54l7")))) - (build-system asdf-build-system/sbcl) - (arguments - ;; Tests fail with: Component SMART-BUFFER-ASD::SMART-BUFFER-TEST not - ;; found, required by #<SYSTEM "smart-buffer">. Why? - `(#:tests? #f)) - (native-inputs - `(("sbcl-prove-asdf" ,sbcl-prove-asdf) - ("sbcl-prove" ,sbcl-prove))) - (inputs - `(("sbcl-xsubseq" ,sbcl-xsubseq) - ("sbcl-flexi-streams" ,sbcl-flexi-streams))) - (home-page "https://github.com/fukamachi/smart-buffer") - (synopsis "Smart octets buffer") - (description - "Smart-buffer provides an output buffer which changes the destination -depending on content size.") - (license license:bsd-3)))) - -(define-public cl-smart-buffer - (sbcl-package->cl-source-package sbcl-smart-buffer)) - -(define-public sbcl-fast-http - (let ((commit "f9e7597191bae380503e20724fd493a24d024935") - (revision "1")) - (package - (name "sbcl-fast-http") - (version (git-version "0.2.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/fukamachi/fast-http") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "0qdmwv2zm0sizxdb8nnclgwl0nfjcbjaimbakavikijw7lr9b4jp")))) - (build-system asdf-build-system/sbcl) - (arguments - ;; Tests fail with: Component FAST-HTTP-ASD::FAST-HTTP-TEST not found, - ;; required by #<SYSTEM "fast-http">. Why? - `(#:tests? #f)) - (native-inputs - `(("sbcl-prove-asdf" ,sbcl-prove-asdf) - ("sbcl-prove" ,sbcl-prove))) - (inputs - `(("sbcl-alexandria" ,sbcl-alexandria) - ("sbcl-proc-parse" ,sbcl-proc-parse) - ("sbcl-xsubseq" ,sbcl-xsubseq) - ("sbcl-smart-buffer" ,sbcl-smart-buffer) - ("sbcl-cl-utilities" ,sbcl-cl-utilities))) - (home-page "https://github.com/fukamachi/fast-http") - (synopsis "HTTP request/response parser for Common Lisp") - (description - "@code{fast-http} is a HTTP request/response protocol parser for Common -Lisp.") - ;; Author specified the MIT license - (license license:expat)))) - -(define-public cl-fast-http - (sbcl-package->cl-source-package sbcl-fast-http)) - -(define-public sbcl-static-vectors - (let ((commit "0681eac1f49370cde03e64b077251e8abf47d702") - (revision "1")) - (package - (name "sbcl-static-vectors") - (version (git-version "1.8.3" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/sionescu/static-vectors.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "138nlsq14hv8785ycjm6jw3i6ablhq8vcwys7q09y80arcgrg6r3")))) - (native-inputs - `(("sbcl-fiveam" ,sbcl-fiveam))) - (inputs - `(("sbcl-cffi-grovel" ,sbcl-cffi-grovel) - ("sbcl-cffi" ,sbcl-cffi))) - (build-system asdf-build-system/sbcl) - (home-page "http://common-lisp.net/projects/iolib/") - (synopsis "Allocate SIMPLE-ARRAYs in static memory") - (description - "With @code{static-vectors}, you can create vectors allocated in static -memory.") - (license license:expat)))) - -(define-public cl-static-vectors - (sbcl-package->cl-source-package sbcl-static-vectors)) - -(define-public sbcl-marshal - (let ((commit "eff1b15f2b0af2f26f71ad6a4dd5c4beab9299ec") - (revision "1")) - (package - (name "sbcl-marshal") - (version (git-version "1.3.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/wlbr/cl-marshal.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "08qs6fhk38xpkkjkpcj92mxx0lgy4ygrbbzrmnivdx281syr0gwh")))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/wlbr/cl-marshal") - (synopsis "Simple (de)serialization of Lisp datastructures") - (description - "Simple and fast marshalling of Lisp datastructures. Convert any object -into a string representation, put it on a stream an revive it from there. -Only minimal changes required to make your CLOS objects serializable.") - (license license:expat)))) - -(define-public cl-marshal - (sbcl-package->cl-source-package sbcl-marshal)) - -(define-public sbcl-checkl - (let ((commit "80328800d047fef9b6e32dfe6bdc98396aee3cc9") - (revision "1")) - (package - (name "sbcl-checkl") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/rpav/CheckL.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "0bpisihx1gay44xmyr1dmhlwh00j0zzi04rp9fy35i95l2r4xdlx")))) - (build-system asdf-build-system/sbcl) - (arguments - ;; Error while trying to load definition for system checkl-test from - ;; pathname [...]/checkl-test.asd: The function CHECKL:DEFINE-TEST-OP - ;; is undefined. - '(#:tests? #f)) - (native-inputs - `(("sbcl-fiveam" ,sbcl-fiveam))) - (inputs - `(("sbcl-marshal" ,sbcl-marshal))) - (home-page "https://github.com/rpav/CheckL/") - (synopsis "Dynamic testing for Common Lisp") - (description - "CheckL lets you write tests dynamically, it checks resulting values -against the last run.") - ;; The author specifies both LLGPL and "BSD", but the "BSD" license - ;; isn't specified anywhere, so I don't know which kind. LLGPL is the - ;; stronger of the two and so I think only listing this should suffice. - (license license:llgpl)))) - -(define-public cl-checkl - (sbcl-package->cl-source-package sbcl-checkl)) - -(define-public sbcl-fast-io - (let ((commit "dc3a71db7e9b756a88781ae9c342fe9d4bbab51c") - (revision "1")) - (package - (name "sbcl-fast-io") - (version (git-version "1.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/rpav/fast-io.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1jsp6xvi26ln6fdy5j5zi05xvan8jsqdhisv552dy6xg6ws8i1yq")))) - (build-system asdf-build-system/sbcl) - (arguments - ;; Error while trying to load definition for system fast-io-test from - ;; pathname [...]/fast-io-test.asd: The function CHECKL:DEFINE-TEST-OP - ;; is undefined. - '(#:tests? #f)) - (native-inputs - `(("sbcl-fiveam" ,sbcl-fiveam) - ("sbcl-checkl" ,sbcl-checkl))) - (inputs - `(("sbcl-alexandria" ,sbcl-alexandria) - ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams) - ("sbcl-static-vectors" ,sbcl-static-vectors))) - (home-page "https://github.com/rpav/fast-io") - (synopsis "Fast octet-vector/stream I/O for Common Lisp") - (description - "Fast-io is about improving performance to octet-vectors and octet -streams (though primarily the former, while wrapping the latter).") - ;; Author specifies this as NewBSD which is an alias - (license license:bsd-3)))) - -(define-public cl-fast-io - (sbcl-package->cl-source-package sbcl-fast-io)) - -(define-public sbcl-jonathan - (let ((commit "1f448b4f7ac8265e56e1c02b32ce383e65316300") - (revision "1")) - (package - (name "sbcl-jonathan") - (version (git-version "0.1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Rudolph-Miller/jonathan.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "14x4iwz3mbag5jzzzr4sb6ai0m9r4q4kyypbq32jmsk2dx1hi807")))) - (build-system asdf-build-system/sbcl) - (arguments - ;; Tests fail with: Component JONATHAN-ASD::JONATHAN-TEST not found, - ;; required by #<SYSTEM "jonathan">. Why? - `(#:tests? #f)) - (native-inputs - `(("sbcl-prove-asdf" ,sbcl-prove-asdf) - ("sbcl-prove" ,sbcl-prove))) - (inputs - `(("sbcl-cl-syntax" ,sbcl-cl-syntax) - ("sbcl-cl-syntax-annot" ,sbcl-cl-syntax-annot) - ("sbcl-fast-io" ,sbcl-fast-io) - ("sbcl-proc-parse" ,sbcl-proc-parse) - ("sbcl-cl-ppcre" ,sbcl-cl-ppcre))) - (home-page "http://rudolph-miller.github.io/jonathan/overview.html") - (synopsis "JSON encoder and decoder") - (description - "High performance JSON encoder and decoder. Currently support: SBCL, -CCL.") - ;; Author specifies the MIT license - (license license:expat)))) - -(define-public cl-jonathan - (sbcl-package->cl-source-package sbcl-jonathan)) - -(define-public sbcl-http-body - (let ((commit "dd01dc4f5842e3d29728552e5163acce8386eb73") - (revision "1")) - (package - (name "sbcl-http-body") - (version (git-version "0.1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/fukamachi/http-body") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1jd06snjvxcprhapgfq8sx0y5lrldkvhf206ix6d5a23dd6zcmr0")))) - (build-system asdf-build-system/sbcl) - (arguments - ;; Tests fail with: Component HTTP-BODY-ASD::HTTP-BODY-TEST not - ;; found, required by #<SYSTEM "http-body">. Why? - `(#:tests? #f)) - (native-inputs - `(("sbcl-prove-asdf" ,sbcl-prove-asdf) - ("sbcl-prove" ,sbcl-prove))) - (inputs - `(("sbcl-fast-http" ,sbcl-fast-http) - ("sbcl-jonathan" ,sbcl-jonathan) - ("sbcl-quri" ,sbcl-quri))) - (home-page "https://github.com/fukamachi/http-body") - (synopsis "HTTP POST data parser") - (description - "HTTP-Body parses HTTP POST data and returns POST parameters. It -supports application/x-www-form-urlencoded, application/json, and -multipart/form-data.") - (license license:bsd-2)))) - -(define-public cl-http-body - (sbcl-package->cl-source-package sbcl-http-body)) - -(define-public sbcl-circular-streams - (let ((commit "e770bade1919c5e8533dd2078c93c3d3bbeb38df") - (revision "1")) - (package - (name "sbcl-circular-streams") - (version (git-version "0.1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/fukamachi/circular-streams") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1wpw6d5cciyqcf92f7mvihak52pd5s47kk4qq6f0r2z2as68p5rs")))) - (build-system asdf-build-system/sbcl) - (arguments - ;; The tests depend on cl-test-more which is now prove. Prove - ;; tests aren't working for some reason. - `(#:tests? #f)) - (inputs - `(("sbcl-fast-io" ,sbcl-fast-io) - ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams))) - (home-page "https://github.com/fukamachi/circular-streams") - (synopsis "Circularly readable streams for Common Lisp") - (description - "Circular-Streams allows you to read streams circularly by wrapping real -streams. Once you reach end-of-file of a stream, it's file position will be -reset to 0 and you're able to read it again.") - (license license:llgpl)))) - -(define-public cl-circular-streams - (sbcl-package->cl-source-package sbcl-circular-streams)) - -(define-public sbcl-lack-request - (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b") - (revision "1")) - (package - (name "sbcl-lack-request") - (version (git-version "0.1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/fukamachi/lack.git") - (commit commit))) - (file-name (git-file-name "lack-request" version)) - (sha256 - (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85")))) - (build-system asdf-build-system/sbcl) - (arguments - '(#:asd-file "lack-request.asd" - #:asd-system-name "lack-request" - #:test-asd-file "t-lack-request.asd" - ;; XXX: Component :CLACK-TEST not found - #:tests? #f)) - (native-inputs - `(("sbcl-prove-asdf" ,sbcl-prove-asdf) - ("sbcl-prove" ,sbcl-prove))) - (inputs - `(("sbcl-quri" ,sbcl-quri) - ("sbcl-http-body" ,sbcl-http-body) - ("sbcl-circular-streams" ,sbcl-circular-streams))) - (home-page "https://github.com/fukamachi/lack") - (synopsis "Lack, the core of Clack") - (description - "Lack is a Common Lisp library which allows web applications to be -constructed of modular components. It was originally a part of Clack, however -it's going to be rewritten as an individual project since Clack v2 with -performance and simplicity in mind.") - (license license:llgpl)))) - -(define-public cl-lack-request - (sbcl-package->cl-source-package sbcl-lack-request)) - -(define-public sbcl-local-time - (let ((commit "beac054eef428552b63d4ae7820c32ffef9a3015") - (revision "1")) - (package - (name "sbcl-local-time") - (version (git-version "1.0.6" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/dlowe-net/local-time.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "0xhkmgxh41dg2wwlsp0h2l41jp144xn4gpxhh0lna6kh0560w2cc")))) - (build-system asdf-build-system/sbcl) - (arguments - ;; TODO: Component :STEFIL not found, required by #<SYSTEM - ;; "local-time/test"> - '(#:tests? #f)) - (native-inputs - `(("stefil" ,sbcl-hu.dwim.stefil))) - (inputs - `(("sbcl-cl-fad" ,sbcl-cl-fad))) - (home-page "https://common-lisp.net/project/local-time/") - (synopsis "Time manipulation library for Common Lisp") - (description - "The LOCAL-TIME library is a Common Lisp library for the manipulation of -dates and times. It is based almost entirely upon Erik Naggum's paper \"The -Long Painful History of Time\".") - (license license:expat)))) - -(define-public cl-local-time - (sbcl-package->cl-source-package sbcl-local-time)) - -(define-public sbcl-lack-response - (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b") - (revision "1")) - (package - (name "sbcl-lack-response") - (version (git-version "0.1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/fukamachi/lack.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85")))) - (build-system asdf-build-system/sbcl) - (arguments - '(#:asd-file "lack-response.asd" - #:asd-system-name "lack-response" - ;; XXX: no tests for lack-response. - #:tests? #f)) - (native-inputs - `(("sbcl-prove-asdf" ,sbcl-prove-asdf) - ("sbcl-prove" ,sbcl-prove))) - (inputs - `(("sbcl-quri" ,sbcl-quri) - ("sbcl-http-body" ,sbcl-http-body) - ("sbcl-circular-streams" ,sbcl-circular-streams) - ("sbcl-local-time" ,sbcl-local-time))) - (home-page "https://github.com/fukamachi/lack") - (synopsis "Lack, the core of Clack") - (description - "Lack is a Common Lisp library which allows web applications to be -constructed of modular components. It was originally a part of Clack, however -it's going to be rewritten as an individual project since Clack v2 with -performance and simplicity in mind.") - (license license:llgpl)))) - -(define-public cl-lack-response - (sbcl-package->cl-source-package sbcl-lack-response)) - -(define-public sbcl-lack-component - (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b") - (revision "1")) - (package - (name "sbcl-lack-component") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/fukamachi/lack.git") - (commit commit))) - (file-name (git-file-name "lack-component" version)) - (sha256 - (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85")))) - (build-system asdf-build-system/sbcl) - (arguments - '(#:asd-file "lack-component.asd" - #:asd-system-name "lack-component" - #:test-asd-file "t-lack-component.asd" - ;; XXX: Component :LACK-TEST not found - #:tests? #f)) - (native-inputs - `(("prove-asdf" ,sbcl-prove-asdf))) - (home-page "https://github.com/fukamachi/lack") - (synopsis "Lack, the core of Clack") - (description - "Lack is a Common Lisp library which allows web applications to be -constructed of modular components. It was originally a part of Clack, however -it's going to be rewritten as an individual project since Clack v2 with -performance and simplicity in mind.") - (license license:llgpl)))) - -(define-public cl-lack-component - (sbcl-package->cl-source-package sbcl-lack-component)) - -(define-public sbcl-lack-util - (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b") - (revision "1")) - (package - (name "sbcl-lack-util") - (version (git-version "0.1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/fukamachi/lack.git") - (commit commit))) - (file-name (git-file-name "lack-util" version)) - (sha256 - (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85")))) - (build-system asdf-build-system/sbcl) - (arguments - '(#:asd-file "lack-util.asd" - #:asd-system-name "lack-util" - #:test-asd-file "t-lack-util.asd" - ;; XXX: Component :LACK-TEST not found - #:tests? #f)) - (native-inputs - `(("prove-asdf" ,sbcl-prove-asdf))) - (inputs - `(("sbcl-ironclad" ,sbcl-ironclad))) - (home-page "https://github.com/fukamachi/lack") - (synopsis "Lack, the core of Clack") - (description - "Lack is a Common Lisp library which allows web applications to be -constructed of modular components. It was originally a part of Clack, however -it's going to be rewritten as an individual project since Clack v2 with -performance and simplicity in mind.") - (license license:llgpl)))) - -(define-public cl-lack-util - (sbcl-package->cl-source-package sbcl-lack-util)) - -(define-public sbcl-lack-middleware-backtrace - (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b") - (revision "1")) - (package - (name "sbcl-lack-middleware-backtrace") - (version (git-version "0.1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/fukamachi/lack.git") - (commit commit))) - (file-name (git-file-name "lack-middleware-backtrace" version)) - (sha256 - (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85")))) - (build-system asdf-build-system/sbcl) - (arguments - '(#:asd-file "lack-middleware-backtrace.asd" - #:asd-system-name "lack-middleware-backtrace" - #:test-asd-file "t-lack-middleware-backtrace.asd" - ;; XXX: Component :LACK not found - #:tests? #f)) - (native-inputs - `(("prove-asdf" ,sbcl-prove-asdf))) - (home-page "https://github.com/fukamachi/lack") - (synopsis "Lack, the core of Clack") - (description - "Lack is a Common Lisp library which allows web applications to be -constructed of modular components. It was originally a part of Clack, however -it's going to be rewritten as an individual project since Clack v2 with -performance and simplicity in mind.") - (license license:llgpl)))) - -(define-public cl-lack-middleware-backtrace - (sbcl-package->cl-source-package sbcl-lack-middleware-backtrace)) - -(define-public sbcl-trivial-mimes - (let ((commit "303f8ac0aa6ca0bc139aa3c34822e623c3723fab") - (revision "1")) - (package - (name "sbcl-trivial-mimes") - (version (git-version "1.1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shinmera/trivial-mimes.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "17jxgl47r695bvsb7wi3n2ws5rp1zzgvw0zii8cy5ggw4b4ayv6m")))) - (build-system asdf-build-system/sbcl) - (arguments - '(#:phases - (modify-phases %standard-phases - (add-after - 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (let ((anchor "#p\"/etc/mime.types\"")) - (substitute* "mime-types.lisp" - ((anchor all) - (string-append - anchor "\n" - "(asdf:system-relative-pathname :trivial-mimes " - "\"../../share/common-lisp/" (%lisp-type) - "-source/trivial-mimes/mime.types\")"))))))))) - (native-inputs - `(("stefil" ,sbcl-hu.dwim.stefil))) - (inputs - `(("sbcl-cl-fad" ,sbcl-cl-fad))) - (home-page "http://shinmera.github.io/trivial-mimes/") - (synopsis "Tiny Common Lisp library to detect mime types in files") - (description - "This is a teensy library that provides some functions to determine the -mime-type of a file.") - (license license:artistic2.0)))) - -(define-public cl-trivial-mimes - (sbcl-package->cl-source-package sbcl-trivial-mimes)) - -(define-public ecl-trivial-mimes - (sbcl-package->ecl-package sbcl-trivial-mimes)) - -(define-public sbcl-lack-middleware-static - (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b") - (revision "1")) - (package - (name "sbcl-lack-middleware-static") - (version (git-version "0.1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/fukamachi/lack.git") - (commit commit))) - (file-name (git-file-name "lack-middleware-static" version)) - (sha256 - (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85")))) - (build-system asdf-build-system/sbcl) - (arguments - '(#:asd-file "lack-middleware-static.asd" - #:asd-system-name "lack-middleware-static" - #:test-asd-file "t-lack-middleware-static.asd" - ;; XXX: Component :LACK not found - #:tests? #f)) - (native-inputs - `(("prove-asdf" ,sbcl-prove-asdf))) - (inputs - `(("sbcl-ironclad" ,sbcl-ironclad) - ("sbcl-trivial-mimes" ,sbcl-trivial-mimes) - ("sbcl-local-time" ,sbcl-local-time))) - (home-page "https://github.com/fukamachi/lack") - (synopsis "Lack, the core of Clack") - (description - "Lack is a Common Lisp library which allows web applications to be -constructed of modular components. It was originally a part of Clack, however -it's going to be rewritten as an individual project since Clack v2 with -performance and simplicity in mind.") - (license license:llgpl)))) - -(define-public cl-lack-middleware-static - (sbcl-package->cl-source-package sbcl-lack-middleware-static)) - -(define-public sbcl-lack - (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b") - (revision "1")) - (package - (name "sbcl-lack") - (version (git-version "0.1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/fukamachi/lack.git") - (commit commit))) - (file-name (git-file-name "lack" version)) - (sha256 - (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85")))) - (build-system asdf-build-system/sbcl) - (arguments - '(#:test-asd-file "t-lack.asd" - ;; XXX: Component :CLACK not found - #:tests? #f)) - (native-inputs - `(("prove-asdf" ,sbcl-prove-asdf))) - (inputs - `(("sbcl-lack-component" ,sbcl-lack-component) - ("sbcl-lack-util" ,sbcl-lack-util))) - (home-page "https://github.com/fukamachi/lack") - (synopsis "Lack, the core of Clack") - (description - "Lack is a Common Lisp library which allows web applications to be -constructed of modular components. It was originally a part of Clack, however -it's going to be rewritten as an individual project since Clack v2 with -performance and simplicity in mind.") - (license license:llgpl)))) - -(define-public cl-lack - (sbcl-package->cl-source-package sbcl-lack)) - -(define-public sbcl-ningle - (let ((commit "50bd4f09b5a03a7249bd4d78265d6451563b25ad") - (revision "1")) - (package - (name "sbcl-ningle") - (version (git-version "0.3.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/fukamachi/ningle.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1bsl8cnxhacb8p92z9n89vhk1ikmij5zavk0m2zvmj7iqm79jzgw")))) - (build-system asdf-build-system/sbcl) - (arguments - ;; TODO: pull in clack-test - '(#:tests? #f - #:phases - (modify-phases %standard-phases - (delete 'cleanup-files) - (delete 'cleanup) - (add-before 'cleanup 'combine-fasls - (lambda* (#:key outputs #:allow-other-keys) - (let* ((out (assoc-ref outputs "out")) - (lib (string-append out "/lib/sbcl")) - (ningle-path (string-append lib "/ningle")) - (fasl-files (find-files out "\\.fasl$"))) - (mkdir-p ningle-path) - (let ((fasl-path (lambda (name) - (string-append ningle-path - "/" - (basename name) - "--system.fasl")))) - (for-each (lambda (file) - (rename-file file - (fasl-path - (basename file ".fasl")))) - fasl-files)) - fasl-files) - #t))))) - (native-inputs - `(("sbcl-prove-asdf" ,sbcl-prove-asdf) - ("sbcl-prove" ,sbcl-prove))) - (inputs - `(("sbcl-cl-syntax" ,sbcl-cl-syntax) - ("sbcl-cl-syntax-annot" ,sbcl-cl-syntax-annot) - ("sbcl-myway" ,sbcl-myway) - ("sbcl-lack-request" ,sbcl-lack-request) - ("sbcl-lack-response" ,sbcl-lack-response) - ("sbcl-lack-component" ,sbcl-lack-component) - ("sbcl-alexandria" ,sbcl-alexandria) - ("sbcl-babel" ,sbcl-babel))) - (home-page "http://8arrow.org/ningle/") - (synopsis "Super micro framework for Common Lisp") - (description - "Ningle is a lightweight web application framework for Common Lisp.") - (license license:llgpl)))) - -(define-public cl-ningle - (sbcl-package->cl-source-package sbcl-ningle)) - -(define-public sbcl-clack - (let ((commit "e3e032843bb1220ab96263c411aa7f2feb4746e0") - (revision "1")) - (package - (name "sbcl-clack") - (version (git-version "2.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/fukamachi/clack.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1ymzs6qyrwhlj6cgqsnpyn6g5cbp7a3s1vgxwna20y2q7y4iacy0")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("sbcl-lack" ,sbcl-lack) - ("sbcl-lack-middleware-backtrace" ,sbcl-lack-middleware-backtrace) - ("sbcl-bordeaux-threads" ,sbcl-bordeaux-threads))) - (home-page "https://github.com/fukamachi/clack") - (synopsis "Web Application Environment for Common Lisp") - (description - "Clack is a web application environment for Common Lisp inspired by -Python's WSGI and Ruby's Rack.") - (license license:llgpl)))) - -(define-public cl-clack - (sbcl-package->cl-source-package sbcl-clack)) - -(define-public sbcl-log4cl - (let ((commit "611e094458504b938d49de904eab141285328c7c") - (revision "1")) - (package - (name "sbcl-log4cl") - (build-system asdf-build-system/sbcl) - (version "1.1.2") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/sharplispers/log4cl") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "08jly0s0g26b56hhpfizxsb4j0yvbh946sd205gr42dkzv8l7dsc")))) - ;; FIXME: tests require stefil, sbcl-hu.dwim.stefil wont work - (arguments - `(#:tests? #f)) - (inputs `(("bordeaux-threads" ,sbcl-bordeaux-threads))) - (synopsis "Common Lisp logging framework, modeled after Log4J") - (home-page "https://github.com/7max/log4cl") - (description "This is a Common Lisp logging framework that can log at -various levels and mix text with expressions.") - (license license:asl2.0)))) - -(define-public cl-log4cl - (sbcl-package->cl-source-package sbcl-log4cl)) - -(define-public ecl-log4cl - (sbcl-package->ecl-package sbcl-log4cl)) - -(define-public sbcl-find-port - (let ((commit "00c96a25af93a0f8681d34ec548861f2d7485478") - (revision "1")) - (package - (name "sbcl-find-port") - (build-system asdf-build-system/sbcl) - (version "0.1") - (home-page "https://github.com/eudoxia0/find-port") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "0d6dzbb45jh0rx90wgs6v020k2xa87mvzas3mvfzvivjvqqlpryq")))) - (native-inputs - `(("fiveam" ,sbcl-fiveam))) - (inputs - `(("sbcl-usocket" ,sbcl-usocket))) - (synopsis "Find open ports programmatically in Common Lisp") - (description "This is a small Common Lisp library that finds an open -port within a range.") - (license license:expat)))) - -(define-public cl-find-port - (sbcl-package->cl-source-package sbcl-find-port)) - -(define-public ecl-find-port - (sbcl-package->ecl-package sbcl-find-port)) - -(define-public sbcl-clunit - (let ((commit "6f6d72873f0e1207f037470105969384f8380628") - (revision "1")) - (package - (name "sbcl-clunit") - (version (git-version "0.2.3" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/tgutu/clunit.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "1idf2xnqzlhi8rbrqmzpmb3i1l6pbdzhhajkmhwbp6qjkmxa4h85")))) - (build-system asdf-build-system/sbcl) - (synopsis "CLUnit is a Common Lisp unit testing framework") - (description - "CLUnit is a Common Lisp unit testing framework. It is designed -to be easy to use so that you can quickly start testing. CLUnit -provides a rich set of features aimed at improving your unit testing -experience.") - (home-page "http://tgutu.github.io/clunit/") - ;; MIT License - (license license:expat)))) - -(define-public cl-clunit - (sbcl-package->cl-source-package sbcl-clunit)) - -(define-public ecl-clunit - (sbcl-package->ecl-package sbcl-clunit)) - -(define-public sbcl-py4cl - (let ((commit "4c8a2b0814fd311f978964f825ce012290f60136") - (revision "1")) - (package - (name "sbcl-py4cl") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/bendudson/py4cl.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "15mk7qdqjkj56gdnbyrdyz6r7m1h26ldvn6ch96pmvg5vmr1m45r")) - (modules '((guix build utils))))) - (build-system asdf-build-system/sbcl) - (native-inputs - `(("sbcl-clunit" ,sbcl-clunit))) - (inputs - `(("sbcl-trivial-garbage" ,sbcl-trivial-garbage))) - (propagated-inputs - ;; This package doesn't do anything without python available - `(("python" ,python) - ;; For multi-dimensional array support - ("python-numpy" ,python-numpy))) - (arguments - '(#:phases - (modify-phases %standard-phases - (add-after 'unpack 'replace-*base-directory*-var - (lambda* (#:key outputs #:allow-other-keys) - ;; In the ASD, the author makes an attempt to - ;; programatically determine the location of the - ;; source-code so lisp can call into "py4cl.py". We can - ;; hard-code this since we know where this file will - ;; reside. - (substitute* "src/callpython.lisp" - (("py4cl/config:\\*base-directory\\*") - (string-append - "\"" - (assoc-ref outputs "out") - "/share/common-lisp/sbcl-source/py4cl/" - "\"")))))))) - (synopsis "Call python from Common Lisp") - (description - "Py4CL is a bridge between Common Lisp and Python, which enables Common -Lisp to interact with Python code. It uses streams to communicate with a -separate python process, the approach taken by cl4py. This is different to -the CFFI approach used by burgled-batteries, but has the same goal.") - (home-page "https://github.com/bendudson/py4cl") - ;; MIT License - (license license:expat)))) - -(define-public cl-py4cl - (sbcl-package->cl-source-package sbcl-py4cl)) - -(define-public ecl-py4cl - (sbcl-package->ecl-package sbcl-py4cl)) - -(define-public sbcl-parse-declarations - (package - (name "sbcl-parse-declarations") - (version "1.0.0") - (source - (origin - (method url-fetch) - (uri (string-append - "http://beta.quicklisp.org/archive/parse-declarations/" - "2010-10-06/parse-declarations-20101006-darcs.tgz")) - (sha256 - (base32 - "0r85b0jfacd28kr65kw9c13dx4i6id1dpmby68zjy63mqbnyawrd")))) - (build-system asdf-build-system/sbcl) - (arguments - `(#:asd-file "parse-declarations-1.0.asd" - #:asd-system-name "parse-declarations-1.0")) - (home-page "https://common-lisp.net/project/parse-declarations/") - (synopsis "Parse, filter, and build declarations") - (description - "Parse-Declarations is a Common Lisp library to help writing -macros which establish bindings. To be semantically correct, such -macros must take user declarations into account, as these may affect -the bindings they establish. Yet the ANSI standard of Common Lisp does -not provide any operators to work with declarations in a convenient, -high-level way. This library provides such operators.") - ;; MIT License - (license license:expat))) - -(define-public cl-parse-declarations - (sbcl-package->cl-source-package sbcl-parse-declarations)) - -(define-public ecl-parse-declarations - (sbcl-package->ecl-package sbcl-parse-declarations)) - -(define-public sbcl-cl-quickcheck - (let ((commit "807b2792a30c883a2fbecea8e7db355b50ba662f") - (revision "1")) - (package - (name "sbcl-cl-quickcheck") - (version (git-version "0.0.4" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/mcandre/cl-quickcheck.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "165lhypq5xkcys6hvzb3jq7ywnmqvzaflda29qk2cbs3ggas4767")))) - (build-system asdf-build-system/sbcl) - (synopsis - "Common Lisp port of the QuickCheck unit test framework") - (description - "Common Lisp port of the QuickCheck unit test framework") - (home-page "https://github.com/mcandre/cl-quickcheck") - ;; MIT - (license license:expat)))) - -(define-public cl-cl-quickcheck - (sbcl-package->cl-source-package sbcl-cl-quickcheck)) - -(define-public ecl-cl-quickcheck - (sbcl-package->ecl-package sbcl-cl-quickcheck)) - -(define-public sbcl-burgled-batteries3 - (let ((commit "9c0f6667e1a71ddf77e21793a0bea524710fef6e") - (revision "1")) - (package - (name "sbcl-burgled-batteries3") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/snmsts/burgled-batteries3.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "0b726kz2xxcg5l930gz035rsdvhxrzmp05iwfwympnb4z4ammicb")))) - (build-system asdf-build-system/sbcl) - (arguments - '(#:tests? #f - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'set-*cpython-include-dir*-var - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "grovel-include-dir.lisp" - (("\\(defparameter \\*cpython-include-dir\\* \\(detect-python\\)\\)") - (string-append - "(defparameter *cpython-include-dir* \"" - (assoc-ref inputs "python") - "/include/python3.7m" - "\")"))) - (substitute* "ffi-interface.lisp" - (("\\*cpython-lib\\*") - (format #f "'(\"~a/lib/libpython3.so\")" - (assoc-ref inputs "python")))) - #t))))) - (native-inputs - `(("python" ,python) - ("sbcl-cl-fad" ,sbcl-cl-fad) - ("sbcl-lift" ,sbcl-lift) - ("sbcl-cl-quickcheck" ,sbcl-cl-quickcheck))) - (inputs - `(("sbcl-cffi" ,sbcl-cffi) - ("sbcl-cffi-grovel" ,sbcl-cffi-grovel) - ("sbcl-alexandria" , sbcl-alexandria) - ("sbcl-parse-declarations-1.0" ,sbcl-parse-declarations) - ("sbcl-trivial-garbage" ,sbcl-trivial-garbage))) - (synopsis "Bridge between Python and Lisp (FFI bindings, etc.)") - (description - "This package provides a shim between Python3 (specifically, the -CPython implementation of Python) and Common Lisp.") - (home-page "https://github.com/snmsts/burgled-batteries3") - ;; MIT - (license license:expat)))) - -(define-public cl-burgled-batteries3 - (sbcl-package->cl-source-package sbcl-burgled-batteries3)) - -(define-public ecl-burgled-batteries3 - (sbcl-package->ecl-package sbcl-burgled-batteries3)) - -(define-public sbcl-metabang-bind - (let ((commit "c93b7f7e1c18c954c2283efd6a7fdab36746ab5e") - (revision "1")) - (package - (name "sbcl-metabang-bind") - (version (git-version "0.8.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/gwkkwg/metabang-bind.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "0hd0kr91795v77akpbcyqiss9p0p7ypa9dznrllincnmgvsxlmf0")))) - (build-system asdf-build-system/sbcl) - (native-inputs - `(("sbcl-lift" ,sbcl-lift))) - (synopsis "Macro that generalizes @code{multiple-value-bind} etc.") - (description - "Bind extends the idea of of let and destructing to provide a uniform -syntax for all your accessor needs. It combines @code{let}, -@code{destructuring-bind}, @code{with-slots}, @code{with-accessors}, structure -editing, property or association-lists, and @code{multiple-value-bind} and a -whole lot more into a single form.") - (home-page "https://common-lisp.net/project/metabang-bind/") - ;; MIT License - (license license:expat)))) - -(define-public cl-metabang-bind - (sbcl-package->cl-source-package sbcl-metabang-bind)) - -(define-public ecl-metabang-bind - (sbcl-package->ecl-package sbcl-metabang-bind)) - -(define-public sbcl-fare-utils - (let ((commit "66e9c6f1499140bc00ccc22febf2aa528cbb5724") - (revision "1")) - (package - (name "sbcl-fare-utils") - (version (git-version "1.0.0.5" revision commit)) - (source - (origin - (method git-fetch) - (uri - (git-reference - (url - "https://gitlab.common-lisp.net/frideau/fare-utils.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "01wsr1aap3jdzhn4hrqjbhsjx6qci9dbd3gh4gayv1p49rbg8aqr")))) - (build-system asdf-build-system/sbcl) - (arguments - `(#:test-asd-file "test/fare-utils-test.asd")) - (native-inputs - `(("sbcl-hu.dwim.stefil" ,sbcl-hu.dwim.stefil))) - (synopsis "Collection of utilities and data structures") - (description - "fare-utils is a small collection of utilities. It contains a lot of -basic everyday functions and macros.") - (home-page "https://gitlab.common-lisp.net/frideau/fare-utils") - ;; MIT License - (license license:expat)))) - -(define-public cl-fare-utils - (sbcl-package->cl-source-package sbcl-fare-utils)) - -(define-public ecl-fare-utils - (sbcl-package->ecl-package sbcl-fare-utils)) - -(define-public sbcl-trivial-utf-8 - (let ((commit "4d427cfbb1c452436a0efb71c3205c9da67f718f") - (revision "1")) - (package - (name "sbcl-trivial-utf-8") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri - (git-reference - (url (string-append "https://gitlab.common-lisp.net/" - "trivial-utf-8/trivial-utf-8.git")) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "1jz27gz8gvqdmvp3k9bxschs6d5b3qgk94qp2bj6nv1d0jc3m1l1")))) - (arguments - ;; Guix incorrectly assumes the "8" is part of the version - ;; number and lobs it off. - `(#:asd-file "trivial-utf-8.asd" - #:asd-system-name "trivial-utf-8")) - (build-system asdf-build-system/sbcl) - (synopsis "UTF-8 input/output library") - (description - "The Babel library solves a similar problem while understanding more -encodings. Trivial UTF-8 was written before Babel existed, but for new -projects you might be better off going with Babel. The one plus that Trivial -UTF-8 has is that it doesn't depend on any other libraries.") - (home-page "https://common-lisp.net/project/trivial-utf-8/") - (license license:bsd-3)))) - -(define-public cl-trivial-utf-8 - (sbcl-package->cl-source-package sbcl-trivial-utf-8)) - -(define-public ecl-trivial-utf-8 - (sbcl-package->ecl-package sbcl-trivial-utf-8)) - -(define-public sbcl-idna - (package - (name "sbcl-idna") - (build-system asdf-build-system/sbcl) - (version "0.2.2") - (home-page "https://github.com/antifuchs/idna") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit version))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "00nbr3mffxhlq14gg9d16pa6691s4qh35inyw76v906s77khm5a2")))) - (inputs - `(("split-sequence" ,sbcl-split-sequence))) - (synopsis "IDNA string encoding and decoding routines for Common Lisp") - (description "This Common Lisp library provides string encoding and -decoding routines for IDNA, the International Domain Names in Applications.") - (license license:expat))) - -(define-public cl-idna - (sbcl-package->cl-source-package sbcl-idna)) - -(define-public ecl-idna - (sbcl-package->ecl-package sbcl-idna)) - -(define-public sbcl-swap-bytes - (package - (name "sbcl-swap-bytes") - (build-system asdf-build-system/sbcl) - (version "1.1") - (home-page "https://github.com/sionescu/swap-bytes") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit (string-append "v" version)))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "1qysbv0jngdfkv53y874qjhcxc4qi8ixaqq6j8bzxh5z0931wv55")))) - (inputs - `(("trivial-features" ,sbcl-trivial-features))) - (native-inputs - `(("fiveam" ,sbcl-fiveam))) - (arguments - ;; TODO: Tests fail, why? - `(#:tests? #f)) - (synopsis "Efficient endianness conversion for Common Lisp") - (description "This Common Lisp library provides optimized byte-swapping -primitives. The library can change endianness of unsigned integers of length -1/2/4/8. Very useful in implementing various network protocols and file -formats.") - (license license:expat))) - -(define-public cl-swap-bytes - (sbcl-package->cl-source-package sbcl-swap-bytes)) - -(define-public ecl-swap-bytes - (sbcl-package->ecl-package sbcl-swap-bytes)) - -(define-public sbcl-iolib.asdf - ;; Latest release is from June 2017. - (let ((commit "81e20614c0d27f9605bf9766214e236fd31b99b4") - (revision "1")) - (package - (name "sbcl-iolib.asdf") - (build-system asdf-build-system/sbcl) - (version "0.8.3") - (home-page "https://github.com/sionescu/iolib") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "1j81r0wm7nfbwl991f26s4npcy7kybzybd3m47rbxy31h0cfcmdm")))) - (inputs - `(("alexandria" ,sbcl-alexandria))) - (arguments - '(#:asd-file "iolib.asdf.asd")) - (synopsis "ASDF component classes for IOLib, a Common Lisp I/O library") - (description "IOlib is to be a better and more modern I/O library than -the standard Common Lisp library. It contains a socket library, a DNS -resolver, an I/O multiplexer(which supports @code{select(2)}, @code{epoll(4)} -and @code{kqueue(2)}), a pathname library and file-system utilities.") - (license license:expat)))) - -(define-public sbcl-iolib.conf - (package - (inherit sbcl-iolib.asdf) - (name "sbcl-iolib.conf") - (inputs - `(("iolib.asdf" ,sbcl-iolib.asdf))) - (arguments - '(#:asd-file "iolib.conf.asd")) - (synopsis "Compile-time configuration for IOLib, a Common Lisp I/O library"))) - -(define-public sbcl-iolib.common-lisp - (package - (inherit sbcl-iolib.asdf) - (name "sbcl-iolib.common-lisp") - (inputs - `(("iolib.asdf" ,sbcl-iolib.asdf) - ("iolib.conf" ,sbcl-iolib.conf))) - (arguments - '(#:asd-file "iolib.common-lisp.asd")) - (synopsis "Slightly modified Common Lisp for IOLib, a Common Lisp I/O library"))) - -(define-public sbcl-iolib.base - (package - (inherit sbcl-iolib.asdf) - (name "sbcl-iolib.base") - (inputs - `(("iolib.asdf" ,sbcl-iolib.asdf) - ("iolib.conf" ,sbcl-iolib.conf) - ("iolib.common-lisp" ,sbcl-iolib.common-lisp) - ("split-sequence" ,sbcl-split-sequence))) - (arguments - '(#:asd-file "iolib.base.asd")) - (synopsis "Base package for IOLib, a Common Lisp I/O library"))) - -(define-public sbcl-iolib.grovel - (package - (inherit sbcl-iolib.asdf) - (name "sbcl-iolib.grovel") - (inputs - `(("iolib.asdf" ,sbcl-iolib.asdf) - ("iolib.conf" ,sbcl-iolib.conf) - ("iolib.base", sbcl-iolib.base) - ("cffi", sbcl-cffi))) - (arguments - '(#:asd-file "iolib.grovel.asd" - #:phases - (modify-phases %standard-phases - (add-after 'install 'install-header - (lambda* (#:key outputs #:allow-other-keys) - ;; This header is required by sbcl-iolib. - (install-file "src/grovel/grovel-common.h" - (string-append (assoc-ref outputs "out") - "/lib/sbcl")) - #t))))) - (synopsis "CFFI Groveller for IOLib, a Common Lisp I/O library"))) - -(define-public sbcl-iolib - (package - (inherit sbcl-iolib.asdf) - (name "sbcl-iolib") - (inputs - `(("iolib.asdf" ,sbcl-iolib.asdf) - ("iolib.conf" ,sbcl-iolib.conf) - ("iolib.grovel" ,sbcl-iolib.grovel) - ("iolib.base" ,sbcl-iolib.base) - ("bordeaux-threads" ,sbcl-bordeaux-threads) - ("idna" ,sbcl-idna) - ("swap-bytes" ,sbcl-swap-bytes) - ("libfixposix" ,libfixposix) - ("cffi" ,sbcl-cffi))) - (native-inputs - `(("fiveam" ,sbcl-fiveam))) - (arguments - '(#:asd-file "iolib.asd" - #:asd-system-name "iolib" - #:test-asd-file "iolib.tests.asd" - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "src/syscalls/ffi-functions-unix.lisp" - (("\\(:default \"libfixposix\"\\)") - (string-append - "(:default \"" - (assoc-ref inputs "libfixposix") "/lib/libfixposix\")"))) - ;; Socket tests need Internet access, disable them. - (substitute* "iolib.tests.asd" - (("\\(:file \"sockets\" :depends-on \\(\"pkgdcl\" \"defsuites\"\\)\\)") - ""))))))) - (synopsis "Common Lisp I/O library"))) - -(define-public cl-iolib - (sbcl-package->cl-source-package sbcl-iolib)) - -(define sbcl-iolib+multiplex - (package - (inherit sbcl-iolib) - (name "sbcl-iolib+multiplex") - (arguments - (substitute-keyword-arguments (package-arguments sbcl-iolib) - ((#:asd-system-name _) "iolib/multiplex"))))) - -(define sbcl-iolib+syscalls - (package - (inherit sbcl-iolib) - (name "sbcl-iolib+syscalls") - (arguments - (substitute-keyword-arguments (package-arguments sbcl-iolib) - ((#:asd-system-name _) "iolib/syscalls"))))) - -(define sbcl-iolib+streams - (package - (inherit sbcl-iolib) - (name "sbcl-iolib+streams") - (arguments - (substitute-keyword-arguments (package-arguments sbcl-iolib) - ((#:asd-system-name _) "iolib/streams"))))) - -(define sbcl-iolib+sockets - (package - (inherit sbcl-iolib) - (name "sbcl-iolib+sockets") - (arguments - (substitute-keyword-arguments (package-arguments sbcl-iolib) - ((#:asd-system-name _) "iolib/sockets"))))) - -(define-public sbcl-ieee-floats - (let ((commit "566b51a005e81ff618554b9b2f0b795d3b29398d") - (revision "1")) - (package - (name "sbcl-ieee-floats") - (build-system asdf-build-system/sbcl) - (version (git-version "20170924" revision commit)) - (home-page "https://github.com/marijnh/ieee-floats/") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "1xyj49j9x3lc84cv3dhbf9ja34ywjk1c46dklx425fxw9mkwm83m")))) - (native-inputs - `(("fiveam" ,sbcl-fiveam))) - (synopsis "IEEE 754 binary representation for floats in Common Lisp") - (description "This is a Common Lisp library that allows to convert -floating point values to IEEE 754 binary representation.") - (license license:bsd-3)))) - -(define-public cl-ieee-floats - (sbcl-package->cl-source-package sbcl-ieee-floats)) - -(define sbcl-closure-common - (let ((commit "e3c5f5f454b72b01b89115e581c3c52a7e201e5c") - (revision "1")) - (package - (name "sbcl-closure-common") - (build-system asdf-build-system/sbcl) - (version (git-version "20101006" revision commit)) - (home-page "https://common-lisp.net/project/cxml/") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/sharplispers/closure-common") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "0k5r2qxn122pxi301ijir3nayi9sg4d7yiy276l36qmzwhp4mg5n")))) - (inputs - `(("trivial-gray-streams" ,sbcl-trivial-gray-streams) - ("babel" ,sbcl-babel))) - (synopsis "Support Common Lisp library for CXML") - (description "Closure-common is an internal helper library. The name -Closure is a reference to the web browser it was originally written for.") - ;; TODO: License? - (license #f)))) - -(define-public sbcl-cxml+xml - (let ((commit "00b22bf4c4cf11c993d5866fae284f95ab18e6bf") - (revision "1")) - (package - (name "sbcl-cxml+xml") - (build-system asdf-build-system/sbcl) - (version (git-version "0.0.0" revision commit)) - (home-page "https://common-lisp.net/project/cxml/") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/sharplispers/cxml") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "13kif7rf3gqdycsk9zq0d7y0g9y81krkl0z87k0p2fkbjfgrph37")))) - (inputs - `(("closure-common" ,sbcl-closure-common) - ("puri" ,sbcl-puri) - ("trivial-gray-streams" ,sbcl-trivial-gray-streams))) - (arguments - `(#:asd-file "cxml.asd" - #:asd-system-name "cxml/xml")) - (synopsis "Common Lisp XML parser") - (description "CXML implements a namespace-aware, validating XML 1.0 -parser as well as the DOM Level 2 Core interfaces. Two parser interfaces are -offered, one SAX-like, the other similar to StAX.") - (license license:llgpl)))) - -(define sbcl-cxml+dom - (package - (inherit sbcl-cxml+xml) - (name "sbcl-cxml+dom") - (inputs - `(("closure-common" ,sbcl-closure-common) - ("puri" ,sbcl-puri) - ("cxml+xml" ,sbcl-cxml+xml))) - (arguments - `(#:asd-file "cxml.asd" - #:asd-system-name "cxml/dom")))) - -(define sbcl-cxml+klacks - (package - (inherit sbcl-cxml+xml) - (name "sbcl-cxml+klacks") - (inputs - `(("closure-common" ,sbcl-closure-common) - ("puri" ,sbcl-puri) - ("cxml+xml" ,sbcl-cxml+xml))) - (arguments - `(#:asd-file "cxml.asd" - #:asd-system-name "cxml/klacks")))) - -(define sbcl-cxml+test - (package - (inherit sbcl-cxml+xml) - (name "sbcl-cxml+test") - (inputs - `(("closure-common" ,sbcl-closure-common) - ("puri" ,sbcl-puri) - ("cxml+xml" ,sbcl-cxml+xml))) - (arguments - `(#:asd-file "cxml.asd" - #:asd-system-name "cxml/test")))) - -(define-public sbcl-cxml - (package - (inherit sbcl-cxml+xml) - (name "sbcl-cxml") - (inputs - `(("closure-common" ,sbcl-closure-common) - ("puri" ,sbcl-puri) - ("trivial-gray-streams" ,sbcl-trivial-gray-streams) - ("cxml+dom" ,sbcl-cxml+dom) - ("cxml+klacks" ,sbcl-cxml+klacks) - ("cxml+test" ,sbcl-cxml+test))) - (arguments - `(#:asd-file "cxml.asd" - #:asd-system-name "cxml" - #:phases - (modify-phases %standard-phases - (add-after 'build 'install-dtd - (lambda* (#:key outputs #:allow-other-keys) - (install-file "catalog.dtd" - (string-append - (assoc-ref outputs "out") - "/lib/" (%lisp-type))))) - (add-after 'create-asd 'remove-component - ;; XXX: The original .asd has no components, but our build system - ;; creates an entry nonetheless. We need to remove it for the - ;; generated .asd to load properly. See trivia.trivial for a - ;; similar problem. - (lambda* (#:key outputs #:allow-other-keys) - (let* ((out (assoc-ref outputs "out")) - (asd (string-append out "/lib/sbcl/cxml.asd"))) - (substitute* asd - ((" :components -") - "")) - (substitute* asd - ((" *\\(\\(:compiled-file \"cxml--system\"\\)\\)") - "")))))))))) - -(define-public cl-cxml - (sbcl-package->cl-source-package sbcl-cxml)) - -(define-public sbcl-cl-reexport - (let ((commit "312f3661bbe187b5f28536cd7ec2956e91366c3b") - (revision "1")) - (package - (name "sbcl-cl-reexport") - (build-system asdf-build-system/sbcl) - (version (git-version "0.1" revision commit)) - (home-page "https://github.com/takagi/cl-reexport") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "1cwpn1m3wrl0fl9plznn7p464db646gnfc8zkyk97dyxski2aq0x")))) - (inputs - `(("alexandria" ,sbcl-alexandria))) - (arguments - ;; TODO: Tests fail because cl-test-more is missing, but I can't find it online. - `(#:tests? #f)) - (synopsis "HTTP cookie manager for Common Lisp") - (description "cl-cookie is a Common Lisp library featuring parsing of -cookie headers, cookie creation, cookie jar creation and more.") - (license license:llgpl)))) - -(define-public cl-reexport - (sbcl-package->cl-source-package sbcl-cl-reexport)) - -(define-public sbcl-cl-cookie - (let ((commit "cea55aed8b9ad25fafd13defbcb9fe8f41b29546") - (revision "1")) - (package - (name "sbcl-cl-cookie") - (build-system asdf-build-system/sbcl) - (version (git-version "0.9.10" revision commit)) - (home-page "https://github.com/fukamachi/cl-cookie") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "090g7z75h98zvc1ldx0vh4jn4086dhjm2w30jcwkq553qmyxwl8h")))) - (inputs - `(("proc-parse" ,sbcl-proc-parse) - ("alexandria" ,sbcl-alexandria) - ("quri" ,sbcl-quri) - ("cl-ppcre" ,sbcl-cl-ppcre) - ("local-time" ,sbcl-local-time))) - (native-inputs - `(("prove-asdf" ,sbcl-prove-asdf) - ("prove" ,sbcl-prove))) - (arguments - ;; TODO: Tests fail because cl-cookie depends on cl-cookie-test. - `(#:tests? #f)) - (synopsis "HTTP cookie manager for Common Lisp") - (description "cl-cookie is a Common Lisp library featuring parsing of -cookie headers, cookie creation, cookie jar creation and more.") - (license license:bsd-2)))) - -(define-public cl-cookie - (sbcl-package->cl-source-package sbcl-cl-cookie)) - -(define-public sbcl-dexador - (let ((commit "a2714d126cc94bc7a9a6e1e3c08de455b3a66378") - (revision "1")) - (package - (name "sbcl-dexador") - (build-system asdf-build-system/sbcl) - (version (git-version "0.9.10" revision commit)) - (home-page "https://github.com/fukamachi/dexador") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "0nbqgn4v3l2z6m1k1bdxfnqpfrk84nxdmz7csz11zzcfs4flkv79")))) - (inputs - `(("trivial-gray-streams" ,sbcl-trivial-gray-streams) - ("babel" ,sbcl-babel) - ("usocket" ,sbcl-usocket) - ("fast-http" ,sbcl-fast-http) - ("quri" ,sbcl-quri) - ("fast-io" ,sbcl-fast-io) - ("chunga" ,sbcl-chunga) - ("cl-ppcre" ,sbcl-cl-ppcre) - ("cl-cookie" ,sbcl-cl-cookie) - ("trivial-mimes" ,sbcl-trivial-mimes) - ("chipz" ,sbcl-chipz) - ("cl-base64" ,sbcl-cl-base64) - ("cl-reexport" ,sbcl-cl-reexport) - ("cl+ssl" ,sbcl-cl+ssl) - ("bordeaux-threads" ,sbcl-bordeaux-threads) - ("alexandria" ,sbcl-alexandria))) - (native-inputs - `(("prove" ,sbcl-prove) - ("prove-asdf" ,sbcl-prove-asdf) - ("lack-request" ,sbcl-lack-request) - ("clack" ,sbcl-clack) - ("babel" ,sbcl-babel) - ("alexandria" ,sbcl-alexandria) - ("cl-ppcre" ,sbcl-cl-ppcre) - ("local-time" ,sbcl-local-time))) - (arguments - ;; TODO: Circular dependency: tests depend on clack-test which depends on dexador. - `(#:tests? #f - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-permissions - (lambda _ (make-file-writable "t/data/test.gz") #t))))) - (synopsis "Yet another HTTP client for Common Lisp") - (description "Dexador is yet another HTTP client for Common Lisp with -neat APIs and connection-pooling. It is meant to supersede Drakma.") - (license license:expat)))) - -(define-public cl-dexador - (package - (inherit (sbcl-package->cl-source-package sbcl-dexador)) - (arguments - `(#:phases - ;; asdf-build-system/source has its own phases and does not inherit - ;; from asdf-build-system/sbcl phases. - (modify-phases %standard-phases/source - (add-after 'unpack 'fix-permissions - (lambda _ (make-file-writable "t/data/test.gz") #t))))))) - -(define-public ecl-dexador - (sbcl-package->ecl-package sbcl-dexador)) - -(define-public sbcl-lisp-namespace - (let ((commit "28107cafe34e4c1c67490fde60c7f92dc610b2e0") - (revision "1")) - (package - (name "sbcl-lisp-namespace") - (build-system asdf-build-system/sbcl) - (version (git-version "0.1" revision commit)) - (home-page "https://github.com/guicho271828/lisp-namespace") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "1jw2wykp06z2afb9nm1lgfzll5cjlj36pnknjx614057zkkxq4iy")))) - (inputs - `(("alexandria" ,sbcl-alexandria))) - (native-inputs - `(("fiveam" ,sbcl-fiveam))) - (arguments - `(#:test-asd-file "lisp-namespace.test.asd" - ;; XXX: Component LISP-NAMESPACE-ASD::LISP-NAMESPACE.TEST not found - #:tests? #f)) - (synopsis "LISP-N, or extensible namespaces in Common Lisp") - (description "Common Lisp already has major 2 namespaces, function -namespace and value namespace (or variable namespace), but there are actually -more — e.g., class namespace. -This library offers macros to deal with symbols from any namespace.") - (license license:llgpl)))) - -(define-public cl-lisp-namespace - (sbcl-package->cl-source-package sbcl-lisp-namespace)) - -(define-public sbcl-trivial-cltl2 - (let ((commit "8eec8407df833e8f27df8a388bc10913f16d9e83") - (revision "1")) - (package - (name "sbcl-trivial-cltl2") - (build-system asdf-build-system/sbcl) - (version (git-version "0.1.1" revision commit)) - (home-page "https://github.com/Zulu-Inuoe/trivial-cltl2") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "1dyyxz17vqv8hlfwq287gl8xxbvcnq798ajb7p5jdjz91wqf4bgk")))) - (synopsis "Simple CLtL2 compatibility layer for Common Lisp") - (description "This library is a portable compatibility layer around -\"Common Lisp the Language, 2nd -Edition\" (@url{https://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node102.html}) -and it exports symbols from implementation-specific packages.") - (license license:llgpl)))) - -(define-public cl-trivial-cltl2 - (sbcl-package->cl-source-package sbcl-trivial-cltl2)) - -(define-public sbcl-introspect-environment - (let ((commit "fff42f8f8fd0d99db5ad6c5812e53de7d660020b") - (revision "1")) - (package - (name "sbcl-introspect-environment") - (build-system asdf-build-system/sbcl) - (version (git-version "0.1" revision commit)) - (home-page "https://github.com/Bike/introspect-environment") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "1i305n0wfmpac63ni4i3vixnnkl8daw5ncxy0k3dv92krgx6qzhp")))) - (native-inputs - `(("fiveam" ,sbcl-fiveam))) - (synopsis "Common Lisp environment introspection portability layer") - (description "This library is a small interface to portable but -nonstandard introspection of Common Lisp environments. It is intended to -allow a bit more compile-time introspection of environments in Common Lisp. - -Quite a bit of information is available at the time a macro or compiler-macro -runs; inlining info, type declarations, that sort of thing. This information -is all standard - any Common Lisp program can @code{(declare (integer x))} and -such. - -This info ought to be accessible through the standard @code{&environment} -parameters, but it is not. Several implementations keep the information for -their own purposes but do not make it available to user programs, because -there is no standard mechanism to do so. - -This library uses implementation-specific hooks to make information available -to users. This is currently supported on SBCL, CCL, and CMUCL. Other -implementations have implementations of the functions that do as much as they -can and/or provide reasonable defaults.") - (license license:wtfpl2)))) - -(define-public cl-introspect-environment - (sbcl-package->cl-source-package sbcl-introspect-environment)) - -(define-public sbcl-type-i - (let ((commit "dea233f45f94064105ec09f0767de338f67dcbe2") - (revision "1")) - (package - (name "sbcl-type-i") - (build-system asdf-build-system/sbcl) - (version (git-version "0.1" revision commit)) - (home-page "https://github.com/guicho271828/type-i") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "039g5pbrhh65s0bhr9314gmd2nwc2y5lp2377c5qrc2lxky89qs3")))) - (inputs - `(("alexandria" ,sbcl-alexandria) - ("introspect-environment" ,sbcl-introspect-environment) - ("trivia.trivial" ,sbcl-trivia.trivial))) - (native-inputs - `(("fiveam" ,sbcl-fiveam))) - (arguments - `(#:test-asd-file "type-i.test.asd")) - (synopsis "Type inference utility on unary predicates for Common Lisp") - (description "This library tries to provide a way to detect what kind of -type the given predicate is trying to check. This is different from inferring -the return type of a function.") - (license license:llgpl)))) - -(define-public cl-type-i - (sbcl-package->cl-source-package sbcl-type-i)) - -(define-public sbcl-optima - (let ((commit "373b245b928c1a5cce91a6cb5bfe5dd77eb36195") - (revision "1")) - (package - (name "sbcl-optima") - (build-system asdf-build-system/sbcl) - (version (git-version "1.0" revision commit)) - (home-page "https://github.com/m2ym/optima") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "1yw4ymq7ms89342kkvb3aqxgv0w38m9kd8ikdqxxzyybnkjhndal")))) - (inputs - `(("alexandria" ,sbcl-alexandria) - ("closer-mop" ,sbcl-closer-mop))) - (native-inputs - `(("eos" ,sbcl-eos))) - (arguments - ;; XXX: Circular dependencies: tests depend on optima.ppcre which depends on optima. - `(#:tests? #f - #:test-asd-file "optima.test.asd")) - (synopsis "Optimized pattern matching library for Common Lisp") - (description "Optima is a fast pattern matching library which uses -optimizing techniques widely used in the functional programming world.") - (license license:expat)))) - -(define-public cl-optima - (sbcl-package->cl-source-package sbcl-optima)) - -(define-public sbcl-fare-quasiquote - (package - (name "sbcl-fare-quasiquote") - (build-system asdf-build-system/sbcl) - (version "20171130") - (home-page "http://common-lisp.net/project/fare-quasiquote") - (source - (origin - (method url-fetch) - (uri (string-append "http://beta.quicklisp.org/archive/fare-quasiquote/" - (date->string (string->date version "~Y~m~d") "~Y-~m-~d") - "/fare-quasiquote-" - version - "-git.tgz")) - (sha256 - (base32 - "00brmh7ndsi0c97nibi8cy10j3l4gmkyrfrr5jr5lzkfb7ngyfqa")))) - (inputs - `(("fare-utils" ,sbcl-fare-utils))) - (arguments - ;; XXX: Circular dependencies: Tests depend on subsystems, which depend on the main systems. - `(#:tests? #f - #:phases - (modify-phases %standard-phases - ;; XXX: Require 1.0.0 version of fare-utils, and we package some - ;; commits after 1.0.0.5, but ASDF fails to read the - ;; "-REVISION-COMMIT" part generated by Guix. - (add-after 'unpack 'patch-requirement - (lambda _ - (substitute* "fare-quasiquote.asd" - (("\\(:version \"fare-utils\" \"1.0.0\"\\)") "\"fare-utils\""))))))) - (synopsis "Pattern-matching friendly implementation of quasiquote for Common Lisp") - (description "The main purpose of this n+2nd reimplementation of -quasiquote is enable matching of quasiquoted patterns, using Optima or -Trivia.") - (license license:expat))) - -(define-public cl-fare-quasiquote - (sbcl-package->cl-source-package sbcl-fare-quasiquote)) - -(define-public sbcl-fare-quasiquote-optima - (package - (inherit sbcl-fare-quasiquote) - (name "sbcl-fare-quasiquote-optima") - (inputs - `(("optima" ,sbcl-optima) - ("fare-quasiquote" ,sbcl-fare-quasiquote))) - (arguments - '(#:phases - (modify-phases %standard-phases - (add-after 'unpack 'patch-requirement - (lambda _ - (substitute* "fare-quasiquote-optima.asd" - (("\\(:version \"optima\" \"1\\.0\"\\)") - "\"optima\"")) - #t))))))) - -(define-public cl-fare-quasiquote-optima - (sbcl-package->cl-source-package sbcl-fare-quasiquote-optima)) - -(define-public sbcl-fare-quasiquote-readtable - (package - (inherit sbcl-fare-quasiquote) - (name "sbcl-fare-quasiquote-readtable") - (inputs - `(("fare-quasiquote" ,sbcl-fare-quasiquote) - ("named-readtables" ,sbcl-named-readtables))) - (description "The main purpose of this n+2nd reimplementation of -quasiquote is enable matching of quasiquoted patterns, using Optima or -Trivia. - -This package uses fare-quasiquote with named-readtable."))) - -(define-public cl-fare-quasiquote-readtable - (sbcl-package->cl-source-package sbcl-fare-quasiquote-readtable)) - -;; TODO: Add support for component-less system in asdf-build-system/sbcl. -(define-public cl-fare-quasiquote-extras - (package - (inherit cl-fare-quasiquote) - (name "cl-fare-quasiquote-extras") - (build-system asdf-build-system/source) - (propagated-inputs - `(("fare-quasiquote" ,cl-fare-quasiquote) - ("fare-quasiquote-optima" ,cl-fare-quasiquote-optima) - ("fare-quasiquote-readtable" ,cl-fare-quasiquote-readtable))) - (description "This library combines @code{fare-quasiquote-readtable} and -@code{fare-quasiquote-optima}."))) - -(define-public sbcl-trivia.level0 - (let ((commit "902e0c65602bbfe96ae82e679330b3771ddc7603") - (revision "1")) - (package - (name "sbcl-trivia.level0") - (build-system asdf-build-system/sbcl) - (version (git-version "0.0.0" revision commit)) - (home-page "https://github.com/guicho271828/trivia") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "11qbab30qqnfy9mx3x9fvgcw1jbvh1qn2cqv3p8xdn2m8981jvhr")))) - (inputs - `(("alexandria" ,sbcl-alexandria))) - (synopsis "Pattern matching in Common Lisp") - (description "Trivia is a pattern matching compiler that is compatible -with Optima, another pattern matching library for Common Lisp. It is meant to -be faster and more extensible than Optima.") - (license license:llgpl)))) - -(define-public sbcl-trivia.level1 - (package - (inherit sbcl-trivia.level0) - (name "sbcl-trivia.level1") - (inputs - `(("trivia.level0" ,sbcl-trivia.level0))) - (description "Trivia is a pattern matching compiler that is compatible -with Optima, another pattern matching library for Common Lisp. It is meant to -be faster and more extensible than Optima. - -This system contains the core patterns of Trivia."))) - -(define-public sbcl-trivia.level2 - (package - (inherit sbcl-trivia.level0) - (name "sbcl-trivia.level2") - (inputs - `(("trivia.level1" ,sbcl-trivia.level1) - ("lisp-namespace" ,sbcl-lisp-namespace) - ("trivial-cltl2" ,sbcl-trivial-cltl2) - ("closer-mop" ,sbcl-closer-mop))) - (description "Trivia is a pattern matching compiler that is compatible -with Optima, another pattern matching library for Common Lisp. It is meant to -be faster and more extensible than Optima. - -This system contains a non-optimized pattern matcher compatible with Optima, -with extensible optimizer interface."))) - -(define-public sbcl-trivia.trivial - (package - (inherit sbcl-trivia.level0) - (name "sbcl-trivia.trivial") - (inputs - `(("trivia.level2" ,sbcl-trivia.level2))) - (arguments - `(#:phases - (modify-phases %standard-phases - (replace 'create-asd-file - (lambda* (#:key outputs inputs #:allow-other-keys) - (let* ((out (assoc-ref outputs "out")) - (lib (string-append out "/lib/" (%lisp-type))) - (level2 (assoc-ref inputs "trivia.level2"))) - (mkdir-p lib) - (install-file "trivia.trivial.asd" lib) - ;; XXX: This .asd does not have any component and the build - ;; system fails to work in this case. We should update the - ;; build system to handle component-less .asd. - ;; TODO: How do we append to file in Guile? It seems that - ;; (open-file ... "a") gets a "Permission denied". - (substitute* (string-append lib "/trivia.trivial.asd") - (("\"\\)") - (string-append "\") - -(progn (asdf/source-registry:ensure-source-registry) - (setf (gethash - \"trivia.level2\" - asdf/source-registry:*source-registry*) - #p\"" - level2 - "/share/common-lisp/sbcl-bundle-systems/trivia.level2.asd\"))"))))))))) - (description "Trivia is a pattern matching compiler that is compatible -with Optima, another pattern matching library for Common Lisp. It is meant to -be faster and more extensible than Optima. - -This system contains the base level system of Trivia with a trivial optimizer."))) - -(define-public sbcl-trivia.balland2006 - (package - (inherit sbcl-trivia.level0) - (name "sbcl-trivia.balland2006") - (inputs - `(("trivia.trivial" ,sbcl-trivia.trivial) - ("iterate" ,sbcl-iterate) - ("type-i" ,sbcl-type-i) - ("alexandria" ,sbcl-alexandria))) - (arguments - ;; Tests are done in trivia itself. - `(#:tests? #f)) - (description "Trivia is a pattern matching compiler that is compatible -with Optima, another pattern matching library for Common Lisp. It is meant to -be faster and more extensible than Optima. - -This system contains the base level system of Trivia with a trivial optimizer."))) - -(define-public sbcl-trivia.ppcre - (package - (inherit sbcl-trivia.level0) - (name "sbcl-trivia.ppcre") - (inputs - `(("trivia.trivial" ,sbcl-trivia.trivial) - ("cl-ppcre" ,sbcl-cl-ppcre))) - (description "Trivia is a pattern matching compiler that is compatible -with Optima, another pattern matching library for Common Lisp. It is meant to -be faster and more extensible than Optima. - -This system contains the PPCRE extension."))) - -(define-public sbcl-trivia.quasiquote - (package - (inherit sbcl-trivia.level0) - (name "sbcl-trivia.quasiquote") - (inputs - `(("trivia.trivial" ,sbcl-trivia.trivial) - ("fare-quasiquote" ,sbcl-fare-quasiquote) - ("fare-quasiquote-readtable" ,sbcl-fare-quasiquote-readtable))) - (description "Trivia is a pattern matching compiler that is compatible -with Optima, another pattern matching library for Common Lisp. It is meant to -be faster and more extensible than Optima. - -This system contains the fare-quasiquote extension."))) - -(define-public sbcl-trivia.cffi - (package - (inherit sbcl-trivia.level0) - (name "sbcl-trivia.cffi") - (inputs - `(("cffi" ,sbcl-cffi) - ("trivia.trivial" ,sbcl-trivia.trivial))) - (description "Trivia is a pattern matching compiler that is compatible -with Optima, another pattern matching library for Common Lisp. It is meant to -be faster and more extensible than Optima. - -This system contains the CFFI foreign slot access extension."))) - -(define-public sbcl-trivia - (package - (inherit sbcl-trivia.level0) - (name "sbcl-trivia") - (inputs - `(("trivia.balland2006" ,sbcl-trivia.balland2006))) - (native-inputs - `(("fiveam" ,sbcl-fiveam) - ("trivia.ppcre" ,sbcl-trivia.ppcre) - ("trivia.quasiquote" ,sbcl-trivia.quasiquote) - ("trivia.cffi" ,sbcl-trivia.cffi) - ("optima" ,sbcl-optima))) - (arguments - `(#:test-asd-file "trivia.test.asd" - #:phases - (modify-phases %standard-phases - (add-after 'create-asd 'remove-component - ;; XXX: The original .asd has no components, but our build system - ;; creates an entry nonetheless. We need to remove it for the - ;; generated .asd to load properly. See trivia.trivial for a - ;; similar problem. - (lambda* (#:key outputs #:allow-other-keys) - (let* ((out (assoc-ref outputs "out")) - (asd (string-append out "/lib/" (%lisp-type) "/trivia.asd"))) - (substitute* asd - ((" :components -") - "")) - (substitute* asd - ((" *\\(\\(:compiled-file \"trivia--system\"\\)\\)") - "")))))))) - (description "Trivia is a pattern matching compiler that is compatible -with Optima, another pattern matching library for Common Lisp. It is meant to -be faster and more extensible than Optima."))) - -(define-public cl-trivia - (sbcl-package->cl-source-package sbcl-trivia)) - -(define-public sbcl-mk-string-metrics - (package - (name "sbcl-mk-string-metrics") - (version "0.1.2") - (home-page "https://github.com/cbaggers/mk-string-metrics/") - (source (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit version))) - (sha256 - (base32 "0bg0bv2mfd4k0g3x72x563hvmrx18xavaffr6xk5rh4if5j7kcf6")) - (file-name (git-file-name name version)))) - (build-system asdf-build-system/sbcl) - (synopsis "Calculate various string metrics efficiently in Common Lisp") - (description "This library implements efficient algorithms that calculate -various string metrics in Common Lisp: - -@itemize -@item Damerau-Levenshtein distance -@item Hamming distance -@item Jaccard similarity coefficient -@item Jaro distance -@item Jaro-Winkler distance -@item Levenshtein distance -@item Normalized Damerau-Levenshtein distance -@item Normalized Levenshtein distance -@item Overlap coefficient -@end itemize\n") - (license license:x11))) - -(define-public cl-mk-string-metrics - (sbcl-package->cl-source-package sbcl-mk-string-metrics)) - -(define-public sbcl-cl-str - (let ((commit "3d5ec86e3a0199e5973aacde951086dfd754b5e5")) - (package - (name "sbcl-cl-str") - (version (git-version "0.8" "1" commit)) - (home-page "https://github.com/vindarel/cl-str") - (source (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (sha256 - (base32 "0szzzbygw9h985yxz909vvqrp69pmpcpahn7hn350lnyjislk9ga")) - (file-name (git-file-name name version)))) - (build-system asdf-build-system/sbcl) - (inputs - `(("cl-ppcre" ,sbcl-cl-ppcre) - ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode))) - (native-inputs - `(("prove" ,sbcl-prove) - ("prove-asdf" ,sbcl-prove-asdf))) - (arguments - `(#:asd-file "str.asd" - #:asd-system-name "str" - #:test-asd-file "str.test.asd")) - (synopsis "Modern, consistent and terse Common Lisp string manipulation library") - (description "A modern and consistent Common Lisp string manipulation -library that focuses on modernity, simplicity and discoverability: -@code{(str:trim s)} instead of @code{(string-trim '(#\\Space ...) s)}), or -@code{str:concat strings} instead of an unusual format construct; one -discoverable library instead of many; consistency and composability, where -@code{s} is always the last argument, which makes it easier to feed pipes and -arrows.") - (license license:expat)))) - -(define-public cl-str - (sbcl-package->cl-source-package sbcl-cl-str)) - -(define-public sbcl-cl-xmlspam - (let ((commit "ea06abcca2a73a9779bcfb09081e56665f94e22a")) - (package - (name "sbcl-cl-xmlspam") - (build-system asdf-build-system/sbcl) - (version (git-version "0.0.0" "1" commit)) - (home-page "https://github.com/rogpeppe/cl-xmlspam") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (file-name (string-append name "-" version)) - (sha256 - (base32 - "0w4rqvrgdgk3fwfq3kx4r7wwdr2bv3b6n3bdqwsiriw9psqzpz2s")))) - (inputs - `(("cxml" ,sbcl-cxml) - ("cl-ppcre" ,sbcl-cl-ppcre))) - (synopsis "Concise, regexp-like pattern matching on streaming XML for Common Lisp") - (description "CXML does an excellent job at parsing XML elements, but what -do you do when you have a XML file that's larger than you want to fit in -memory, and you want to extract some information from it? Writing code to deal -with SAX events, or even using Klacks, quickly becomes tedious. -@code{cl-xmlspam} (for XML Stream PAttern Matcher) is designed to make it easy -to write code that mirrors the structure of the XML that it's parsing. It -also makes it easy to shift paradigms when necessary - the usual Lisp control -constructs can be used interchangeably with pattern matching, and the full -power of CXML is available when necessary.") - (license license:bsd-3)))) - -;; TODO: dbus uses ASDF's package-inferred-system which is not supported by -;; asdf-build-system/sbcl as of 2019-08-02. We should fix -;; asdf-build-system/sbcl. -(define-public cl-dbus - (let ((commit "24b452df3a45ca5dc95015500f34baad175c981a") - (revision "1")) - (package - (name "cl-dbus") - (build-system asdf-build-system/source) - (version (git-version "20190408" revision commit)) - (home-page "https://github.com/death/dbus") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "0fw2q866yddbf23nk9pxphm9gsasx35vjyss82xzvndnjmzlqfl5")))) - ;; Inputs must be propagated or else packages depending on this won't have the necessary packages. - (propagated-inputs - `(("alexandria" ,sbcl-alexandria) - ("trivial-garbage" ,sbcl-trivial-garbage) - ("babel" ,sbcl-babel) - ("iolib" ,sbcl-iolib) - ("iolib+multiplex" ,(@@ (gnu packages lisp) sbcl-iolib+multiplex)) - ("iolib+syscalls" ,(@@ (gnu packages lisp) sbcl-iolib+syscalls)) - ("iolib+streams" ,(@@ (gnu packages lisp) sbcl-iolib+streams)) - ("iolib+sockets" ,(@@ (gnu packages lisp) sbcl-iolib+sockets)) - ("ieee-floats" ,sbcl-ieee-floats) - ("flexi-streams" ,sbcl-flexi-streams) - ("cl-xmlspam" ,sbcl-cl-xmlspam) - ("ironclad" ,sbcl-ironclad))) - (synopsis "D-Bus client library for Common Lisp") - (description "This is a Common Lisp library that allows to publish D-Bus -objects as well as send and notify other objects connected to a bus.") - (license license:bsd-2)))) - -(define-public sbcl-cl-hooks - (let ((commit "5b638083f3b4f1221a52631d9c8a0a265565cac7") - (revision "1")) - (package - (name "sbcl-cl-hooks") - (build-system asdf-build-system/sbcl) - (version (git-version "0.2.1" revision commit)) - (home-page "https://github.com/scymtym/architecture.hooks") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "0bg3l0a28lw5gqqjp6p6b5nhwqk46sgkb7184w5qbfngw1hk8x9y")))) - (inputs - `(("alexandria" ,sbcl-alexandria) - ("let-plus" ,sbcl-let-plus) - ("trivial-garbage" ,sbcl-trivial-garbage) - ("closer-mop" ,sbcl-closer-mop))) - (native-inputs - `(("fiveam" ,sbcl-fiveam))) - (synopsis "Hooks extension point mechanism (as in Emacs) for Common Lisp") - (description "A hook, in the present context, is a certain kind of -extension point in a program that allows interleaving the execution of -arbitrary code with the execution of a the program without introducing any -coupling between the two. Hooks are used extensively in the extensible editor -Emacs. - -In the Common LISP Object System (CLOS), a similar kind of extensibility is -possible using the flexible multi-method dispatch mechanism. It may even seem -that the concept of hooks does not provide any benefits over the possibilities -of CLOS. However, there are some differences: - -@itemize - -@item There can be only one method for each combination of specializers and -qualifiers. As a result this kind of extension point cannot be used by -multiple extensions independently. -@item Removing code previously attached via a @code{:before}, @code{:after} or -@code{:around} method can be cumbersome. -@item There could be other or even multiple extension points besides @code{:before} -and @code{:after} in a single method. -@item Attaching codes to individual objects using eql specializers can be -cumbersome. -@item Introspection of code attached a particular extension point is -cumbersome since this requires enumerating and inspecting the methods of a -generic function. -@end itemize - -This library tries to complement some of these weaknesses of method-based -extension-points via the concept of hooks.") - (license license:llgpl)))) - -(define-public cl-hooks - (sbcl-package->cl-source-package sbcl-cl-hooks)) - -(define-public ecl-cl-hooks - (sbcl-package->ecl-package sbcl-cl-hooks)) - -(define-public sbcl-s-sysdeps - (let ((commit "d28246b5dffef9e73a0e0e6cfbc4e878006fe34d") - (revision "1")) - (package - (name "sbcl-s-sysdeps") - (build-system asdf-build-system/sbcl) - (version (git-version "1" revision commit)) - (home-page "https://github.com/svenvc/s-sysdeps") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "14b69b81yrxmjlvmm3lfxk04x5v7hqz4fql121334wh72czznfh9")))) - (synopsis "Common Lisp abstraction layer over platform dependent functionality") - (description "@code{s-sysdeps} is an abstraction layer over platform -dependent functionality. This simple package is used as a building block in a -number of other open source projects. - -@code{s-sysdeps} abstracts: - -@itemize -@item managing processes, -@item implementing a standard TCP/IP server, -@item opening a client TCP/IP socket stream, -@item working with process locks. -@end itemize\n") - (license license:llgpl)))) - -(define-public cl-s-sysdeps - (sbcl-package->cl-source-package sbcl-s-sysdeps)) - -(define-public ecl-s-sysdeps - (sbcl-package->ecl-package sbcl-s-sysdeps)) - -(define-public sbcl-cl-prevalence - (let ((commit "c163c227ed85d430b82cb1e3502f72d4f88e3cfa") - (revision "1")) - (package - (name "sbcl-cl-prevalence") - (build-system asdf-build-system/sbcl) - (version (git-version "5" revision commit)) - (home-page "https://github.com/40ants/cl-prevalence") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "1i9zj1q2ahgwch56an21yzbgkynz0kab9fyxkq9mg8p3xrv38jjn")))) - (inputs - `(("s-sysdeps" ,sbcl-s-sysdeps) - ("s-xml" ,sbcl-s-xml))) - (synopsis "Implementation of object prevalence for Common Lisp") - (description "This Common Lisp library implements object prevalence (see -@url{https://en.wikipedia.org/wiki/System_prevalence}). It allows -for (de)serializing to and from s-exps as well as XML. Serialization of arbitrary -classes and cyclic data structures are supported.") - (license license:llgpl)))) - -(define-public cl-prevalence - (sbcl-package->cl-source-package sbcl-cl-prevalence)) - -(define-public ecl-cl-prevalence - (sbcl-package->ecl-package sbcl-cl-prevalence)) - -(define-public sbcl-series - (let ((commit "da9061b336119d1e5214aff9117171d494d5a58a") - (revision "1")) - (package - (name "sbcl-series") - (version (git-version "2.2.11" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "git://git.code.sf.net/p/series/series") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "07hk2lhfx42zk018pxqvn4gs77vd4n4g8m4xxbqaxgca76mifwfw")))) - (build-system asdf-build-system/sbcl) - (arguments - ;; Disable the tests, they are apparently buggy and I didn't find - ;; a simple way to make them run and pass. - '(#:tests? #f)) - (synopsis "Series data structure for Common Lisp") - (description - "This Common Lisp library provides a series data structure much like -a sequence, with similar kinds of operations. The difference is that in many -situations, operations on series may be composed functionally and yet execute -iteratively, without the need to construct intermediate series values -explicitly. In this manner, series provide both the clarity of a functional -programming style and the efficiency of an iterative programming style.") - (home-page "http://series.sourceforge.net/") - (license license:expat)))) - -(define-public cl-series - (sbcl-package->cl-source-package sbcl-series)) - -(define-public ecl-series - (sbcl-package->ecl-package sbcl-series)) - -(define-public sbcl-periods - (let ((commit "983d4a57325db3c8def942f163133cec5391ec28") - (revision "1")) - (package - (name "sbcl-periods") - (version (git-version "0.0.2" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/jwiegley/periods.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "0z30jr3lxz3cmi019fsl4lgcgwf0yqpn95v9zkkkwgymdrkd4lga")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("local-time" ,sbcl-local-time))) - (synopsis "Common Lisp library for manipulating date/time objects") - (description - "Periods is a Common Lisp library providing a set of utilities for -manipulating times, distances between times, and both contiguous and -discontiguous ranges of time.") - (home-page "https://github.com/jwiegley/periods") - (license license:bsd-3)))) - -(define-public cl-periods - (sbcl-package->cl-source-package sbcl-periods)) - -(define-public ecl-periods - (sbcl-package->ecl-package sbcl-periods)) - -(define-public sbcl-periods-series - (package - (inherit sbcl-periods) - (name "sbcl-periods-series") - (inputs - `(("periods" ,sbcl-periods) - ("series" ,sbcl-series))) - (arguments - '(#:asd-file "periods-series.asd" - #:asd-system-name "periods-series")) - (description - "Periods-series is an extension of the periods Common Lisp library -providing functions compatible with the series Common Lisp library."))) - -(define-public cl-periods-series - (sbcl-package->cl-source-package sbcl-periods-series)) - -(define-public ecl-periods-series - (sbcl-package->ecl-package sbcl-periods-series)) - -(define-public sbcl-metatilities-base - (let ((commit "6eaa9e3ff0939a93a92109dd0fcd218de85417d5") - (revision "1")) - (package - (name "sbcl-metatilities-base") - (version (git-version "0.6.6" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/gwkkwg/metatilities-base.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "0xpa86pdzlnf4v5g64j3ifaplx71sx2ha8b7vvakswi652679ma0")))) - (build-system asdf-build-system/sbcl) - (native-inputs - `(("lift" ,sbcl-lift))) - (synopsis "Core of the metatilities Common Lisp library") - (description - "Metatilities-base is the core of the metatilities Common Lisp library -which implements a set of utilities.") - (home-page "https://common-lisp.net/project/metatilities-base/") - (license license:expat)))) - -(define-public cl-metatilities-base - (sbcl-package->cl-source-package sbcl-metatilities-base)) - -(define-public ecl-metatilities-base - (sbcl-package->ecl-package sbcl-metatilities-base)) - -(define-public sbcl-cl-containers - (let ((commit "810927e19d933bcf38ffeb7a23ce521efc432d45") - (revision "1")) - (package - (name "sbcl-cl-containers") - (version (git-version "0.12.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/gwkkwg/cl-containers.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "1s9faxw7svhbjpkhfrz2qxgjm3cvyjb8wpyb4m8dx4i5g7vvprkv")))) - (build-system asdf-build-system/sbcl) - (native-inputs - `(("lift" ,sbcl-lift))) - (inputs - `(("metatilities-base" ,sbcl-metatilities-base))) - (arguments - '(#:phases - (modify-phases %standard-phases - (add-after 'unpack 'relax-version-checks - (lambda _ - (substitute* "cl-containers.asd" - (("\\(:version \"metatilities-base\" \"0\\.6\\.6\"\\)") - "\"metatilities-base\"")) - (substitute* "cl-containers-test.asd" - (("\\(:version \"lift\" \"1\\.7\\.0\"\\)") - "\"lift\"")) - #t))))) - (synopsis "Container library for Common Lisp") - (description - "Common Lisp ships with a set of powerful built in data structures -including the venerable list, full featured arrays, and hash-tables. -CL-containers enhances and builds on these structures by adding containers -that are not available in native Lisp (for example: binary search trees, -red-black trees, sparse arrays and so on), and by providing a standard -interface so that they are simpler to use and so that changing design -decisions becomes significantly easier.") - (home-page "https://common-lisp.net/project/cl-containers/") - (license license:expat)))) - -(define-public cl-containers - (sbcl-package->cl-source-package sbcl-cl-containers)) - -(define-public ecl-cl-containers - (sbcl-package->ecl-package sbcl-cl-containers)) - -(define-public sbcl-xlunit - (let ((commit "3805d34b1d8dc77f7e0ee527a2490194292dd0fc") - (revision "1")) - (package - (name "sbcl-xlunit") - (version (git-version "0.6.3" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "http://git.kpe.io/xlunit.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "0argfmp9nghs4sihyj3f8ch9qfib2b7ll07v5m9ziajgzsfl5xw3")))) - (build-system asdf-build-system/sbcl) - (arguments - '(#:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-tests - (lambda _ - (substitute* "xlunit.asd" - ((" :force t") "")) - #t))))) - (synopsis "Unit testing package for Common Lisp") - (description - "The XLUnit package is a toolkit for building test suites. It is based -on the XPTest package by Craig Brozensky and the JUnit package by Kent Beck.") - (home-page "http://quickdocs.org/xlunit/") - (license license:bsd-3)))) - -(define-public cl-xlunit - (sbcl-package->cl-source-package sbcl-xlunit)) - -(define-public ecl-xlunit - (sbcl-package->ecl-package sbcl-xlunit)) - -(define-public sbcl-fprog - (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636") - (revision "1")) - (package - (name "sbcl-fprog") - (version (git-version "1.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/jwiegley/cambl.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "103mry04j2k9vznsxm7wcvccgxkil92cdrv52miwcmxl8daa4jiz")))) - (build-system asdf-build-system/sbcl) - (synopsis "Functional programming utilities for Common Lisp") - (description - "@code{fprog} is a Common Lisp library allowing iteration over -immutable lists sharing identical sublists.") - (home-page "https://github.com/jwiegley/cambl") - (license license:bsd-3)))) - -(define-public cl-fprog - (sbcl-package->cl-source-package sbcl-fprog)) - -(define-public ecl-fprog - (sbcl-package->ecl-package sbcl-fprog)) - -(define-public sbcl-cambl - (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636") - (revision "1")) - (package - (inherit sbcl-fprog) - (name "sbcl-cambl") - (version (git-version "4.0.0" revision commit)) - (native-inputs - `(("xlunit" ,sbcl-xlunit))) - (inputs - `(("alexandria" ,sbcl-alexandria) - ("cl-containers" ,sbcl-cl-containers) - ("local-time" ,sbcl-local-time) - ("periods" ,sbcl-periods) - ("fprog" ,sbcl-fprog))) - (synopsis "Commoditized amounts and balances for Common Lisp") - (description - "CAMBL is a Common Lisp library providing a convenient facility for -working with commoditized values. It does not allow compound units (and so is -not suited for scientific operations) but does work rather nicely for the -purpose of financial calculations.")))) - -(define-public cl-cambl - (sbcl-package->cl-source-package sbcl-cambl)) - -(define-public ecl-cambl - (sbcl-package->ecl-package sbcl-cambl)) - -(define-public sbcl-cl-ledger - (let ((commit "08e0be41795e804cd36142e51756ad0b1caa377b") - (revision "1")) - (package - (name "sbcl-cl-ledger") - (version (git-version "4.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/ledger/cl-ledger.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "1via0qf6wjcyxnfbmfxjvms0ik9j8rqbifgpmnhrzvkhrq9pv8h1")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("cambl" ,sbcl-cambl) - ("cl-ppcre" ,sbcl-cl-ppcre) - ("local-time" ,sbcl-local-time) - ("periods-series" ,sbcl-periods-series))) - (arguments - '(#:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-system-definition - (lambda _ - (substitute* "cl-ledger.asd" - ((" :build-operation program-op") "") - ((" :build-pathname \"cl-ledger\"") "") - ((" :entry-point \"ledger::main\"") "")) - #t))))) - (synopsis "Common Lisp port of the Ledger accounting system") - (description - "CL-Ledger is a Common Lisp port of the Ledger double-entry accounting -system.") - (home-page "https://github.com/ledger/cl-ledger") - (license license:bsd-3)))) - -(define-public cl-ledger - (sbcl-package->cl-source-package sbcl-cl-ledger)) - -(define-public ecl-cl-ledger - (sbcl-package->ecl-package sbcl-cl-ledger)) - -(define-public sbcl-bst - (let ((commit "34f9c7e8e0a9f2c952fe310ab36cb630d5d9c15a") - (revision "1")) - (package - (name "sbcl-bst") - (version (git-version "1.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/glv2/bst.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "1amxns7hvvh4arwbh8ciwfzplg127vh37dnbamv1m1kmmnmihfc8")))) - (build-system asdf-build-system/sbcl) - (native-inputs - `(("alexandria" ,sbcl-alexandria) - ("fiveam" ,sbcl-fiveam))) - (synopsis "Binary search tree for Common Lisp") - (description - "BST is a Common Lisp library for working with binary search trees that -can contain any kind of values.") - (home-page "https://github.com/glv2/bst") - (license license:gpl3)))) - -(define-public cl-bst - (sbcl-package->cl-source-package sbcl-bst)) - -(define-public ecl-bst - (sbcl-package->ecl-package sbcl-bst)) - -(define-public sbcl-cl-octet-streams - (package - (name "sbcl-cl-octet-streams") - (version "1.0") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/glv2/cl-octet-streams.git") - (commit (string-append "v" version)))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "1d7mn6ydv0j2x4r7clpc9ijjwrnfpxmvhifv8n5j7jh7s744sf8d")))) - (build-system asdf-build-system/sbcl) - (native-inputs - `(("fiveam" ,sbcl-fiveam))) - (inputs - `(("trivial-gray-streams" ,sbcl-trivial-gray-streams))) - (synopsis "In-memory octet streams for Common Lisp") - (description - "CL-octet-streams is a library implementing in-memory octet -streams for Common Lisp. It was inspired by the trivial-octet-streams and -cl-plumbing libraries.") - (home-page "https://github.com/glv2/cl-octet-streams") - (license license:gpl3+))) - -(define-public cl-octet-streams - (sbcl-package->cl-source-package sbcl-cl-octet-streams)) - -(define-public ecl-cl-octet-streams - (sbcl-package->ecl-package sbcl-cl-octet-streams)) - -(define-public sbcl-lzlib - (let ((commit "0de1db7129fef9a58a059d35a2fa2ecfc5b47b47") - (revision "1")) - (package - (name "sbcl-lzlib") - (version (git-version "1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/glv2/cl-lzlib.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "12ny7vj52fgnd8hb8fc8mry92vq4c1x72x2350191m4476j95clz")))) - (build-system asdf-build-system/sbcl) - (native-inputs - `(("fiveam" ,sbcl-fiveam))) - (inputs - `(("cffi" ,sbcl-cffi) - ("cl-octet-streams" ,sbcl-cl-octet-streams) - ("lzlib" ,lzlib))) - (arguments - '(#:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "src/lzlib.lisp" - (("liblz\\.so") - (string-append (assoc-ref inputs "lzlib") "/lib/liblz.so"))) - #t))))) - (synopsis "Common Lisp library for lzip (de)compression") - (description - "This Common Lisp library provides functions for lzip (LZMA) -compression/decompression using bindings to the lzlib C library.") - (home-page "https://github.com/glv2/cl-lzlib") - (license license:gpl3+)))) - -(define-public cl-lzlib - (sbcl-package->cl-source-package sbcl-lzlib)) - -(define-public ecl-lzlib - (sbcl-package->ecl-package sbcl-lzlib)) - -(define-public sbcl-chanl - (let ((commit "2362b57550c2c9238cc882d03553aaa1040b7340") - (revision "0")) - (package - (name "sbcl-chanl") - (version (git-version "0.4.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/zkat/chanl.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "0ag3wz7yrqwp0s5069wwda98z3rrqd25spg8sa8rdqghj084w28w")))) - (build-system asdf-build-system/sbcl) - (native-inputs - `(("fiveam" ,sbcl-fiveam))) - (inputs - `(("bordeaux-threads" ,sbcl-bordeaux-threads))) - (synopsis "Portable channel-based concurrency for Common Lisp") - (description "Common Lisp library for channel-based concurrency. In -a nutshell, you create various threads sequentially executing tasks you need -done, and use channel objects to communicate and synchronize the state of these -threads.") - (home-page "https://github.com/zkat/chanl") - (license (list license:expat license:bsd-3))))) - -(define-public cl-chanl - (sbcl-package->cl-source-package sbcl-chanl)) - -(define-public ecl-chanl - (let ((base (sbcl-package->ecl-package sbcl-chanl))) - (package - (inherit base) - (arguments - (substitute-keyword-arguments (package-arguments base) - ;; The CHANL.ACTORS package uses the :ARGUMENTS option of - ;; DEFINE-METHOD-COMBINATION, which is not implemented in ECL yet - ;; (see https://gitlab.com/embeddable-common-lisp/ecl/issues/305). - ;; So let's disable it for now, as it allows compiling the library - ;; and using the rest of it. - ((#:phases phases '%standard-phases) - `(modify-phases ,phases - (add-after 'unpack 'disable-chanl-actors - (lambda _ - (substitute* "chanl.asd" - (("\\(:file \"actors\"\\)") "")) - #t)))) - ;; Disable the tests for now, as the SEND-SEQUENCE test seems to - ;; never end. - ((#:tests? _ #f) #f)))))) - -(define-public sbcl-cl-store - (let ((commit "cd01f2610d3360dc01ab972bd9317407aaea7745") - (revision "0")) - (package - (name "sbcl-cl-store") - (version (git-version "0.8.11" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/skypher/cl-store.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "05b7kh5af2ax7vlmphpac4vbqr84j5ivppj96qzb64fxpjpqglm4")))) - (build-system asdf-build-system/sbcl) - (native-inputs - `(("rt" ,sbcl-rt))) - (synopsis "Common Lisp library to serialize data") - (description - "CL-STORE is a portable serialization package which should give you the -ability to store all Common Lisp data types into streams.") - (home-page "http://www.common-lisp.net/project/cl-store/") - (license license:expat)))) - -(define-public cl-store - (sbcl-package->cl-source-package sbcl-cl-store)) - -(define-public ecl-cl-store - (sbcl-package->ecl-package sbcl-cl-store)) - -(define-public sbcl-cl-gobject-introspection - (let ((commit "7b703e2384945ea0ac39d9b766de434a08d81560") - (revision "0")) - (package - (name "sbcl-cl-gobject-introspection") - (version (git-version "0.3" revision commit)) - (home-page "https://github.com/andy128k/cl-gobject-introspection") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "1zcqd2qj14f6b38vys8gr89s6cijsp9r8j43xa8lynilwva7bwyh")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("alexandria" ,sbcl-alexandria) - ("cffi" ,sbcl-cffi) - ("iterate" ,sbcl-iterate) - ("trivial-garbage" ,sbcl-trivial-garbage) - ("glib" ,glib) - ("gobject-introspection" ,gobject-introspection))) - (native-inputs - `(("fiveam" ,sbcl-fiveam))) - (arguments - ;; TODO: Tests fail, see - ;; https://github.com/andy128k/cl-gobject-introspection/issues/70. - '(#:tests? #f - #:phases - (modify-phases %standard-phases - (add-after (quote unpack) (quote fix-paths) - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "src/init.lisp" - (("libgobject-2\\.0\\.so") - (string-append (assoc-ref inputs "glib") "/lib/libgobject-2.0.so")) - (("libgirepository-1\\.0\\.so") - (string-append (assoc-ref inputs "gobject-introspection") - "/lib/libgirepository-1.0.so"))) - #t))))) - (synopsis "Common Lisp bindings to GObject Introspection") - (description - "This library is a bridge between Common Lisp and GObject -Introspection, which enables Common Lisp programs to access the full interface -of C+GObject libraries without the need of writing dedicated bindings.") - (license (list license:bsd-3 - ;; Tests are under a different license. - license:llgpl))))) - -(define-public cl-gobject-introspection - (sbcl-package->cl-source-package sbcl-cl-gobject-introspection)) - -(define-public sbcl-string-case - (let ((commit "718c761e33749e297cd2809c7ba3ade1985c49f7") - (revision "0")) - (package - (name "sbcl-string-case") - (version (git-version "0.0.2" revision commit)) - (home-page "https://github.com/pkhuong/string-case") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "1n5i3yh0h5s636rcnwn7jwqy3rjflikra04lymimhpcshhjsk0md")))) - (build-system asdf-build-system/sbcl) - (synopsis "Efficient string= case in Common Lisp") - (description - "@code{string-case} is a Common Lisp macro that generates specialised decision -trees to dispatch on string equality.") - (license license:bsd-3)))) - -(define-public cl-string-case - (sbcl-package->cl-source-package sbcl-string-case)) - -(define-public ecl-string-case - (sbcl-package->ecl-package sbcl-string-case)) - -(define-public sbcl-global-vars - (let ((commit "c749f32c9b606a1457daa47d59630708ac0c266e") - (revision "0")) - (package - (name "sbcl-global-vars") - (version (git-version "1.0.0" revision commit)) - (home-page "https://github.com/lmj/global-vars") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "06m3xc8l3pgsapl8fvsi9wf6y46zs75cp9zn7zh6dc65v4s5wz3d")))) - (build-system asdf-build-system/sbcl) - (synopsis "Efficient global variables in Common Lisp") - (description - "In Common Lisp, a special variable that is never dynamically bound -typically serves as a stand-in for a global variable. The @code{global-vars} -library provides true global variables that are implemented by some compilers. -An attempt to rebind a global variable properly results in a compiler error. -That is, a global variable cannot be dynamically bound. - -Global variables therefore allow us to communicate an intended usage that -differs from special variables. Global variables are also more efficient than -special variables, especially in the presence of threads.") - (license license:expat)))) - -(define-public cl-global-vars - (sbcl-package->cl-source-package sbcl-global-vars)) - -(define-public ecl-global-vars - (sbcl-package->ecl-package sbcl-global-vars)) - -(define-public sbcl-trivial-file-size - (let ((commit "1c1d672a01a446ba0391dbb4ffc40be3b0476f23") - (revision "0")) - (package - (name "sbcl-trivial-file-size") - (version (git-version "0.0.0" revision commit)) - (home-page "https://github.com/ruricolist/trivial-file-size") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "17pp86c9zs4y7i1sh7q9gbfw9iqv6655k7fz8qbj9ly1ypgxp4qs")))) - (build-system asdf-build-system/sbcl) - (native-inputs - `(("fiveam" ,sbcl-fiveam))) - (synopsis "Size of a file in bytes in Common Lisp") - (description - "The canonical way to determine the size of a file in bytes, using Common Lisp, -is to open the file with an element type of (unsigned-byte 8) and then -calculate the length of the stream. This is less than ideal. In most cases -it is better to get the size of the file from its metadata, using a system -call. - -This library exports a single function, file-size-in-octets. It returns the -size of a file in bytes, using system calls when possible.") - (license license:expat)))) - -(define-public cl-trivial-file-size - (sbcl-package->cl-source-package sbcl-trivial-file-size)) - -(define-public ecl-trivial-file-size - (sbcl-package->ecl-package sbcl-trivial-file-size)) - -(define-public sbcl-trivial-macroexpand-all - (let ((commit "933270ac7107477de1bc92c1fd641fe646a7a8a9") - (revision "0")) - (package - (name "sbcl-trivial-macroexpand-all") - (version (git-version "0.0.0" revision commit)) - (home-page "https://github.com/cbaggers/trivial-macroexpand-all") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "191hnn4b5j4i3crydmlzbm231kj0h7l8zj6mzj69r1npbzkas4bd")))) - (build-system asdf-build-system/sbcl) - (native-inputs - `(("fiveam" ,sbcl-fiveam))) - (synopsis "Portable macroexpand-all for Common Lisp") - (description - "This library provides a macroexpand-all function that calls the -implementation specific equivalent.") - (license license:unlicense)))) - -(define-public cl-trivial-macroexpand-all - (sbcl-package->cl-source-package sbcl-trivial-macroexpand-all)) - -(define-public ecl-trivial-macroexpand-all - (sbcl-package->ecl-package sbcl-trivial-macroexpand-all)) - -(define-public sbcl-serapeum - (let ((commit "65837f8a0d65b36369ec8d000fff5c29a395b5fe") - (revision "0")) - (package - (name "sbcl-serapeum") - (version (git-version "0.0.0" revision commit)) - (home-page "https://github.com/ruricolist/serapeum") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "0clwf81r2lvk1rbfvk91s9zmbkas9imf57ilqclw12mxaxlfsnbw")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("alexandria" ,sbcl-alexandria) - ("trivia" ,sbcl-trivia) - ("trivia.quasiquote" ,sbcl-trivia.quasiquote) - ("split-sequence" ,sbcl-split-sequence) - ("string-case" ,sbcl-string-case) - ("parse-number" ,sbcl-parse-number) - ("trivial-garbage" ,sbcl-trivial-garbage) - ("bordeaux-threads" ,sbcl-bordeaux-threads) - ("named-readtables" ,sbcl-named-readtables) - ("fare-quasiquote-extras" ,cl-fare-quasiquote-extras) - ("parse-declarations-1.0" ,sbcl-parse-declarations) - ("global-vars" ,sbcl-global-vars) - ("trivial-file-size" ,sbcl-trivial-file-size) - ("trivial-macroexpand-all" ,sbcl-trivial-macroexpand-all))) - (native-inputs - `(("fiveam" ,sbcl-fiveam) - ("local-time" ,sbcl-local-time))) - (arguments - '(#:phases - (modify-phases %standard-phases - (add-after 'unpack 'disable-failing-tests - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "serapeum.asd" - ;; Guix does not have Quicklisp, and probably never will. - (("\\(:file \"quicklisp\"\\)") "")) - #t))))) - (synopsis "Common Lisp utility library beyond Alexandria") - (description - "Serapeum is a conservative library of Common Lisp utilities. It is a -supplement, not a competitor, to Alexandria.") - (license license:expat)))) - -(define-public cl-serapeum - (sbcl-package->cl-source-package sbcl-serapeum)) - -(define-public sbcl-arrows - (let ((commit "df7cf0067e0132d9697ac8b1a4f1b9c88d4f5382") - (revision "0")) - (package - (name "sbcl-arrows") - (version (git-version "0.2.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://gitlab.com/Harleqin/arrows.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "042k9vkssrqx9nhp14wdzm942zgdxvp35mba0p2syz98i75im2yy")))) - (build-system asdf-build-system/sbcl) - (native-inputs - `(("hu.dwim.stefil" ,sbcl-hu.dwim.stefil))) - (synopsis "Clojure-like arrow macros for Common Lisp") - (description - "This library implements the @code{->} and @code{->>} macros from -Clojure, as well as several expansions on the idea.") - (home-page "https://gitlab.com/Harleqin/arrows") - (license license:public-domain)))) - -(define-public cl-arrows - (sbcl-package->cl-source-package sbcl-arrows)) - -(define-public ecl-arrows - (sbcl-package->ecl-package sbcl-arrows)) - -(define-public sbcl-simple-parallel-tasks - (let ((commit "db460f7a3f7bbfe2d3a2223ed21e162068d04dda") - (revision "0")) - (package - (name "sbcl-simple-parallel-tasks") - (version (git-version "1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/glv2/simple-parallel-tasks.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "0amw3qk23wnlyrsgzszs6rs7y4zvxv8dr03rnqhc60mnm8ds4dd5")))) - (build-system asdf-build-system/sbcl) - (native-inputs - `(("fiveam" ,sbcl-fiveam))) - (inputs - `(("chanl" ,sbcl-chanl))) - (synopsis "Common Lisp library to evaluate some forms in parallel") - (description "This is a simple Common Lisp library to evaluate some -forms in parallel.") - (home-page "https://github.com/glv2/simple-parallel-tasks") - (license license:gpl3)))) - -(define-public cl-simple-parallel-tasks - (sbcl-package->cl-source-package sbcl-simple-parallel-tasks)) - -(define-public ecl-simple-parallel-tasks - (sbcl-package->ecl-package sbcl-simple-parallel-tasks)) - -(define-public sbcl-cl-heap - (package - (name "sbcl-cl-heap") - (version "0.1.6") - (source - (origin - (method url-fetch) - (uri (string-append "https://common-lisp.net/project/cl-heap/releases/" - "cl-heap_" version ".tar.gz")) - (sha256 - (base32 - "163hb07p2nxz126rpq3cj5dyala24n0by5i5786n2qcr1w0bak4i")))) - (build-system asdf-build-system/sbcl) - (native-inputs - `(("xlunit" ,sbcl-xlunit))) - (arguments - `(#:test-asd-file "cl-heap-tests.asd")) - (synopsis "Heap and priority queue data structures for Common Lisp") - (description - "CL-HEAP provides various implementations of heap data structures (a -binary heap and a Fibonacci heap) as well as an efficient priority queue.") - (home-page "https://common-lisp.net/project/cl-heap/") - (license license:gpl3+))) - -(define-public cl-heap - (sbcl-package->cl-source-package sbcl-cl-heap)) - -(define-public ecl-cl-heap - (sbcl-package->ecl-package sbcl-cl-heap)) - -(define-public sbcl-curry-compose-reader-macros - (let ((commit "beaa92dedf392726c042184bfd6149fa8d9e6ac2") - (revision "0")) - (package - (name "sbcl-curry-compose-reader-macros") - (version (git-version "1.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri - (git-reference - (url "https://github.com/eschulte/curry-compose-reader-macros.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "0rv9bl8xrad5wfcg5zs1dazvnpmvqz6297lbn8bywsrcfnlf7h98")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("alexandria" ,sbcl-alexandria) - ("named-readtables" ,sbcl-named-readtables))) - (synopsis "Reader macros for partial application and composition") - (description - "This Common Lisp library provides reader macros for concise expression -of function partial application and composition.") - (home-page "https://eschulte.github.io/curry-compose-reader-macros/") - (license license:public-domain)))) - -(define-public cl-curry-compose-reader-macros - (sbcl-package->cl-source-package sbcl-curry-compose-reader-macros)) - -(define-public ecl-curry-compose-reader-macros - (sbcl-package->ecl-package sbcl-curry-compose-reader-macros)) - -(define-public sbcl-yason - (package - (name "sbcl-yason") - (version "0.7.7") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/phmarek/yason.git") - (commit (string-append "v" version)))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "0479rbjgbj80jpk5bby18inlv1kfp771a82rlcq5psrz65qqa9bj")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("alexandria" ,sbcl-alexandria) - ("trivial-gray-streams" ,sbcl-trivial-gray-streams))) - (synopsis "Common Lisp JSON parser/encoder") - (description - "YASON is a Common Lisp library for encoding and decoding data in the -JSON interchange format.") - (home-page "https://github.com/phmarek/yason") - (license license:bsd-3))) - -(define-public cl-yason - (sbcl-package->cl-source-package sbcl-yason)) - -(define-public ecl-yason - (sbcl-package->ecl-package sbcl-yason)) - -(define-public sbcl-stefil - (let ((commit "0398548ec95dceb50fc2c2c03e5fb0ce49b86c7a") - (revision "0")) - (package - (name "sbcl-stefil") - (version (git-version "0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://gitlab.common-lisp.net/stefil/stefil.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "0bqz64q2szzhf91zyqyssmvrz7da6442rs01808pf3wrdq28bclh")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("alexandria" ,sbcl-alexandria) - ("iterate" ,sbcl-iterate) - ("metabang-bind" ,sbcl-metabang-bind))) - (propagated-inputs - ;; Swank doesn't have a pre-compiled package, therefore we must - ;; propagate its sources. - `(("swank" ,cl-slime-swank))) - (arguments - '(#:phases - (modify-phases %standard-phases - (add-after 'unpack 'drop-unnecessary-dependency - (lambda _ - (substitute* "package.lisp" - ((":stefil-system") "")) - #t))))) - (home-page "https://common-lisp.net/project/stefil/index-old.shtml") - (synopsis "Simple test framework") - (description - "Stefil is a simple test framework for Common Lisp, with a focus on -interactive development.") - (license license:public-domain)))) - -(define-public cl-stefil - (sbcl-package->cl-source-package sbcl-stefil)) - -(define-public sbcl-graph - (let ((commit "78bf9ec930d8eae4f0861b5be76765fb1e45e24f") - (revision "0")) - (package - (name "sbcl-graph") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri - (git-reference - (url "https://github.com/eschulte/graph.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "1qpij4xh8bqwc2myahpilcbh916v7vg0acz2fij14d3y0jm02h0g")) - (patches (search-patches "sbcl-graph-asdf-definitions.patch")))) - (build-system asdf-build-system/sbcl) - (native-inputs - `(("stefil" ,sbcl-stefil))) - (inputs - `(("alexandria" ,sbcl-alexandria) - ("cl-heap" ,sbcl-cl-heap) - ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros) - ("metabang-bind" ,sbcl-metabang-bind) - ("named-readtables" ,sbcl-named-readtables))) - (arguments - '(#:test-asd-file "graph.test.asd")) - (synopsis "Graph data structure and algorithms for Common Lisp") - (description - "The GRAPH Common Lisp library provides a data structures to represent -graphs, as well as some graph manipulation and analysis algorithms (shortest -path, maximum flow, minimum spanning tree, etc.).") - (home-page "https://eschulte.github.io/graph/") - (license license:gpl3+)))) - -(define-public cl-graph - (sbcl-package->cl-source-package sbcl-graph)) - -(define-public sbcl-graph-dot - (package - (inherit sbcl-graph) - (name "sbcl-graph-dot") - (inputs - `(("alexandria" ,sbcl-alexandria) - ("cl-ppcre" ,sbcl-cl-ppcre) - ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros) - ("graph" ,sbcl-graph) - ("metabang-bind" ,sbcl-metabang-bind) - ("named-readtables" ,sbcl-named-readtables))) - (arguments - (substitute-keyword-arguments (package-arguments sbcl-graph) - ((#:asd-file _ "") "graph.dot.asd") - ((#:asd-system-name _ #f) "graph-dot"))) - (synopsis "Serialize graphs to and from DOT format"))) - -(define-public sbcl-graph-json - (package - (inherit sbcl-graph) - (name "sbcl-graph-json") - (inputs - `(("alexandria" ,sbcl-alexandria) - ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros) - ("graph" ,sbcl-graph) - ("metabang-bind" ,sbcl-metabang-bind) - ("named-readtables" ,sbcl-named-readtables) - ("yason" ,sbcl-yason))) - (arguments - (substitute-keyword-arguments (package-arguments sbcl-graph) - ((#:asd-file _ "") "graph.json.asd") - ((#:asd-system-name _ #f) "graph-json"))) - (synopsis "Serialize graphs to and from JSON format"))) |