--- Begin Message ---
|
Subject: |
[PATCH] Add Multiple Common Lisp Packages |
|
Date: |
Sat, 23 Mar 2019 15:14:26 -0500 |
|
User-agent: |
Gnus/5.13 (Gnus v5.13) Emacs/26.1 (gnu/linux) |
I packaged most of these in one day in a mad rush to try and get Clack
packaged. After verifying the packages built, I went back after the fact
and decorated all the packages with their metadata.
Because I rushed through some of this, I'm sure I've made a mistake
somewhere and I would greatly appreciate more eyes on these packages. If
we want to take the stance that something is better than nothing, and
that we can clean up any mistakes later, that's fine too.
>From c4b9394599c7cf9f6069fb3e8c3466858155e1c8 Mon Sep 17 00:00:00 2001
From: Katherine Cox-Buday <address@hidden>
Date: Sat, 23 Mar 2019 15:01:11 -0500
Subject: [PATCH] Add Multiple Common Lisp Packages
---
gnu/packages/lisp.scm | 1210 ++++++++++++++++++++++++++++++++++++++++-
guix/licenses.scm | 7 +-
2 files changed, 1214 insertions(+), 3 deletions(-)
diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm
index 3d43b7c509..837839c0f7 100644
--- a/gnu/packages/lisp.scm
+++ b/gnu/packages/lisp.scm
@@ -12,6 +12,7 @@
;;; Copyright © 2018 Alex Vong <address@hidden>
;;; Copyright © 2018 Pierre Neidhardt <address@hidden>
;;; Copyright © 2018 Pierre Langlois <address@hidden>
+;;; Copyright © 2019 Katherine Cox-Buday <address@hidden>
;;;
;;; This file is part of GNU Guix.
;;;
@@ -65,6 +66,7 @@
#:use-module (gnu packages sqlite)
#:use-module (gnu packages tex)
#:use-module (gnu packages texinfo)
+ #:use-module (gnu packages tls)
#:use-module (gnu packages version-control)
#:use-module (gnu packages xorg)
#:use-module (gnu packages databases)
@@ -2554,8 +2556,7 @@ 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";)
- ;; REVIEW: The actual license is LLGPL. Should we add it to Guix?
- (license license:lgpl3+))))
+ (license license:llgpl))))
(define-public cl-ansi-text
(sbcl-package->cl-source-package sbcl-cl-ansi-text))
@@ -3840,3 +3841,1208 @@ client and server.")
(define-public ecl-trivial-clipboard
(sbcl-package->ecl-package sbcl-trivial-clipboard))
+
+(define-public sbcl-trivial-backtrace
+ (let ((commit-hash "ca81c011b86424a381a7563cea3b924f24e6fbeb"))
+ (package
+ (name "sbcl-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.
trivial-backtrace is a simple solution to generating a backtrace portably.")
+ (home-page "https://common-lisp.net/project/trivial-backtrace/";)
+ (license license:bsd-style)
+ (version (string-append "0.0.0-" (string-take commit-hash 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/gwkkwg/trivial-backtrace.git";)
+ (commit commit-hash)))
+ (sha256 (base32
"10p41p43skj6cimdg8skjy7372s8v2xpkg8djjy0l8rm45i654k1"))))
+ (inputs
+ `(("sbcl-lift" ,sbcl-lift)))
+ (build-system asdf-build-system/sbcl))))
+
+(define-public cl-trivial-backtrace
+ (sbcl-package->cl-source-package sbcl-trivial-backtrace))
+
+(define-public sbcl-rfc2388
+ (let ((commit-hash "591bcf7e77f2c222c43953a80f8c297751dc0c4e"))
+ (package
+ (name "sbcl-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\".")
+ (home-page "https://github.com/jdz/rfc2388/";)
+ (license license:bsd-2)
+ (version (string-append "0.0.0-" (string-take commit-hash 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/jdz/rfc2388.git";)
+ (commit commit-hash)))
+ (sha256 (base32
"0phh5n3clhl9ji8jaxrajidn22d3f0aq87mlbfkkxlnx2pnw694k"))))
+ (build-system asdf-build-system/sbcl))))
+
+(define-public cl-rfc2388
+ (sbcl-package->cl-source-package sbcl-rfc2388))
+
+(define-public sbcl-md5
+ (let ((version "2.0.4"))
+ (package
+ (name "sbcl-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.")
+ (home-page "https://github.com/pmai/md5";)
+ (license license:public-domain)
+ (version version)
+ (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))))
+
+(define-public cl-md5
+ (sbcl-package->cl-source-package sbcl-md5))
+
+(define-public sbcl-cl+ssl
+ (let ((commit-hash "b81c1135cf5700e870ce2573d5035d249e491788"))
+ (package
+ (name "sbcl-cl+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.")
+ (home-page "http://common-lisp.net/project/cl-plus-ssl/";)
+ (license license:expat)
+ (version (string-append "0.0.0-" (string-take commit-hash 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/cl-plus-ssl/cl-plus-ssl.git";)
+ (commit commit-hash)))
+ (sha256 (base32
"1845i1pafmqb6cdlr53yaqy67kjrhkvbx6c37ca15cw70vhdr3z9"))))
+ (inputs
+ `(("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)))
+ (propagated-inputs `(("openssl" ,openssl)))
+ (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)))))))))))
+
+(define-public cl-cl+ssl
+ (sbcl-package->cl-source-package sbcl-cl+ssl))
+
+(define-public sbcl-kmrcl
+ (let ((version "1.109.0")
+ (commit-hash "5260068b2eb735af6796740c2db4955afac21636"))
+ (package
+ (name "sbcl-kmrcl")
+ (synopsis "KMRCL is a collection of utilities used by a number of Kevin
Rosenberg's CL packages.")
+ (description "KMRCL is a collection of utilities used by a number of
Kevin Rosenberg's CL packages.")
+ (home-page "http://files.kpe.io/kmrcl/";)
+ (license license:llgpl)
+ (version (string-append version "-" (string-take commit-hash 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "http://git.kpe.io/kmrcl.git/";)
+ (commit commit-hash)))
+ (sha256 (base32
"1va7xjgzfv674bpsli674i7zj3f7wg5kxic41kz18r6hh4n52dfv"))))
+ (inputs
+ `(("sbcl-rt" ,sbcl-rt)))
+ (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)))))
+
+(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")
+ (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.")
+ (home-page "http://files.kpe.io/cl-base64/";)
+ (license license:bsd-3)
+ (version version)
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "http://git.kpe.io/cl-base64.git";)
+ (commit (string-append "v" version))))
+ (sha256 (base32
"1dw6j7n6gsd2qa0p0rbsjxj00acxx3i9ca1qkgl0liy8lpnwkypl"))))
+ (inputs
+ `(("sbcl-ptester" ,sbcl-ptester)
+ ("sbcl-kmrcl" ,sbcl-kmrcl)))
+ (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)))))
+
+(define-public cl-cl-base64
+ (sbcl-package->cl-source-package sbcl-cl-base64))
+
+(define-public sbcl-chunga
+ (let ((version "1.1.7"))
+ (package
+ (name "sbcl-chunga")
+ (synopsis "Portable chunked streams for Common Lisp")
+ (description "Chunga implements streams capable of chunked encoding on
demand as defined in RFC 2616.")
+ (home-page "https://edicl.github.io/chunga/";)
+ (license license:bsd-2)
+ (version version)
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://github.com/edicl/chunga/archive/v";
version ".tar.gz"))
+ (sha256 (base32
"0ra17kyc9l7qbaw003ly111r1cbn4zixbfq1ydr9cxw10v30q1n7"))))
+ (inputs
+ `(("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)))
+ (build-system asdf-build-system/sbcl))))
+
+(define-public cl-chunga
+ (sbcl-package->cl-source-package sbcl-chunga))
+
+(define-public sbcl-cl-who
+ (let ((version "1.1.4")
+ (commit-hash "2c08caa4bafba720409af9171feeba3f32e86d32"))
+ (package
+ (name "sbcl-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.")
+ (home-page "https://edicl.github.io/cl-who/";)
+ (license license:bsd-2)
+ (version (string-append version (string-take commit-hash 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/edicl/cl-who.git";)
+ (commit commit-hash)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0yjb6sr3yazm288m318kqvj9xk8rm9n1lpimgf65ymqv0i5agxsb"))))
+ (native-inputs
+ `(("sbcl-flexi-streams" ,sbcl-flexi-streams)))
+ (build-system asdf-build-system/sbcl))))
+
+(define-public cl-cl-who
+ (sbcl-package->cl-source-package sbcl-cl-who))
+
+(define-public sbcl-chipz
+ (let ((version "0.8")
+ (commit-hash "75dfbc660a5a28161c57f115adf74c8a926bfc4d"))
+ (package
+ (name "sbcl-chipz")
+ (synopsis "A 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.")
+ (home-page "http://method-combination.net/lisp/chipz/";)
+ (license license:expat) ; The author describes it as "MIT-like"
+ (version (string-append version (string-take commit-hash 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/froydnj/chipz.git";)
+ (commit commit-hash)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0plx4rs39zbs4gjk77h4a2q11zpy75fh9v8hnxrvsf8fnakajhwg"))))
+ (native-inputs
+ `(("sbcl-flexi-streams" ,sbcl-flexi-streams)))
+ (build-system asdf-build-system/sbcl))))
+
+(define-public cl-chipz
+ (sbcl-package->cl-source-package sbcl-chipz))
+
+(define-public sbcl-drakma
+ (let ((version "2.0.4")
+ (commit-hash "7647c0ae842ff2058624e53979c7f297760c97a7"))
+ (package
+ (name "sbcl-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.")
+ (home-page "https://edicl.github.io/drakma/";)
+ (license license:bsd-2)
+ (version (string-append version (string-take commit-hash 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/edicl/drakma.git";)
+ (commit commit-hash)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1c4i9wakhj5pxfyyykxshdmv3180sbkrx6fcyynikmc0jd0rh84r"))))
+ (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)))
+ (build-system asdf-build-system/sbcl))))
+
+(define-public cl-drakma
+ (sbcl-package->cl-source-package sbcl-drakma))
+
+(define-public sbcl-hunchentoot
+ (let ((version "1.2.38"))
+ (package
+ (name "sbcl-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.")
+ (home-page "https://edicl.github.io/hunchentoot/";)
+ (license license:bsd-2)
+ (version version)
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://github.com/edicl/hunchentoot/archive/v";
version ".tar.gz"))
+ (sha256 (base32
"17z8rpd6b5w93jwrdwfwxjha617xnjqw8aq1hw2z76zp1fn8yrmh"))))
+ (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)))
+ (native-inputs
+ `(("sbcl-cl-who" ,sbcl-cl-who)
+ ("sbcl-drakma" ,sbcl-drakma)))
+ (build-system asdf-build-system/sbcl))))
+
+(define-public cl-hunchentoot
+ (sbcl-package->cl-source-package sbcl-hunchentoot))
+
+(define-public sbcl-trivial-types
+ (package
+ (name "sbcl-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.")
+ (home-page "https://github.com/m2ym/trivial-types";)
+ (license license:llgpl)
+ (version "0.0.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/m2ym/trivial-types.git";)
+ (commit "ee869f2b7504d8aa9a74403641a5b42b16f47d88")))
+ (sha256 (base32 "1s4cp9bdlbn8447q7w7f1wkgwrbvfzp20mgs307l5pxvdslin341"))))
+ (build-system asdf-build-system/sbcl)))
+
+(define-public cl-trivial-types
+ (sbcl-package->cl-source-package sbcl-trivial-types))
+
+(define-public sbcl-cl-syntax
+ (package
+ (name "sbcl-cl-syntax")
+ (synopsis "Reader Syntax Coventions for Common Lisp and SLIME")
+ (description "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp
and SLIME.")
+ (home-page "https://github.com/m2ym/cl-syntax";)
+ (license license:llgpl)
+ (version "0.0.3")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/m2ym/cl-syntax.git";)
+ (commit "03f0c329bbd55b8622c37161e6278366525e2ccc")))
+ (sha256 (base32 "17ran8xp77asagl31xv8w819wafh6whwfc9p6dgx22ca537gyl4y"))))
+ (inputs `(("sbcl-trivial-types" ,sbcl-trivial-types)
+ ("sbcl-named-readtables" ,sbcl-named-readtables)))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-file "cl-syntax.asd"
+ #:asd-system-name "cl-syntax"))))
+
+(define-public cl-cl-syntax
+ (sbcl-package->cl-source-package sbcl-cl-syntax))
+
+(define-public sbcl-cl-annot
+ (let ((commit-hash "c99e69c15d935eabc671b483349a406e0da9518d"))
+ (package
+ (name "sbcl-cl-annot")
+ (synopsis "Python-like Annotation Syntax for Common Lisp.")
+ (description "cl-annot is an general annotation library for Common Lisp.")
+ (home-page "https://github.com/m2ym/cl-annot";)
+ (license license:llgpl)
+ (version (string-append "0.0.0-" (string-take commit-hash 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/m2ym/cl-annot.git";)
+ (commit commit-hash)))
+ (sha256 (base32
"1wq1gs9jjd5m6iwrv06c2d7i5dvqsfjcljgbspfbc93cg5xahk4n"))))
+ (inputs
+ `(("sbcl-alexandria" ,sbcl-alexandria)))
+ (build-system asdf-build-system/sbcl))))
+
+(define-public cl-cl-annot
+ (sbcl-package->cl-source-package sbcl-cl-annot))
+
+(define-public sbcl-cl-syntax-annot
+ (package
+ (name "sbcl-cl-syntax-annot")
+ (synopsis "Reader Syntax Coventions for Common Lisp and SLIME")
+ (description "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp
and SLIME.")
+ (home-page "https://github.com/m2ym/cl-syntax";)
+ (license license:llgpl)
+ (version "0.0.3")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/m2ym/cl-syntax.git";)
+ (commit "03f0c329bbd55b8622c37161e6278366525e2ccc")))
+ (sha256 (base32 "17ran8xp77asagl31xv8w819wafh6whwfc9p6dgx22ca537gyl4y"))))
+ (inputs `(("sbcl-cl-syntax" ,sbcl-cl-syntax)
+ ("sbcl-cl-annot" ,sbcl-cl-annot)))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-file "cl-syntax-annot.asd"
+ #:asd-system-name "cl-syntax-annot"))))
+
+(define-public cl-cl-syntax-annot
+ (sbcl-package->cl-source-package sbcl-cl-syntax-annot))
+
+(define-public sbcl-myway
+ (let ((commit-hash "286230082a11f879c18b93f17ca571c5f676bfb7"))
+ (package
+ (name "sbcl-myway")
+ (synopsis "Sinatra-compatible URL routing library for Common Lisp")
+ (description "My Way is a Sinatra-compatible URL routing library.")
+ (home-page "https://github.com/fukamachi/myway";)
+ (license license:llgpl)
+ (version (string-append "0.1.0-" (string-take commit-hash 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/myway.git";)
+ (commit commit-hash)))
+ (sha256 (base32
"0briia9bk3lbr0frnx39d1qg6i38dm4j6z9w3yga3d40k6df4a90"))))
+ (inputs
+ `(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
+ ("sbcl-quri" ,sbcl-quri)
+ ("sbcl-map-set" ,sbcl-map-set)))
+ (native-inputs
+ `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+ ("sbcl-prove" ,sbcl-prove)))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; Tests fail with: Component MYWAY-ASD::MYWAY-TEST not found,
+ ;; required by #<SYSTEM "myway">. Why?
+ '(#:tests? #f)))))
+
+(define-public cl-myway
+ (sbcl-package->cl-source-package sbcl-myway))
+
+(define-public sbcl-cl-utilities
+ (let ((commit-hash "dce2d2f6387091ea90357a130fa6d13a6776884b"))
+ (package
+ (name "sbcl-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.")
+ (home-page "http://common-lisp.net/project/cl-utilities";)
+ (license license:public-domain)
+ (version (string-append "0.0.0-" (string-take commit-hash 7)))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
"https://gitlab.common-lisp.net/cl-utilities/cl-utilities/-/archive/dce2d2f6387091ea90357a130fa6d13a6776884b/cl-utilities-";
commit-hash ".tar.gz"))
+ (sha256 (base32
"1r46v730yf96nk2vb24qmagv9x96xvd08abqwhf02ghgydv1a7z2"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#: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)"))))))))))
+
+(define-public cl-cl-utilities
+ (sbcl-package->cl-source-package sbcl-cl-utilities))
+
+(define-public sbcl-map-set
+ (let ((commit-hash "7b4b545b68b8"))
+ (package
+ (name "sbcl-map-set")
+ (synopsis "Implementation of a set-like data structure with constant time
addition, removal, and random selection.")
+ (description "Implementation of a set-like data structure with constant
time addition, removal, and random selection.")
+ (home-page "https://bitbucket.org/tarballs_are_good/map-set";)
+ (license license:bsd-3)
+ (version (string-append "0.0.0-" (string-take commit-hash 7)))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
"https://bitbucket.org/tarballs_are_good/map-set/get/"; commit-hash ".tar.gz"))
+ (sha256 (base32
"1sx5j5qdsy5fklspfammwb16kjrhkggdavm922a9q86jm5l0b239"))))
+ (build-system asdf-build-system/sbcl))))
+
+(define-public cl-map-set
+ (sbcl-package->cl-source-package sbcl-map-set))
+
+(define-public sbcl-quri
+ (let ((commit-hash "76b75103f21ead092c9f715512fa82441ef61185"))
+ (package
+ (name "sbcl-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.")
+ (home-page "https://github.com/fukamachi/quri";)
+ (license license:bsd-3)
+ (version (string-append "0.1.0-" (string-take commit-hash 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/quri.git";)
+ (commit commit-hash)))
+ (sha256 (base32
"1ccbxsgzdibmzq33mmbmmz9vwl6l03xh6nbpsh1hkdvdcl7q0a60"))))
+ (inputs `(("sbcl-babel" ,sbcl-babel)
+ ("sbcl-split-sequence" ,sbcl-split-sequence)
+ ("sbcl-cl-utilities" ,sbcl-cl-utilities)
+ ("sbcl-alexandria" ,sbcl-alexandria)))
+ (native-inputs `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+ ("sbcl-prove" ,sbcl-prove)))
+ (arguments
+ ;; Tests fail with: Component QURI-ASD::QURI-TEST not found,
+ ;; required by #<SYSTEM "quri">. Why?
+ '(#:tests? #f))
+ (build-system asdf-build-system/sbcl))))
+
+(define-public cl-quri
+ (sbcl-package->cl-source-package sbcl-quri))
+
+(define-public sbcl-smart-buffer
+ (let ((commit-hash "09b9a9a0b3abaa37abe9a730f5aac2643dca4e62"))
+ (package
+ (name "sbcl-smart-buffer")
+ (synopsis "Smart octets buffer.")
+ (description "Smart-buffer provides an output buffer which changes the
destination depending on content size.")
+ (home-page "https://github.com/fukamachi/smart-buffer";)
+ (license license:bsd-3)
+ (version (string-append "0.0.1-" (string-take commit-hash 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/smart-buffer";)
+ (commit commit-hash)))
+ (sha256 (base32
"0qz1zzxx0wm5ff7gpgsq550a59p0qj594zfmm2rglj97dahj54l7"))))
+ (inputs `(;; ("sbcl-alexandria" ,sbcl-alexandria)
+ ;; ("sbcl-proc-parse" ,sbcl-proc-parse)
+ ("sbcl-xsubseq" ,sbcl-xsubseq)
+ ("sbcl-flexi-streams" ,sbcl-flexi-streams)))
+ (native-inputs
+ `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+ ("sbcl-prove" ,sbcl-prove)))
+ (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)))))
+
+(define-public cl-smart-buffer
+ (sbcl-package->cl-source-package sbcl-smart-buffer))
+
+(define-public sbcl-xsubseq
+ (let ((commit-hash "5ce430b3da5cda3a73b9cf5cee4df2843034422b"))
+ (package
+ (name "sbcl-xsubseq")
+ (synopsis "Efficient way to use \"subseq\"s in Common Lisp")
+ (description "XSubseq provides functions to be able to handle \"subseq\"s
more effieiently.")
+ (home-page "https://github.com/fukamachi/xsubseq";)
+ (license license:bsd-2)
+ (version (string-append "0.0.1-" (string-take commit-hash 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/xsubseq";)
+ (commit commit-hash)))
+ (sha256 (base32
"1xz79q0p2mclf3sqjiwf6izdpb6xrsr350bv4mlmdlm6rg5r99px"))))
+ (native-inputs
+ `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+ ("sbcl-prove" ,sbcl-prove)))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; Tests fail with: Component XSUBSEQ-ASD::XSUBSEQ-TEST not found,
+ ;; required by #<SYSTEM "xsubseq">. Why?
+ `(#:tests? #f)))))
+
+(define-public cl-xsubseq
+ (sbcl-package->cl-source-package sbcl-xsubseq))
+
+(define-public sbcl-fast-http
+ (let ((commit-hash "f9e7597191bae380503e20724fd493a24d024935"))
+ (package
+ (name "sbcl-fast-http")
+ (synopsis "A fast HTTP request/response parser for Common Lisp.")
+ (description "This is a fast HTTP request/response protocol parser for
Common Lisp.")
+ (home-page "https://github.com/fukamachi/fast-http";)
+ (license license:expat) ; Author specified the MIT license
+ (version (string-append "0.2.0-" (string-take commit-hash 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/fast-http";)
+ (commit commit-hash)))
+ (sha256 (base32
"0qdmwv2zm0sizxdb8nnclgwl0nfjcbjaimbakavikijw7lr9b4jp"))))
+ (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)))
+ (native-inputs
+ `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+ ("sbcl-prove" ,sbcl-prove)))
+ (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)))))
+
+(define-public cl-fast-http
+ (sbcl-package->cl-source-package sbcl-fast-http))
+
+(define-public sbcl-static-vectors
+ (let ((commit-hash "0681eac1f49370cde03e64b077251e8abf47d702"))
+ (package
+ (name "sbcl-static-vectors")
+ (synopsis "Allocate SIMPLE-ARRAYs in static memory")
+ (description "Allocate SIMPLE-ARRAYs in static memory")
+ (home-page "http://common-lisp.net/projects/iolib/";)
+ (license license:expat) ; Author specified an MIT license
+ (version (string-append "1.8.3-" (string-take commit-hash 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sionescu/static-vectors.git";)
+ (commit commit-hash)))
+ (sha256 (base32
"138nlsq14hv8785ycjm6jw3i6ablhq8vcwys7q09y80arcgrg6r3"))))
+ (inputs
+ `(("sbcl-cffi-grovel" ,sbcl-cffi-grovel)
+ ("sbcl-cffi" ,sbcl-cffi)))
+ (native-inputs
+ `(("sbcl-fiveam" ,sbcl-fiveam)))
+ (build-system asdf-build-system/sbcl))))
+
+(define-public cl-static-vectors
+ (sbcl-package->cl-source-package sbcl-static-vectors))
+
+(define-public sbcl-marshal
+ (let ((commit-hash "eff1b15f2b0af2f26f71ad6a4dd5c4beab9299ec"))
+ (package
+ (name "sbcl-marshal")
+ (synopsis "Simple and fast serialization of all kinds of Common Lisp data
structures.")
+ (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.")
+ (home-page "https://github.com/wlbr/cl-marshal";)
+ (license license:expat) ; Author specified an MIT license
+ (version (string-append "1.3.0-" (string-take commit-hash 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/wlbr/cl-marshal.git";)
+ (commit commit-hash)))
+ (sha256 (base32
"08qs6fhk38xpkkjkpcj92mxx0lgy4ygrbbzrmnivdx281syr0gwh"))))
+ (build-system asdf-build-system/sbcl))))
+
+(define-public cl-marshal
+ (sbcl-package->cl-source-package sbcl-marshal))
+
+(define-public sbcl-checkl
+ (let ((commit-hash "80328800d047fef9b6e32dfe6bdc98396aee3cc9"))
+ (package
+ (name "sbcl-checkl")
+ (synopsis "Why write programs in Common Lisp but tests like Java? Meet
CheckL!")
+ (description "TODO")
+ (home-page "")
+ ;; 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)
+ (version (string-append "0.0.0-" (string-take commit-hash 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/rpav/CheckL.git";)
+ (commit commit-hash)))
+ (sha256 (base32
"0bpisihx1gay44xmyr1dmhlwh00j0zzi04rp9fy35i95l2r4xdlx"))))
+ (inputs
+ `(("sbcl-marshal" ,sbcl-marshal)))
+ (native-inputs
+ `(("sbcl-fiveam" ,sbcl-fiveam)))
+ (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)))))
+
+(define-public cl-checkl
+ (sbcl-package->cl-source-package sbcl-checkl))
+
+(define-public sbcl-fast-io
+ (let ((commit-hash "dc3a71db7e9b756a88781ae9c342fe9d4bbab51c"))
+ (package
+ (name "sbcl-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).")
+ (home-page "https://github.com/rpav/fast-io";)
+ (license license:bsd-3) ; Author specifies this as NewBSD which is an
alias
+ (version (string-append "1.0.0-" (string-take commit-hash 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/rpav/fast-io.git";)
+ (commit commit-hash)))
+ (sha256 (base32
"1jsp6xvi26ln6fdy5j5zi05xvan8jsqdhisv552dy6xg6ws8i1yq"))))
+ (inputs
+ `(("sbcl-alexandria" ,sbcl-alexandria)
+ ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)
+ ("sbcl-static-vectors" ,sbcl-static-vectors)))
+ (native-inputs
+ `(("sbcl-fiveam" ,sbcl-fiveam)
+ ("sbcl-checkl" ,sbcl-checkl)))
+ (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)))))
+
+(define-public cl-fast-io
+ (sbcl-package->cl-source-package sbcl-fast-io))
+
+(define-public sbcl-jonathan
+ (let ((commit-hash "1f448b4f7ac8265e56e1c02b32ce383e65316300"))
+ (package
+ (name "sbcl-jonathan")
+ (synopsis "JSON encoder and decoder.")
+ (description "It's faster than jsown - high performance Common Lisp json
parser.")
+ (home-page "http://rudolph-miller.github.io/jonathan/overview.html";)
+ (license license:expat) ; Author specifies the MIT license
+ (version (string-append "0.1.0-" (string-take commit-hash 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Rudolph-Miller/jonathan.git";)
+ (commit commit-hash)))
+ (sha256 (base32
"14x4iwz3mbag5jzzzr4sb6ai0m9r4q4kyypbq32jmsk2dx1hi807"))))
+ (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)))
+ (native-inputs
+ `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+ ("sbcl-prove" ,sbcl-prove)))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; Tests fail with: Component JONATHAN-ASD::JONATHAN-TEST not
+ ;; found, required by #<SYSTEM "jonathan">. Why?
+ `(#:tests? #f)))))
+
+(define-public cl-jonathan
+ (sbcl-package->cl-source-package sbcl-jonathan))
+
+(define-public sbcl-http-body
+ (let ((commit-hash "dd01dc4f5842e3d29728552e5163acce8386eb73"))
+ (package
+ (name "sbcl-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.")
+ (home-page "https://github.com/fukamachi/http-body";)
+ (license license:bsd-2)
+ (version (string-append "0.1.0-" (string-take commit-hash 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/http-body";)
+ (commit commit-hash)))
+ (sha256 (base32
"1jd06snjvxcprhapgfq8sx0y5lrldkvhf206ix6d5a23dd6zcmr0"))))
+ (inputs
+ `(("sbcl-fast-http" ,sbcl-fast-http)
+ ("sbcl-jonathan" ,sbcl-jonathan)
+ ("sbcl-quri" ,sbcl-quri)))
+ (native-inputs
+ `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+ ("sbcl-prove" ,sbcl-prove)))
+ (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)))))
+
+(define-public cl-http-body
+ (sbcl-package->cl-source-package sbcl-http-body))
+
+(define-public sbcl-circular-streams
+ (let ((commit-hash "e770bade1919c5e8533dd2078c93c3d3bbeb38df"))
+ (package
+ (name "sbcl-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.")
+ (home-page "https://github.com/fukamachi/circular-streams";)
+ (license license:llgpl)
+ (version (string-append "0.1.0-" (string-take commit-hash 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/circular-streams";)
+ (commit commit-hash)))
+ (sha256 (base32
"1wpw6d5cciyqcf92f7mvihak52pd5s47kk4qq6f0r2z2as68p5rs"))))
+ (inputs
+ `(("sbcl-fast-io" ,sbcl-fast-io)
+ ("sbcl-trivial-gray-streams" ,sbcl-trivial-gray-streams)))
+ (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)))))
+
+(define-public cl-circular-streams
+ (sbcl-package->cl-source-package sbcl-circular-streams))
+
+(define-public sbcl-lack-request
+ (let ((commit-hash "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b"))
+ (package
+ (name "sbcl-lack-request")
+ (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.")
+ (home-page "https://github.com/fukamachi/lack";)
+ (license license:llgpl)
+ (version (string-append "0.1.0-" (string-take commit-hash 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/lack.git";)
+ (commit commit-hash)))
+ (sha256 (base32
"1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+ (inputs
+ `(("sbcl-quri" ,sbcl-quri)
+ ("sbcl-http-body" ,sbcl-http-body)
+ ("sbcl-circular-streams" ,sbcl-circular-streams)))
+ (native-inputs
+ `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+ ("sbcl-prove" ,sbcl-prove)))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-file "lack-request.asd"
+ #:asd-system-name "lack-request"
+ #:test-asd-file "t-lack-request.asd"
+ #:tests? #f)))))
+
+(define-public cl-lack-request
+ (sbcl-package->cl-source-package sbcl-lack-request))
+
+(define-public sbcl-lack-response
+ (let ((commit-hash "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b"))
+ (package
+ (name "sbcl-lack-response")
+ (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.")
+ (home-page "https://github.com/fukamachi/lack";)
+ (license license:llgpl)
+ (version (string-append "0.1.0-" (string-take commit-hash 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/lack.git";)
+ (commit commit-hash)))
+ (sha256 (base32
"1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+ (inputs
+ `(("sbcl-quri" ,sbcl-quri)
+ ("sbcl-http-body" ,sbcl-http-body)
+ ("sbcl-circular-streams" ,sbcl-circular-streams)
+ ("sbcl-local-time" ,sbcl-local-time)))
+ (native-inputs
+ `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+ ("sbcl-prove" ,sbcl-prove)))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-file "lack-response.asd"
+ #:asd-system-name "lack-response"
+ #:test-asd-file "t-lack-response.asd"
+ #:tests? #f)))))
+
+(define-public cl-lack-response
+ (sbcl-package->cl-source-package sbcl-lack-response))
+
+(define-public sbcl-lack-component
+ (let ((commit-hash "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b"))
+ (package
+ (name "sbcl-lack-component")
+ (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.")
+ (home-page "https://github.com/fukamachi/lack";)
+ (license license:llgpl)
+ (version (string-append "0.0.0-" (string-take commit-hash 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/lack.git";)
+ (commit commit-hash)))
+ (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"
+ #:tests? #f)))))
+
+(define-public cl-lack-component
+ (sbcl-package->cl-source-package sbcl-lack-component))
+
+(define-public sbcl-lack-util
+ (let ((commit-hash "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b"))
+ (package
+ (name "sbcl-lack-util")
+ (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.")
+ (home-page "https://github.com/fukamachi/lack";)
+ (license license:llgpl)
+ (version (string-append "0.1.0-" (string-take commit-hash 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/lack.git";)
+ (commit commit-hash)))
+ (sha256 (base32
"1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+ (inputs
+ `(("sbcl-ironclad" ,sbcl-ironclad)))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-file "lack-util.asd"
+ #:asd-system-name "lack-util"
+ #:test-asd-file "t-lack-util.asd"
+ #:tests? #f)))))
+
+(define-public cl-lack-util
+ (sbcl-package->cl-source-package sbcl-lack-util))
+
+(define-public sbcl-lack-middleware-backtrace
+ (let ((commit-hash "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b"))
+ (package
+ (name "sbcl-lack-middleware-backtrace")
+ (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.")
+ (home-page "https://github.com/fukamachi/lack";)
+ (license license:llgpl)
+ (version (string-append "0.1.0-" (string-take commit-hash 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/lack.git";)
+ (commit commit-hash)))
+ (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"
+ #:tests? #f)))))
+
+(define-public cl-lack-middleware-backtrace
+ (sbcl-package->cl-source-package sbcl-lack-middleware-backtrace))
+
+(define-public sbcl-lack-middleware-static
+ (let ((commit-hash "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b"))
+ (package
+ (name "sbcl-lack-middleware-static")
+ (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.")
+ (home-page "https://github.com/fukamachi/lack";)
+ (license license:llgpl)
+ (version (string-append "0.1.0-" (string-take commit-hash 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/lack.git";)
+ (commit commit-hash)))
+ (sha256 (base32
"1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+ (inputs
+ `(("sbcl-ironclad" ,sbcl-ironclad)
+ ("sbcl-trivial-mimes" ,sbcl-trivial-mimes)
+ ("sbcl-local-time" ,sbcl-local-time)))
+ (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"
+ #:tests? #f)))))
+
+(define-public cl-lack-middleware-static
+ (sbcl-package->cl-source-package sbcl-lack-middleware-static))
+
+(define-public sbcl-lack
+ (let ((commit-hash "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b"))
+ (package
+ (name "sbcl-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.")
+ (home-page "https://github.com/fukamachi/lack";)
+ (license license:llgpl)
+ (version (string-append "0.1.0-" (string-take commit-hash 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/lack.git";)
+ (commit commit-hash)))
+ (sha256 (base32
"1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+ (inputs
+ `(("sbcl-lack-component" ,sbcl-lack-component)
+ ("sbcl-lack-util" ,sbcl-lack-util)))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:test-asd-file "t-lack.asd"
+ #:tests? #f)))))
+
+(define-public cl-lack
+ (sbcl-package->cl-source-package sbcl-lack))
+
+(define-public sbcl-local-time
+ (let ((commit-hash "beac054eef428552b63d4ae7820c32ffef9a3015"))
+ (package
+ (name "sbcl-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\".")
+ (home-page "https://common-lisp.net/project/local-time/";)
+ (license license:expat) ; MIT
+ (version (string-append "1.0.6-" (string-take commit-hash 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/dlowe-net/local-time.git";)
+ (commit commit-hash)))
+ (sha256 (base32
"0xhkmgxh41dg2wwlsp0h2l41jp144xn4gpxhh0lna6kh0560w2cc"))))
+ (inputs
+ `(("sbcl-cl-fad" ,sbcl-cl-fad)))
+ (native-inputs
+ `(("stefil" ,sbcl-hu.dwim.stefil)))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; TODO: Component :STEFIL not found, required by #<SYSTEM
+ ;; "local-time/test">
+ '(#:tests? #f)))))
+
+(define-public cl-local-time
+ (sbcl-package->cl-source-package sbcl-local-time))
+
+(define-public sbcl-ningle
+ (let ((commit-hash "50bd4f09b5a03a7249bd4d78265d6451563b25ad"))
+ (package
+ (name "sbcl-ningle")
+ (synopsis "Super micro framework for Common Lisp")
+ (description "Ningle is a lightweight web application framework for
Common Lisp.")
+ (home-page "http://8arrow.org/ningle/";)
+ (license license:llgpl)
+ (version (string-append "0.3.0-" (string-take commit-hash 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/ningle.git";)
+ (commit commit-hash)))
+ (sha256 (base32
"1bsl8cnxhacb8p92z9n89vhk1ikmij5zavk0m2zvmj7iqm79jzgw"))))
+ (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)
+ ))
+ (native-inputs
+ `(("sbcl-prove-asdf" ,sbcl-prove-asdf)
+ ("sbcl-prove" ,sbcl-prove)))
+ (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$")))
+ ;;(system-fasl (string-append lib "/ningle--system.fasl")))
+ (display (string-append "KT: " ningle-path))
+ (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))
+ ;; (lisp-eval-program
+ ;; `((require :uiop)
+ ;; (uiop:combine-fasls ',(map fasl-path '("context" "app"
"route" "main")) ,system-fasl)
+ ;; ;;(uiop:combine-fasls ',fasl-files ,system-fasl)
+ ;; ))
+ )))
+ ;; TODO: Do we need this?
+ ;; (add-after 'create-asd-file 'fix-package-inferred-system
+ ;; (lambda* (#:key outputs #:allow-other-keys)
+ ;; (let* ((out (assoc-ref outputs "out"))
+ ;; (new-asd-path (string-append out
"/lib/sbcl/ningle.asd")))
+ ;; (substitute* new-asd-path
+ ;; ((" \"ningle-main\"" all)
+ ;; " \"ningle/main\"")))))
+
+ ;; (add-after 'unpack 'fix-paths
+ ;; (lambda* (#:key inputs #:allow-other-keys)
+ ;; ;; (substitute* "ningle.asd"
+ ;; ;; (("#:lack.response))" all)
+ ;; ;;
"#:lack.response))\n\n(register-system-packages \"ningle-main\" '(#:ningle
#:ningle/main))"))
+ ;; ;; (substitute* "ningle.asd"
+ ;; ;; (("ningle/main" all)
+ ;; ;; "ningle-main"))
+ ;; (substitute* "main.lisp"
+ ;; (("#:ningle$" all)
+ ;; "#:ningle/main"))
+ ;; )
+ ;; )
+ )
+ )))))
+
+(define-public cl-ningle
+ (sbcl-package->cl-source-package sbcl-ningle))
+
+(define-public sbcl-trivial-mimes
+ (let ((commit-hash "303f8ac0aa6ca0bc139aa3c34822e623c3723fab"))
+ (package
+ (name "sbcl-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.")
+ (home-page "http://shinmera.github.io/trivial-mimes/";)
+ (license license:artistic2.0)
+ (version (string-append "1.1.0-" (string-take commit-hash 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Shinmera/trivial-mimes.git";)
+ (commit commit-hash)))
+ (sha256 (base32
"17jxgl47r695bvsb7wi3n2ws5rp1zzgvw0zii8cy5ggw4b4ayv6m"))))
+ (inputs
+ `(("sbcl-cl-fad" ,sbcl-cl-fad)))
+ (native-inputs
+ `(("stefil" ,sbcl-hu.dwim.stefil)))
+ (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/sbcl-source/trivial-mimes/mime.types\")"))))))))))))
+
+(define-public cl-trivial-mimes
+ (sbcl-package->cl-source-package sbcl-trivial-mimes))
+
+(define-public sbcl-clack
+ (let ((commit-hash "e3e032843bb1220ab96263c411aa7f2feb4746e0"))
+ (package
+ (name "sbcl-clack")
+ (synopsis
+ "Clack is a web application environment for Common Lisp inspired by
Python's WSGI and Ruby's Rack.")
+ (description
+ "Clack is a web application environment for Common Lisp inspired by
Python's WSGI and Ruby's Rack.")
+ (home-page "https://github.com/fukamachi/clack";)
+ (license license:llgpl)
+ (version (string-append "2.0.0-" (string-take commit-hash 7)))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/clack.git";)
+ (commit commit-hash)))
+ (sha256 (base32
"1ymzs6qyrwhlj6cgqsnpyn6g5cbp7a3s1vgxwna20y2q7y4iacy0"))))
+ (inputs
+ `(("sbcl-lack" ,sbcl-lack)
+ ("sbcl-lack-middleware-backtrace" ,sbcl-lack-middleware-backtrace)
+ ("sbcl-bordeaux-threads" ,sbcl-bordeaux-threads)))
+ (build-system asdf-build-system/sbcl))))
+
+(define-public cl-clack
+ (sbcl-package->cl-source-package sbcl-clack))
diff --git a/guix/licenses.scm b/guix/licenses.scm
index d22c3fa36e..5c406503a6 100644
--- a/guix/licenses.scm
+++ b/guix/licenses.scm
@@ -65,7 +65,7 @@
imlib2
ipa
knuth
- lgpl2.0 lgpl2.0+ lgpl2.1 lgpl2.1+ lgpl3 lgpl3+
+ lgpl2.0 lgpl2.0+ lgpl2.1 lgpl2.1+ lgpl3 lgpl3+ llgpl
lppl lppl1.0+ lppl1.1+ lppl1.2 lppl1.2+
lppl1.3 lppl1.3+
lppl1.3a lppl1.3a+
@@ -417,6 +417,11 @@ at URI, which may be a file:// URI pointing the package's
tree."
"https://www.gnu.org/licenses/lgpl.html";
"https://www.gnu.org/licenses/license-list#LGPLv3";))
+(define llgpl
+ (license "LLGPL"
+ "https://opensource.franz.com/preamble.html";
+ "Lisp Lesser General Public License"))
+
(define lppl
(license "LPPL (any version)"
"https://www.latex-project.org/lppl/lppl-1-0/";
--
2.20.1
--
Katherine
--- End Message ---