From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([209.51.188.92]:37385) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1h7nT5-0005Uh-4q for guix-patches@gnu.org; Sat, 23 Mar 2019 16:42:20 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1h7nSt-0000EZ-Ov for guix-patches@gnu.org; Sat, 23 Mar 2019 16:42:10 -0400 Received: from debbugs.gnu.org ([209.51.188.43]:42265) by eggs.gnu.org with esmtps (TLS1.0:RSA_AES_128_CBC_SHA1:16) (Exim 4.71) (envelope-from ) id 1h7nSs-0000CC-0M for guix-patches@gnu.org; Sat, 23 Mar 2019 16:42:03 -0400 Received: from Debian-debbugs by debbugs.gnu.org with local (Exim 4.84_2) (envelope-from ) id 1h7nSr-0005nk-OY for guix-patches@gnu.org; Sat, 23 Mar 2019 16:42:01 -0400 Subject: [bug#34959] Acknowledgement ([PATCH] Add Multiple Common Lisp Packages) Resent-Message-ID: From: Katherine Cox-Buday References: <87pnqh4acd.fsf@gmail.com> Date: Sat, 23 Mar 2019 15:41:12 -0500 In-Reply-To: (GNU bug Tracking System's message of "Sat, 23 Mar 2019 20:16:02 +0000") Message-ID: <87lg15493r.fsf@gmail.com> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="=-=-=" List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: guix-patches-bounces+kyle=kyleam.com@gnu.org Sender: "Guix-patches" To: 34959@debbugs.gnu.org --=-=-= Content-Type: text/plain Of course as soon as I push it up and review it I find all the junk i left in. Here's a cleaner patch, with apologies. --=-=-= Content-Type: text/x-patch; charset=utf-8 Content-Disposition: inline; filename=0001-Add-Multiple-Common-Lisp-Packages.patch Content-Transfer-Encoding: quoted-printable >From d40bd8e4b7b2637b088ea3c14825fd4062625e22 Mon Sep 17 00:00:00 2001 From: Katherine Cox-Buday Date: Sat, 23 Mar 2019 15:01:11 -0500 Subject: [PATCH] Add Multiple Common Lisp Packages --- gnu/packages/lisp.scm | 1181 ++++++++++++++++++++++++++++++++++++++++- guix/licenses.scm | 7 +- 2 files changed, 1185 insertions(+), 3 deletions(-) diff --git a/gnu/packages/lisp.scm b/gnu/packages/lisp.scm index 3d43b7c509..095c6e5c4e 100644 --- a/gnu/packages/lisp.scm +++ b/gnu/packages/lisp.scm @@ -12,6 +12,7 @@ ;;; Copyright =C2=A9 2018 Alex Vong ;;; Copyright =C2=A9 2018 Pierre Neidhardt ;;; Copyright =C2=A9 2018 Pierre Langlois +;;; Copyright =C2=A9 2019 Katherine Cox-Buday ;;; ;;; 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 dis= played with the provided color. It further provides functions which will print the argument with t= he 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)))) =20 (define-public cl-ansi-text (sbcl-package->cl-source-package sbcl-cl-ansi-text)) @@ -3840,3 +3841,1179 @@ client and server.") =20 (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 Co= mmon Lisp standard was how to get a Lisp to output its call stack when some= thing has gone wrong. As such, each Lisp has developed its own notion of wh= at 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 backt= race 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 "10p41p43skj6cimdg8skjy7372s8v2xpkg8djjy0l8rm45i654= k1")))) + (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, wh= ich 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 "0phh5n3clhl9ji8jaxrajidn22d3f0aq87mlbfkkxlnx2pnw69= 4k")))) + (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 Algo= rithm (RFC 1321).") + (description "This package implements The MD5 Message-Digest Algorit= hm, 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 "19yl9n0pjdz5gw4qi711lka97xcd9f81ylg434hk7jwn9f2s= 6w11")))) + (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 "1845i1pafmqb6cdlr53yaqy67kjrhkvbx6c37ca15cw70vhd= r3z9")))) + (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 Ke= vin 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 "1va7xjgzfv674bpsli674i7zj3f7wg5kxic41kz18r6hh4n5= 2dfv")))) + (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 u= sing 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 "1dw6j7n6gsd2qa0p0rbsjxj00acxx3i9ca1qkgl0liy8lpnw= kypl")))) + (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" v= ersion ".tar.gz")) + (sha256 (base32 "0ra17kyc9l7qbaw003ly111r1cbn4zixbfq1ydr9cxw10v30= q1n7")))) + (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 pr= ogrammer 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 ju= st 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, gzi= p, and bzip2 data.") + (description + "DEFLATE data, defined in RFC1951, forms the core of popular compres= sion formats such as zlib (RFC 1950) and gzip (RFC 1952). As such, Chipz al= so provides for decompressing data in those formats as well. BZIP2 is the f= ormat 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. I= t 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 c= onnections (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 "17z8rpd6b5w93jwrdwfwxjha617xnjqw8aq1hw2z76zp1fn8yr= mh")))) + (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 Li= sp 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 Li= sp.") + (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 "1wq1gs9jjd5m6iwrv06c2d7i5dvqsfjcljgbspfbc93cg5xahk= 4n")))) + (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 Li= sp 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 "0briia9bk3lbr0frnx39d1qg6i38dm4j6z9w3yga3d40k6df4a= 90")))) + (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 #. 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 , ther= e is a collection of Common Lisp Utilities, things that everybody writes si= nce they're not part of the official standard. There are some very useful t= hings 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 pa= ckaged and maintained. It takes quite a bit of work to carefully implement = utilities for common use, commented and documented, with error checking pla= ced 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 "1r46v730yf96nk2vb24qmagv9x96xvd08abqwhf02ghgydv1a7= z2")))) + (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(requir= e :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 consta= nt 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-se= t/get/" commit-hash ".tar.gz")) + (sha256 (base32 "1sx5j5qdsy5fklspfammwb16kjrhkggdavm922a9q86jm5l0b2= 39")))) + (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 "1ccbxsgzdibmzq33mmbmmz9vwl6l03xh6nbpsh1hkdvdcl7q0a= 60")))) + (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 #. 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 th= e 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 "0qz1zzxx0wm5ff7gpgsq550a59p0qj594zfmm2rglj97dahj54= l7")))) + (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 no= t found, + ;; required by #. 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 \"subse= q\"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 "1xz79q0p2mclf3sqjiwf6izdpb6xrsr350bv4mlmdlm6rg5r99= px")))) + (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 #. 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 fo= r 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 "0qdmwv2zm0sizxdb8nnclgwl0nfjcbjaimbakavikijw7lr9b4= jp")))) + (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 #. 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 "138nlsq14hv8785ycjm6jw3i6ablhq8vcwys7q09y80arcgrg6= r3")))) + (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 obj= ect into a string representation, put it on a stream an revive it from ther= e. 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 "08qs6fhk38xpkkjkpcj92mxx0lgy4ygrbbzrmnivdx281syr0g= wh")))) + (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 + "Why write programs in Common Lisp but tests like Java? Meet CheckL!= ") + (home-page "https://github.com/rpav/CheckL/") + ;; 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 "0bpisihx1gay44xmyr1dmhlwh00j0zzi04rp9fy35i95l2r4xd= lx")))) + (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 s= treams (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 "1jsp6xvi26ln6fdy5j5zi05xvan8jsqdhisv552dy6xg6ws8i1= yq")))) + (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 j= son 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 "14x4iwz3mbag5jzzzr4sb6ai0m9r4q4kyypbq32jmsk2dx1hi8= 07")))) + (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 #. 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 parame= ters. 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 "1jd06snjvxcprhapgfq8sx0y5lrldkvhf206ix6d5a23dd6zcm= r0")))) + (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 #. 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 wi= ll 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 "1wpw6d5cciyqcf92f7mvihak52pd5s47kk4qq6f0r2z2as68p5= rs")))) + (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 c= onstructed of modular components. It was originally a part of Clack, howeve= r it's going to be rewritten as an individual project since Clack v2 with p= erformance 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 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi= 85")))) + (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 c= onstructed of modular components. It was originally a part of Clack, howeve= r it's going to be rewritten as an individual project since Clack v2 with p= erformance 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 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi= 85")))) + (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 c= onstructed of modular components. It was originally a part of Clack, howeve= r it's going to be rewritten as an individual project since Clack v2 with p= erformance 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 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi= 85")))) + (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 c= onstructed of modular components. It was originally a part of Clack, howeve= r it's going to be rewritten as an individual project since Clack v2 with p= erformance 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 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi= 85")))) + (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 c= onstructed of modular components. It was originally a part of Clack, howeve= r it's going to be rewritten as an individual project since Clack v2 with p= erformance 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 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi= 85")))) + (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 c= onstructed of modular components. It was originally a part of Clack, howeve= r it's going to be rewritten as an individual project since Clack v2 with p= erformance 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 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi= 85")))) + (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 c= onstructed of modular components. It was originally a part of Clack, howeve= r it's going to be rewritten as an individual project since Clack v2 with p= erformance 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 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi= 85")))) + (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 "0xhkmgxh41dg2wwlsp0h2l41jp144xn4gpxhh0lna6kh0560w2= cc")))) + (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 # + '(#: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 "1bsl8cnxhacb8p92z9n89vhk1ikmij5zavk0m2zvmj7iqm79= jzgw")))) + (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$"))) + (mkdir-p ningle-path) + (let ((fasl-path (lambda (name) + (string-append ningle-path "/" (basena= me name) "--system.fasl")))) + (for-each (lambda (file) + (rename-file file (fasl-path (basename file= ".fasl")))) + fasl-files)) + fasl-files))))))))) + +(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 t= o 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 "17jxgl47r695bvsb7wi3n2ws5rp1zzgvw0zii8cy5ggw4b4ayv= 6m")))) + (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-pathna= me :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 "1ymzs6qyrwhlj6cgqsnpyn6g5cbp7a3s1vgxwna20y2q7y4iac= y0")))) + (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 packag= e's tree." "https://www.gnu.org/licenses/lgpl.html" "https://www.gnu.org/licenses/license-list#LGPLv3")) =20 +(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/" --=20 2.20.1 --=-=-= Content-Type: text/plain -- Katherine --=-=-=--