From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([209.51.188.92]:33312) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1h7n3p-0007Uy-3J for guix-patches@gnu.org; Sat, 23 Mar 2019 16:16:14 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1h7n3i-0000cq-TW for guix-patches@gnu.org; Sat, 23 Mar 2019 16:16:09 -0400 Received: from debbugs.gnu.org ([209.51.188.43]:42254) by eggs.gnu.org with esmtps (TLS1.0:RSA_AES_128_CBC_SHA1:16) (Exim 4.71) (envelope-from ) id 1h7n3i-0000cb-IF for guix-patches@gnu.org; Sat, 23 Mar 2019 16:16:02 -0400 Received: from Debian-debbugs by debbugs.gnu.org with local (Exim 4.84_2) (envelope-from ) id 1h7n3i-00057j-9a for guix-patches@gnu.org; Sat, 23 Mar 2019 16:16:02 -0400 Subject: [bug#34959] [PATCH] Add Multiple Common Lisp Packages Resent-Message-ID: Received: from eggs.gnu.org ([209.51.188.92]:33026) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1h7n2O-0006pz-7h for guix-patches@gnu.org; Sat, 23 Mar 2019 16:14:45 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1h7n2I-0006ud-Og for guix-patches@gnu.org; Sat, 23 Mar 2019 16:14:40 -0400 Received: from mail-io1-xd2c.google.com ([2607:f8b0:4864:20::d2c]:42419) by eggs.gnu.org with esmtps (TLS1.0:RSA_AES_128_CBC_SHA1:16) (Exim 4.71) (envelope-from ) id 1h7n2G-0006lH-Ar for guix-patches@gnu.org; Sat, 23 Mar 2019 16:14:34 -0400 Received: by mail-io1-xd2c.google.com with SMTP id c4so4497333ioh.9 for ; Sat, 23 Mar 2019 13:14:30 -0700 (PDT) Received: from gazelle-pro (172-221-246-205.dhcp.chtrptr.net. [172.221.246.205]) by smtp.gmail.com with ESMTPSA id j10sm3421428itj.32.2019.03.23.13.14.26 for (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Sat, 23 Mar 2019 13:14:27 -0700 (PDT) From: Katherine Cox-Buday Date: Sat, 23 Mar 2019 15:14:26 -0500 Message-ID: <87pnqh4acd.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 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. --=-=-= 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 c4b9394599c7cf9f6069fb3e8c3466858155e1c8 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 | 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 =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,1208 @@ 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? Mee= t 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 "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$"))) + ;;(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 "/" (basena= me 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" "a= pp" "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/s= bcl/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(registe= r-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 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 --=-=-=--