diff options
Diffstat (limited to 'gnu/packages/lisp-xyz.scm')
| -rw-r--r-- | gnu/packages/lisp-xyz.scm | 2119 |
1 files changed, 1825 insertions, 294 deletions
diff --git a/gnu/packages/lisp-xyz.scm b/gnu/packages/lisp-xyz.scm index c9f3794c19..49e1160cb7 100644 --- a/gnu/packages/lisp-xyz.scm +++ b/gnu/packages/lisp-xyz.scm @@ -10,17 +10,19 @@ ;;; Copyright © 2017, 2019 Tobias Geerinckx-Rice <me@tobias.gr> ;;; Copyright © 2018 Benjamin Slade <slade@jnanam.net> ;;; Copyright © 2018 Alex Vong <alexvong1995@gmail.com> -;;; Copyright © 2018, 2020 Pierre Neidhardt <mail@ambrevar.xyz> +;;; Copyright © 2018, 2020, 2021 Pierre Neidhardt <mail@ambrevar.xyz> ;;; Copyright © 2018, 2019 Pierre Langlois <pierre.langlois@gmx.com> ;;; Copyright © 2019, 2020 Katherine Cox-Buday <cox.katherine.e@gmail.com> ;;; Copyright © 2019 Jesse Gildersleve <jessejohngildersleve@protonmail.com> -;;; Copyright © 2019, 2020 Guillaume Le Vaillant <glv@posteo.net> +;;; Copyright © 2019, 2020, 2021 Guillaume Le Vaillant <glv@posteo.net> ;;; Copyright © 2019 Brett Gilio <brettg@gnu.org> ;;; Copyright © 2020 Konrad Hinsen <konrad.hinsen@fastmail.net> ;;; Copyright © 2020 Dimakis Dimakakos <me@bendersteed.tech> ;;; Copyright © 2020 Oleg Pykhalov <go.wigust@gmail.com> -;;; Copyright © 2020 Adam Kandur <rndd@tuta.io> -;;; Copyright © 2020 Sharlatan Hellseher <sharlatanus@gmail.com> +;;; Copyright © 2020, 2021 Adam Kandur <rndd@tuta.io> +;;; Copyright © 2020, 2021 Sharlatan Hellseher <sharlatanus@gmail.com> +;;; Copyright © 2021 Aurora <rind38@disroot.org> +;;; Copyright © 2021 Matthew Kraai <kraai@ftbfs.org> ;;; ;;; This file is part of GNU Guix. ;;; @@ -52,10 +54,12 @@ #:use-module (guix utils) #:use-module (guix build-system asdf) #:use-module (guix build-system trivial) + #:use-module (gnu packages base) #:use-module (gnu packages c) #:use-module (gnu packages compression) #:use-module (gnu packages databases) #:use-module (gnu packages enchant) + #:use-module (gnu packages file) #:use-module (gnu packages fonts) #:use-module (gnu packages fontutils) #:use-module (gnu packages glib) @@ -65,6 +69,7 @@ #:use-module (gnu packages libffi) #:use-module (gnu packages lisp) #:use-module (gnu packages maths) + #:use-module (gnu packages mp3) #:use-module (gnu packages networking) #:use-module (gnu packages pkg-config) #:use-module (gnu packages python) @@ -110,6 +115,36 @@ portable between implementations.") (define-public ecl-alexandria (sbcl-package->ecl-package sbcl-alexandria)) +(define-public sbcl-golden-utils + (let ((commit "9424419d867d5c2f819196ee41667a818a5058e7") + (revision "1")) + (package + (name "sbcl-golden-utils") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://git.mfiano.net/mfiano/golden-utils") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "15x0phm6820yj3h37ibi06gjyh6z45sd2nz2n8lcbfflwm086q0h")))) + (build-system asdf-build-system/sbcl) + (inputs + `(("alexandria" ,sbcl-alexandria))) + (home-page "https://git.mfiano.net/mfiano/golden-utils") + (synopsis "Common Lisp utility library") + (description + "This is a Common Lisp library providing various utilities.") + (license license:expat)))) + +(define-public ecl-golden-utils + (sbcl-package->ecl-package sbcl-golden-utils)) + +(define-public cl-golden-utils + (sbcl-package->cl-source-package sbcl-golden-utils)) + (define-public sbcl-asdf-finalizers (let ((commit "7f537f6c598b662ae987c6acc268dd27c25977e0") (revision "1")) @@ -243,6 +278,41 @@ interactive development model in mind.") (define-public ecl-fiveam (sbcl-package->ecl-package sbcl-fiveam)) +(define-public sbcl-trivial-timeout + (let ((commit "feb869357f40f5e109570fb40abad215fb370c6c") + (revision "1")) + (package + (name "sbcl-trivial-timeout") + (version (git-version "0.1.5" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/gwkkwg/trivial-timeout/") + (commit commit))) + (file-name (git-file-name "trivial-timeout" version)) + (sha256 + (base32 "1kninxwvvih9nhh7a9y8lfgi7pdr76675y1clw4ss17vz8fbim5p")))) + (build-system asdf-build-system/sbcl) + (native-inputs + `(("lift" ,sbcl-lift))) + (arguments + ;; NOTE: (Sharlatan-20210202T231437+0000): Due to the age of this library + ;; tests use some deprecated functionality and keep failing. + `(#:tests? #f)) + (home-page "https://github.com/gwkkwg/trivial-timeout/") + (synopsis "Timeout library for Common Lisp") + (description + "This library provides an OS and implementation independent access to +timeouts.") + (license license:expat)))) + +(define-public ecl-trivial-timeout + (sbcl-package->ecl-package sbcl-trivial-timeout)) + +(define-public cl-trivial-timeout + (sbcl-package->cl-source-package sbcl-trivial-timeout)) + (define-public sbcl-bordeaux-threads (package (name "sbcl-bordeaux-threads") @@ -455,34 +525,70 @@ compatible with ANSI-compliant Common Lisp implementations.") (define-public ecl-cl-ppcre (sbcl-package->ecl-package sbcl-cl-ppcre)) -(define-public sbcl-uax-15 - (let ((commit "e7439a91b72f533fcf736643e3ff0677b56c2e7d") +(define-public sbcl-ubiquitous + (let ((commit "35eb7bd9e1b3daee1705f6b41260775180cce8af") (revision "1")) (package - (name "sbcl-uax-15") - (version (git-version "0.1" revision commit)) + (name "sbcl-ubiquitous") + (version (git-version "2.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/sabracrolleton/uax-15") + (url "https://github.com/Shinmera/ubiquitous") (commit commit))) - (file-name (git-file-name "uax-15" version)) + (file-name (git-file-name "ubiquitous" version)) (sha256 - (base32 "1vf8a2aikgx0l5bsq0z9s0dw3sgx1887xhagdlf66fwffa5jskg6")))) + (base32 "1xlkaqmjcpkiv2xl2s2pvvrv976dlc846wm16s1lj62iy1315i49")))) (build-system asdf-build-system/sbcl) - (native-inputs - `(("fiveam" ,sbcl-fiveam))) (inputs - `(("cl-ppcre" ,sbcl-cl-ppcre) - ("split-sequence" ,sbcl-split-sequence))) + `(("bordeaux-threads" ,sbcl-bordeaux-threads))) (arguments - `(#:asd-systems '("uax-15"))) - (home-page "https://github.com/sabracrolleton/uax-15") - (synopsis "Common Lisp implementation of unicode normalization functions") - (description "This package provides supports for unicode normalization, -RFC8264 and RFC7564.") - (license license:expat)))) + '(#:asd-systems '("ubiquitous" + "ubiquitous-concurrent"))) + (home-page "https://shinmera.github.io/ubiquitous/") + (synopsis "Application configuration mechanism for Common Lisp") + (description + "@code{UBIQUITOUS} is a very easy-to-use library for persistent +configuration storage. It automatically takes care of finding a suitable place +to save your data, and provides simple functions to access and modify the data +within.") + (license license:zlib)))) + +(define-public ecl-ubiquitous + (sbcl-package->ecl-package sbcl-ubiquitous)) + +(define-public cl-ubiquitous + (sbcl-package->cl-source-package sbcl-ubiquitous)) + +(define-public sbcl-uax-15 + (package + (name "sbcl-uax-15") + (version "0.1.1") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/sabracrolleton/uax-15") + (commit (string-append "v" version)))) + (file-name (git-file-name "uax-15" version)) + (sha256 + (base32 "0p2ckw7mzxhwa9vbwj2q2dzayz9dl94d9yqd2ynp0pc5v8i0n2fr")))) + (build-system asdf-build-system/sbcl) + (arguments + `(#:asd-systems + '("uax-15"))) + (native-inputs + `(("fiveam" ,sbcl-fiveam))) + (inputs + `(("cl-ppcre" ,sbcl-cl-ppcre) + ("split-sequence" ,sbcl-split-sequence))) + (home-page "https://github.com/sabracrolleton/uax-15") + (synopsis "Common Lisp implementation of unicode normalization functions") + (description + "This package provides supports for unicode normalization, RFC8264 and +RFC7564.") + (license license:expat))) (define-public cl-uax-15 (sbcl-package->cl-source-package sbcl-uax-15)) @@ -782,12 +888,10 @@ antialiased TrueType font rendering using CLX and XRender extension.") (sbcl-package->ecl-package sbcl-clx-truetype)) (define-public sbcl-slynk - (let ((revision "4") - ;; Update together with emacs-sly. - (commit "68561f1b7b66fa0240766ece836bb04da31ea17d")) + (let ((commit "0f46f91a9542599d62c0c332b39636b2941ea372")) (package (name "sbcl-slynk") - (version (git-version "1.0.0-beta" revision commit)) + (version (git-version "1.0.43" "3" commit)) (source (origin (method git-fetch) @@ -796,41 +900,12 @@ antialiased TrueType font rendering using CLX and XRender extension.") (url "https://github.com/joaotavora/sly") (commit commit))) (sha256 - (base32 "1xwx537dhgclngi6b0faf320i8pnac9309wvmk6z2g6dm3v652ds")) - (file-name (git-file-name "slynk" version)) - (modules '((guix build utils) - (ice-9 ftw))) - (snippet - '(begin - ;; Move the contribs into the main source directory for easier - ;; access - (substitute* "slynk/slynk.asd" - (("\\.\\./contrib") - "contrib")) - (rename-file "contrib" "slynk/contrib") - ;; Move slynk's contents into the base directory for easier - ;; access - (for-each (lambda (file) - (unless (string-prefix? "." file) - (rename-file (string-append "slynk/" file) - (string-append "./" (basename file))))) - (scandir "slynk")) - #t)))) + (base32 "0p3j0zylacy6vms8ngis2hx2351xnwfzsw3zy043q6vmqd14wrf1")) + (file-name (git-file-name "slynk" version)))) (build-system asdf-build-system/sbcl) (outputs '("out" "image")) (arguments - `(#:tests? #f ; No test suite - #:asd-systems '("slynk" - "slynk/arglists" - "slynk/fancy-inspector" - "slynk/package-fu" - "slynk/mrepl" - "slynk/trace-dialog" - "slynk/profiler" - "slynk/stickers" - "slynk/indentation" - "slynk/retro") - #:phases + `(#:phases (modify-phases %standard-phases (add-after 'create-asdf-configuration 'build-image (lambda* (#:key outputs #:allow-other-keys) @@ -1316,6 +1391,34 @@ and macros, primarily for software projects written in CL by the author.") (define-public ecl-jpl-util (sbcl-package->ecl-package sbcl-jpl-util)) +(define-public sbcl-piping + (let ((commit "c7a4163c00dea7e72bf6ad33d6abac0d5826a656") + (revision "1")) + (package + (name "sbcl-piping") + (version (git-version "2.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/piping/") + (commit commit))) + (file-name (git-file-name "piping" version)) + (sha256 + (base32 "0in84qnfkynm36d4n4d6v87vprpi27xrydnga462wfhplji6klv5")))) + (build-system asdf-build-system/sbcl) + (home-page "https://shinmera.github.io/piping/") + (synopsis "Library to enable simple message pipelines") + (description + "This is a Common Lisp library to enable simple message pipelines.") + (license license:zlib)))) + +(define-public ecl-piping + (sbcl-package->ecl-package sbcl-piping)) + +(define-public cl-piping + (sbcl-package->cl-source-package sbcl-piping)) + (define-public sbcl-jpl-queues (package (name "sbcl-jpl-queues") @@ -1580,10 +1683,11 @@ C, C++, Java, Python, Erlang, Haskell, Objective-C, Diff, Webkit.") (sbcl-package->ecl-package sbcl-colorize)) (define-public sbcl-3bmd - (let ((commit "192ea13435b605a96ef607df51317056914cabbd")) + (let ((commit "6fc5759448f6f6df6f6df556e020a289a2643288") + (revision "2")) (package (name "sbcl-3bmd") - (version (git-version "0.0.0" "1" commit)) + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) @@ -1591,24 +1695,29 @@ C, C++, Java, Python, Erlang, Haskell, Objective-C, Diff, Webkit.") (url "https://github.com/3b/3bmd") (commit commit))) (sha256 - (base32 - "1rgv3gi7wf963ikmmpk132wgn0icddf226gq3bmcnk1fr3v9gf2f")) + (base32 "1avmbp8xdjlbqpqk7p3vmj7abiw5p3vb5mrxp4wlvgql4sf6z3p4")) (file-name (git-file-name "3bmd" version)))) (build-system asdf-build-system/sbcl) (arguments - ;; FIXME: We need to specify the name because the build-system thinks - ;; "3" is a version marker. - `(#:asd-systems '("3bmd" - "3bmd-ext-code-blocks"))) + ;; FIXME: #41437 - Build fails when package name starts from a digit + `(#:asd-systems + '("3bmd" + "3bmd-ext-definition-lists" + "3bmd-ext-math" + "3bmd-ext-tables" + "3bmd-ext-wiki-links" + "3bmd-youtube" + "3bmd-ext-code-blocks"))) (inputs - `(("colorize" ,sbcl-colorize) + `(("alexandria" ,sbcl-alexandria) + ("colorize" ,sbcl-colorize) ("esrap" ,sbcl-esrap) ("split-sequence" ,sbcl-split-sequence))) + (home-page "https://github.com/3b/3bmd") (synopsis "Markdown processor in Command Lisp using esrap parser") (description - "Common Lisp Markdown -> HTML converter, using @command{esrap} for -parsing, and grammar based on @command{peg-markdown}.") - (home-page "https://github.com/3b/3bmd") + "This is a Common Lisp Markdown to HTML converter, using @command{esrap} +for parsing, and grammar based on @command{peg-markdown}.") (license license:expat)))) (define-public cl-3bmd @@ -1727,7 +1836,7 @@ also be supported.") (define-public sbcl-ironclad (package (name "sbcl-ironclad") - (version "0.53") + (version "0.54") (source (origin (method git-fetch) @@ -1735,7 +1844,7 @@ also be supported.") (url "https://github.com/sharplispers/ironclad/") (commit (string-append "v" version)))) (sha256 - (base32 "01qdfa0jggqbwlsb3aw1iigvs5xhnddk6kn3abhan59956dsbp02")) + (base32 "07g0wpvfqq2yk23prs890d4qvbnr3xd6w8ssd88g89xdg483wpvk")) (file-name (git-file-name name version)))) (build-system asdf-build-system/sbcl) (native-inputs @@ -1790,6 +1899,40 @@ named readtables, which is akin to package namespacing in Common Lisp.") (define-public ecl-named-readtables (sbcl-package->ecl-package sbcl-named-readtables)) +(define-public sbcl-py-configparser + ;; NOTE: (Sharlatan <2021-01-05 Tue> <19:52:19 UTC+0000>) Project updated last + ;; time 8y ago, it looks like abandoned. VCS of the project: + ;; https://svn.common-lisp.net/py-configparser/trunk + (package + (name "sbcl-py-configparser") + (version "1.0.3") + (source + (origin + (method url-fetch) + (uri (string-append + "https://common-lisp.net/project/py-configparser/releases/" + "py-configparser-" version ".tar.gz")) + (sha256 + (base32 "0i4rqz5cv7d7c2w81x5lwy05s6fbi3zikf4k5kpi3bkx3cabwdxj")))) + (build-system asdf-build-system/sbcl) + (inputs + `(("parse-number" ,sbcl-parse-number))) + (home-page "http://common-lisp.net/project/py-configparser/") + (synopsis "ConfigParser Python module functionality for Common Lisp") + (description "The py-configparser package implements the ConfigParser +Python module functionality in Common Lisp. In short, it implements reading +and writing of .INI-file style configuration files with sections containing +key/value pairs of configuration options. In line with the functionalities in +the python module, does this package implement basic interpolation of option +values in other options.") + (license license:expat))) + +(define-public cl-py-configparser + (sbcl-package->cl-source-package sbcl-py-configparser)) + +(define-public ecl-py-configparser + (sbcl-package->ecl-package sbcl-py-configparser)) + (define-public sbcl-pythonic-string-reader (let ((commit "47a70ba1e32362e03dad6ef8e6f36180b560f86a")) (package @@ -1907,6 +2050,51 @@ pretty, documentation is code.") ;; TODO: Find why the tests fail on ECL. ((#:tests? _ #f) #f)))))) +(define-public sbcl-mssql + (let ((commit "045602a19a32254108f2b75871049293f49731eb") + (revision "1")) + (package + (name "sbcl-mssql") + (version (git-version "0.0.3" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/archimag/cl-mssql") + (commit commit))) + (file-name (git-file-name "cl-mssql" version)) + (sha256 + (base32 "09i50adppgc1ybm3ka9vbindhwa2x29f9n3n0jkrryymdhb8zknm")))) + (build-system asdf-build-system/sbcl) + (inputs + `(("cffi" ,sbcl-cffi) + ("freetds" ,freetds) + ("garbage-pools" ,sbcl-garbage-pools) + ("iterate" ,sbcl-iterate) + ("parse-number" ,sbcl-parse-number))) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'fix-paths + (lambda* (#:key inputs #:allow-other-keys) + (substitute* "src/mssql.lisp" + (("libsybdb" all) + (string-append (assoc-ref inputs "freetds") "/lib/" all))) + #t))))) + (home-page "https://github.com/archimag/cl-mssql") + (synopsis "Common Lisp library to interact with MS SQL Server databases") + (description + "@code{cl-mssql} provides an interface to connect to Microsoft SQL +server. It uses the @code{libsybdb} foreign library provided by the FreeTDS +project.") + (license license:llgpl)))) + +(define-public ecl-mssql + (sbcl-package->ecl-package sbcl-mssql)) + +(define-public cl-mssql + (sbcl-package->cl-source-package sbcl-mssql)) + (define-public sbcl-lisp-unit (let ((commit "89653a232626b67400bf9a941f9b367da38d3815")) (package @@ -2209,10 +2397,11 @@ pattern-matching-like, but a char-by-char procedural parser.") (sbcl-package->ecl-package sbcl-proc-parse)) (define-public sbcl-parse-float - (let ((commit "2aae569f2a4b2eb3bfb5401a959425dcf151b09c")) + (let ((commit "3074765101e41222b6b624a66aaf1e6416379f9c") + (revision "2")) (package (name "sbcl-parse-float") - (version (git-version "0.0.0" "1" commit)) + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) @@ -2220,23 +2409,21 @@ pattern-matching-like, but a char-by-char procedural parser.") (url "https://github.com/soemraws/parse-float") (commit commit))) (sha256 - (base32 - "08xw8cchhmqcc0byng69m3f5a2izc9y2290jzz2k0qrbibp1fdk7")) + (base32 "0jd2spawc3v8vzqf8ky4cngl45jm65fhkrdf20mf6dcbn3mzpkmr")) (file-name (git-file-name "proc-parse" version)))) (build-system asdf-build-system/sbcl) - (inputs - `(("alexandria" ,sbcl-alexandria) - ("babel" ,sbcl-babel))) - (native-inputs - `(("prove" ,sbcl-prove))) (arguments - ;; TODO: Tests don't find "proc-parse-test", why? - `(#:tests? #f)) + ;; FIXME: https://github.com/soemraws/parse-float/issues/12 + `(#:asd-systems '("parse-float" "parse-float-tests"))) + (native-inputs + `(("lisp-unit" ,sbcl-lisp-unit))) + (inputs + `(("alexandria" ,sbcl-alexandria))) + (home-page "https://github.com/soemraws/parse-float") (synopsis "Parse a floating point value from a string in Common Lisp") (description "This package exports the following function to parse floating-point values from a string in Common Lisp.") - (home-page "https://github.com/soemraws/parse-float") (license license:public-domain)))) (define-public cl-parse-float @@ -2322,8 +2509,8 @@ tester module.") (sbcl-package->ecl-package sbcl-ptester)) (define-public sbcl-puri - (let ((commit "ef5afb9e5286c8e952d4344f019c1a636a717b97") - (revision "1")) + (let ((commit "4bbab89d9ccbb26346899d1f496c97604fec567b") + (revision "2")) (package (name "sbcl-puri") (version (git-version "1.5.7" revision commit)) @@ -2333,13 +2520,13 @@ tester module.") (uri (git-reference (url "http://git.kpe.io/puri.git") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "puri" version)) (sha256 - (base32 "1vm25pdl92laj72p5vyd538kf3cjy2655z6bdc99h20ana2p231s")))) + (base32 "0gq2rsr0aihs0z20v4zqvmdl4szq53b52rh97pvnmwrlbn4mapmd")))) (build-system asdf-build-system/sbcl) (native-inputs `(("ptester" ,sbcl-ptester))) - (home-page "http://quickdocs.org/puri/") + (home-page "http://puri.kpe.io/") (synopsis "Portable URI Library") (description "This is a portable Universal Resource Identifier library for Common @@ -2433,7 +2620,7 @@ non-consing thread safe queues and fibonacci priority queues.") (define-public sbcl-cffi (package (name "sbcl-cffi") - (version "0.21.0") + (version "0.23.0") (source (origin (method git-fetch) @@ -2442,7 +2629,7 @@ non-consing thread safe queues and fibonacci priority queues.") (commit (string-append "v" version)))) (file-name (git-file-name "cffi-bootstrap" version)) (sha256 - (base32 "1qalargz9bhp850qv60ffwpdqi4xirzar4l3g6qcg8yc6xqf2cjk")))) + (base32 "03s98imc5niwnpj3hhrafl7dmxq45g74h96sm68976k7ahi3vl5b")))) (build-system asdf-build-system/sbcl) (inputs `(("alexandria" ,sbcl-alexandria) @@ -2813,7 +3000,7 @@ is a library for creating graphical user interfaces.") (sbcl-package->ecl-package sbcl-cl-cffi-gtk)) (define-public sbcl-cl-webkit - (let ((commit "5ce3ea1fbf2b21e7ccb98402a818508ca9b79395")) + (let ((commit "0bc05cc73257670ab241853b9cc9ccb68940fe44")) (package (name "sbcl-cl-webkit") (version (git-version "2.4" "10" commit)) @@ -2826,7 +3013,7 @@ is a library for creating graphical user interfaces.") (file-name (git-file-name "cl-webkit" version)) (sha256 (base32 - "0zgd8hp2nalh0v4xgjvqxd6rf95f7mci181xbg3gmqxxwxd4mkpk")))) + "1kg6illspvb5647pm0x819ag2n7njnqvrm18jzgd28vk6nlkrcmq")))) (build-system asdf-build-system/sbcl) (inputs `(("cffi" ,sbcl-cffi) @@ -3154,6 +3341,34 @@ client and server.") (define-public ecl-s-xml-rpc (sbcl-package->ecl-package sbcl-s-xml-rpc)) +(define-public sbcl-trivial-arguments + (let ((commit "ecd84ed9cf9ef8f1e873d7409e6bd04979372aa7") + (revision "1")) + (package + (name "sbcl-trivial-arguments") + (version (git-version "1.1.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/trivial-arguments") + (commit commit))) + (file-name (git-file-name "trivial-arguments" version)) + (sha256 + (base32 "02vaqfavhj8jqxnr68nnzvzshm8jbgcy6m9lvyv4daa6f7ihqf88")))) + (build-system asdf-build-system/sbcl) + (home-page "https://github.com/Shinmera/trivial-arguments") + (synopsis "Common Lisp library to retrieve a function's lambda-list") + (description + "This is a simple library to retrieve the argument list of a function.") + (license license:zlib)))) + +(define-public ecl-trivial-arguments + (sbcl-package->ecl-package sbcl-trivial-arguments)) + +(define-public cl-trivial-arguments + (sbcl-package->cl-source-package sbcl-trivial-arguments)) + (define-public sbcl-trivial-clipboard (let ((commit "afcd3743b842f5a81fc86dba60f9db59970f49c5")) (package @@ -3773,8 +3988,8 @@ addition, removal, and random selection.") (sbcl-package->ecl-package sbcl-map-set)) (define-public sbcl-quri - (let ((commit "b53231c5f19446dd7c24b15a249fefa45ae94f9a") - (revision "2")) + (let ((commit "3a2ad208d71506b6243c0a4cf6a116f8ecf5ad2c") + (revision "3")) (package (name "sbcl-quri") (version (git-version "0.1.0" revision commit)) @@ -3786,7 +4001,7 @@ addition, removal, and random selection.") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 "0cansr63m690ymvhway419178mq2sqnmxm4rdxclbsrnjwwbi36m")))) + (base32 "1n0gs5xib42ccpai17f5xj9krmn9mwzkhlwdh59bka2sma64l829")))) (build-system asdf-build-system/sbcl) (arguments ;; Tests fail with: Component QURI-ASD::QURI-TEST not found, @@ -4279,8 +4494,8 @@ performance and simplicity in mind.") (sbcl-package->ecl-package sbcl-lack)) (define-public sbcl-local-time - (let ((commit "62792705245168d3fc2e04164b9a143477284142") - (revision "1")) + (let ((commit "a177eb911c0e8116e2bfceb79049265a884b701b") + (revision "2")) (package (name "sbcl-local-time") (version (git-version "1.0.6" revision commit)) @@ -4292,16 +4507,10 @@ performance and simplicity in mind.") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 "1r5zq4l1lrgprdr2pw7wwry194yknnllyjf6lx7snypb3k4r3yir")))) + (base32 "0wld28xx20k0ysgg6akic5lg4vkjd0iyhv86m388xfrv8xh87wii")))) (build-system asdf-build-system/sbcl) - (arguments - ;; TODO: Component :STEFIL not found, required by #<SYSTEM - ;; "local-time/test"> - '(#:tests? #f)) (native-inputs - `(("stefil" ,sbcl-hu.dwim.stefil))) - (inputs - `(("sbcl-cl-fad" ,sbcl-cl-fad))) + `(("hu.dwim.stefil" ,sbcl-hu.dwim.stefil))) (home-page "https://common-lisp.net/project/local-time/") (synopsis "Time manipulation library for Common Lisp") (description @@ -4317,8 +4526,8 @@ Long Painful History of Time\".") (sbcl-package->ecl-package sbcl-local-time)) (define-public sbcl-trivial-mimes - (let ((commit "303f8ac0aa6ca0bc139aa3c34822e623c3723fab") - (revision "1")) + (let ((commit "a741fc2f567a4f86b853fd4677d75e62c03e51d9") + (revision "2")) (package (name "sbcl-trivial-mimes") (version (git-version "1.1.0" revision commit)) @@ -4330,7 +4539,7 @@ Long Painful History of Time\".") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 "17jxgl47r695bvsb7wi3n2ws5rp1zzgvw0zii8cy5ggw4b4ayv6m")))) + (base32 "00kcm17q5plpzdj1qwg83ldhxksilgpcdkf3m9azxcdr968xs9di")))) (build-system asdf-build-system/sbcl) (native-inputs `(("stefil" ,sbcl-hu.dwim.stefil))) @@ -4341,7 +4550,7 @@ Long Painful History of Time\".") (description "This is a teensy library that provides some functions to determine the mime-type of a file.") - (license license:artistic2.0)))) + (license license:zlib)))) (define-public cl-trivial-mimes (sbcl-package->cl-source-package sbcl-trivial-mimes)) @@ -4412,8 +4621,8 @@ mime-type of a file.") (sbcl-package->ecl-package sbcl-ningle)) (define-public sbcl-cl-fastcgi - (let ((commit "d576d20eeb12f225201074b28934ba395b15781a") - (revision "1")) + (let ((commit "de8b49b26de9863996ec18db28af8ab7e8ac4e20") + (revision "2")) (package (name "sbcl-cl-fastcgi") (version (git-version "0.2" revision commit)) @@ -4425,7 +4634,7 @@ mime-type of a file.") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 "02mvzzyn0k960s38rbxaqqmdkwcfmyhf8dx6ynz8xyxflmp0s5zv")))) + (base32 "0xgmhx766q4nmrvn5z7ag3ikpr9phlh8ypi8b14azshq9lqbq0m7")))) (build-system asdf-build-system/sbcl) (inputs `(("usocket" ,sbcl-usocket) @@ -4446,8 +4655,6 @@ mime-type of a file.") (description "CL-FastCGI is a generic version of SB-FastCGI, targeting to run on mostly Common Lisp implementation.") - ;; TODO: Upstream on specifies "BSD license": - ;; https://github.com/KDr2/cl-fastcgi/issues/4 (license license:bsd-2)))) (define-public cl-fastcgi @@ -4536,30 +4743,30 @@ theory accurate to internal-time-units-per-second.") (sbcl-package->ecl-package sbcl-cl-log)) (define-public sbcl-log4cl - (let ((commit "611e094458504b938d49de904eab141285328c7c") + (let ((commit "8c48d6f41d3a1475d0a91eed0638b9eecc398e35") (revision "1")) (package (name "sbcl-log4cl") - (build-system asdf-build-system/sbcl) - (version "1.1.2") + (version (git-version "1.1.3" revision commit)) (source (origin (method git-fetch) (uri (git-reference (url "https://github.com/sharplispers/log4cl") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "log4cl" version)) (sha256 - (base32 - "08jly0s0g26b56hhpfizxsb4j0yvbh946sd205gr42dkzv8l7dsc")))) - ;; FIXME: tests require stefil, sbcl-hu.dwim.stefil wont work - (arguments - `(#:tests? #f)) - (inputs `(("bordeaux-threads" ,sbcl-bordeaux-threads))) - (synopsis "Common Lisp logging framework, modeled after Log4J") + (base32 "0166d9aip366pbpdk5gsi2f6xad6q61lssxgbrypa8zslwjn8736")))) + (build-system asdf-build-system/sbcl) + (native-inputs + `(("stefil" ,sbcl-stefil))) + (inputs + `(("bordeaux-threads" ,sbcl-bordeaux-threads))) (home-page "https://github.com/7max/log4cl") - (description "This is a Common Lisp logging framework that can log at -various levels and mix text with expressions.") + (synopsis "Common Lisp logging framework, modeled after Log4J") + (description + "This is a Common Lisp logging framework that can log at various levels +and mix text with expressions.") (license license:asl2.0)))) (define-public cl-log4cl @@ -4568,6 +4775,70 @@ various levels and mix text with expressions.") (define-public ecl-log4cl (sbcl-package->ecl-package sbcl-log4cl)) +(define-public sbcl-printv + (let ((commit "646d31978dbbb460fffb160fd65bb2be9a5a434e") + (revision "1")) + (package + (name "sbcl-printv") + (version (git-version "0.1.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/danlentz/printv") + (commit commit))) + (file-name (git-file-name "printv" version)) + (sha256 + (base32 "08jvy82abm7qi3wrxh6gvmwg9gy0zzhg4cfqajdwrggbah8mj5a6")))) + (build-system asdf-build-system/sbcl) + (home-page "https://github.com/danlentz/printv") + (synopsis "Common Lisp tracing and debug-logging macro") + (description + "@code{PRINTV} is a \"batteries-included\" tracing and debug-logging +macro for Common Lisp.") + (license license:asl2.0)))) + +(define-public ecl-printv + (sbcl-package->ecl-package sbcl-printv)) + +(define-public cl-printv + (sbcl-package->cl-source-package sbcl-printv)) + +(define-public sbcl-verbose + (let ((commit "c5b7ecd465be61b35af17ef57564697b88397174") + (revision "1")) + (package + (name "sbcl-verbose") + (version (git-version "2.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/verbose/") + (commit commit))) + (file-name (git-file-name "verbose" version)) + (sha256 + (base32 "0r51ydj5v7afi2jrlscbhxprv13d9vzg5316g1yzwaxc1kzsdsw6")))) + (build-system asdf-build-system/sbcl) + (inputs + `(("bordeaux-threads" ,sbcl-bordeaux-threads) + ("dissect" ,sbcl-dissect) + ("documentation-utils" ,sbcl-documentation-utils) + ("local-time" ,sbcl-local-time) + ("piping" ,sbcl-piping))) + (home-page "https://shinmera.github.io/verbose/") + (synopsis "Logging framework using the piping library") + (description + "This is a Common Lisp library providing logging faciltiy similar to +@code{CL-LOG} and @code{LOG4CL}.") + (license license:zlib)))) + +(define-public ecl-verbose + (sbcl-package->ecl-package sbcl-verbose)) + +(define-public cl-verbose + (sbcl-package->cl-source-package sbcl-verbose)) + (define-public sbcl-find-port (let ((commit "00c96a25af93a0f8681d34ec548861f2d7485478") (revision "1")) @@ -5555,8 +5826,8 @@ Trivia.") ;;; Split the trivia package in two to work around the circular dependency ;;; between guicho271828/trivia and guicho271828/type-i. (define-public sbcl-trivia.trivial - (let ((commit "37698b47a14c2007630468de7a993694ef7bd475") - (revision "2")) + (let ((commit "7286d5d2a4f685f1cac8370816f95276c0851111") + (revision "3")) (package (name "sbcl-trivia.trivial") (version (git-version "0.0.0" revision commit)) @@ -5569,7 +5840,7 @@ Trivia.") (file-name (git-file-name "trivia" version)) (sha256 (base32 - "0rsbwbw3ipxxgr6zzhci12nilq8zky475kmhz1rcxy4q8a85vn72")))) + "0ln0sj3jry7kzbmxhnin66kpbqan1wp8wwgdbw4k29afbdblkcca")))) (build-system asdf-build-system/sbcl) (inputs `(("alexandria" ,sbcl-alexandria) @@ -6008,8 +6279,8 @@ programming style and the efficiency of an iterative programming style.") (sbcl-package->ecl-package sbcl-series)) (define-public sbcl-periods - (let ((commit "983d4a57325db3c8def942f163133cec5391ec28") - (revision "1")) + (let ((commit "60383dcef88a1ac11f82804ae7a33c361dcd2949") + (revision "2")) (package (name "sbcl-periods") (version (git-version "0.0.2" revision commit)) @@ -6022,7 +6293,7 @@ programming style and the efficiency of an iterative programming style.") (file-name (git-file-name name version)) (sha256 (base32 - "0z30jr3lxz3cmi019fsl4lgcgwf0yqpn95v9zkkkwgymdrkd4lga")))) + "1ym2j4an9ig2hl210jg91gpf7xfnp6mlhkw3n9kkdnwiji3ipqlk")))) (build-system asdf-build-system/sbcl) (inputs `(("local-time" ,sbcl-local-time) @@ -6428,9 +6699,48 @@ ability to store all Common Lisp data types into streams.") (define-public ecl-cl-store (sbcl-package->ecl-package sbcl-cl-store)) +(define-public sbcl-specialization-store + (let ((commit "8d39a866a6f24986aad3cc52349e9cb2653496f3") + (revision "1")) + (package + (name "sbcl-specialization-store") + (version (git-version "0.0.5" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/markcox80/specialization-store") + (commit commit))) + (file-name (git-file-name "specialization-store" version)) + (sha256 + (base32 "0r0bgb46q4gy72l78s7djkxq8ibb4bb3yh9brsry5lih7br8lhi0")))) + (build-system asdf-build-system/sbcl) + (native-inputs + `(("fiveam" ,sbcl-fiveam))) + (inputs + `(("alexandria" ,sbcl-alexandria) + ("introspect-environment" ,sbcl-introspect-environment))) + (home-page "https://github.com/markcox80/specialization-store") + (synopsis "Different type of generic function for Common Lisp") + (description + "SPECIALIZATION-STORE system provides a new kind of function, called +a store function, whose behavior depends on the types of objects passed to the +function.") + (license license:bsd-2)))) + +(define-public ecl-specialization-store + (package + (inherit (sbcl-package->ecl-package sbcl-specialization-store)) + (arguments + ;; TODO: Find why the tests get stuck forever; disable them for now. + `(#:tests? #f)))) + +(define-public cl-specialization-store + (sbcl-package->cl-source-package sbcl-specialization-store)) + (define-public sbcl-cl-gobject-introspection - (let ((commit "7b703e2384945ea0ac39d9b766de434a08d81560") - (revision "0")) + (let ((commit "d0136c8d9ade2560123af1fc55bbf70d2e3db539") + (revision "1")) (package (name "sbcl-cl-gobject-introspection") (version (git-version "0.3" revision commit)) @@ -6444,7 +6754,7 @@ ability to store all Common Lisp data types into streams.") (file-name (git-file-name name version)) (sha256 (base32 - "1zcqd2qj14f6b38vys8gr89s6cijsp9r8j43xa8lynilwva7bwyh")))) + "0dz0r73pq7yhz2iq2jnkq977awx2zws2qfxdcy33329sys1ii32p")))) (build-system asdf-build-system/sbcl) (inputs `(("alexandria" ,sbcl-alexandria) @@ -6456,12 +6766,9 @@ ability to store all Common Lisp data types into streams.") (native-inputs `(("fiveam" ,sbcl-fiveam))) (arguments - ;; TODO: Tests fail, see - ;; https://github.com/andy128k/cl-gobject-introspection/issues/70. - '(#:tests? #f - #:phases + '(#:phases (modify-phases %standard-phases - (add-after (quote unpack) (quote fix-paths) + (add-after 'unpack 'fix-paths (lambda* (#:key inputs #:allow-other-keys) (substitute* "src/init.lisp" (("libgobject-2\\.0\\.so") @@ -6485,6 +6792,42 @@ of C+GObject libraries without the need of writing dedicated bindings.") (define-public ecl-cl-gobject-introspection (sbcl-package->ecl-package sbcl-cl-gobject-introspection)) +(define-public sbcl-cl-slug + (let ((commit "ffb229d10f0d3f7f54e706791725225e200bf749") + (revision "1")) + (package + (name "sbcl-cl-slug") + (version (git-version "0.4.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/EuAndreh/cl-slug") + (commit commit))) + (file-name (git-file-name "cl-slug" version)) + (sha256 + (base32 "1asdq6xllmsvfw5fky9wblqcx9isac9jrrlkfl7vyxcq1wxrnflx")))) + (build-system asdf-build-system/sbcl) + (arguments + `(#:asd-files '("cl-slug-test.asd" "cl-slug.asd") + #:asd-systems '("cl-slug-test" "cl-slug"))) + (native-inputs + `(("prove" ,sbcl-prove))) + (inputs + `(("ppcre" ,sbcl-cl-ppcre))) + (home-page "https://github.com/EuAndreh/cl-slug") + (synopsis "Multi-language slug formater") + (description + "This is a small Common Lisp library to make slugs, mainly for URIs, +from english and beyond.") + (license license:llgpl)))) + +(define-public ecl-cl-slug + (sbcl-package->ecl-package sbcl-cl-slug)) + +(define-public cl-slug + (sbcl-package->cl-source-package sbcl-cl-slug)) + (define-public sbcl-string-case (let ((commit "718c761e33749e297cd2809c7ba3ade1985c49f7") (revision "0")) @@ -6515,6 +6858,34 @@ trees to dispatch on string equality.") (define-public ecl-string-case (sbcl-package->ecl-package sbcl-string-case)) +(define-public sbcl-garbage-pools + (let ((commit "9a7cb7f48b04197c0495df3b6d2e8395ad13f790") + (revision "1")) + (package + (name "sbcl-garbage-pools") + (version (git-version "0.1.2" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/archimag/garbage-pools") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "04jqwr6j138him6wc4nrwjzm4lvyj5j31xqab02nkf8h9hmsf5v1")))) + (build-system asdf-build-system/sbcl) + (home-page "https://github.com/archimag/garbage-pools") + (synopsis "Resource management pools for Common Lisp") + (description "GARBAGE-POOLS is Common Lisp re-implementation of the APR +Pools for resource management.") + (license license:expat)))) + +(define-public ecl-garbage-pools + (sbcl-package->ecl-package sbcl-garbage-pools)) + +(define-public cl-garbage-pools + (sbcl-package->cl-source-package sbcl-garbage-pools)) + (define-public sbcl-global-vars (let ((commit "c749f32c9b606a1457daa47d59630708ac0c266e") (revision "0")) @@ -6623,8 +6994,8 @@ implementation specific equivalent.") (sbcl-package->ecl-package sbcl-trivial-macroexpand-all)) (define-public sbcl-serapeum - (let ((commit "c5e352a9f04a84a93742193c01734f4fb31d9f82") - (revision "3")) + (let ((commit "263f415a350736b44e3878524ff3997e656fca32") + (revision "4")) (package (name "sbcl-serapeum") (version (git-version "0.0.0" revision commit)) @@ -6638,7 +7009,7 @@ implementation specific equivalent.") (file-name (git-file-name name version)) (sha256 (base32 - "16767pxl766c15jznr4srcbp7cnxf8w9lkyaqpp5w5crqymw84nw")))) + "1669yidvxq41s3g6hb2jk21bcb5s2bnfsacpyd5b0hdxbmc7knq3")))) (build-system asdf-build-system/sbcl) (inputs `(("alexandria" ,sbcl-alexandria) @@ -8391,6 +8762,40 @@ respectively.") (define-public ecl-salza2 (sbcl-package->ecl-package sbcl-salza2)) +(define-public sbcl-origin + (let ((commit "d646134302456408d6d43580bb05299f1695ab8e") + (revision "1")) + (package + (name "sbcl-origin") + (version (git-version "2.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://git.mfiano.net/mfiano/origin") + (commit commit))) + (file-name (git-file-name "origin" version)) + (sha256 + (base32 "1n9aszaif3yh8prs5r8v51fbj4r5jd1a048mivd5yij3hplkm82b")))) + (build-system asdf-build-system/sbcl) + (native-inputs + `(("parachute" ,sbcl-parachute))) + (inputs + `(("golden-utils" ,sbcl-golden-utils) + ("specialization-store" ,sbcl-specialization-store))) + (home-page "https://git.mfiano.net/mfiano/origin") + (synopsis "Common Lisp graphics math library") + (description + "This is a native Common Lisp graphics math library with an emphasis on +performance and correctness.") + (license license:expat)))) + +(define-public ecl-origin + (sbcl-package->ecl-package sbcl-origin)) + +(define-public cl-origin + (sbcl-package->cl-source-package sbcl-origin)) + (define-public sbcl-png-read (let ((commit "ec29f38a689972b9f1373f13bbbcd6b05deada88") (revision "1")) @@ -8422,6 +8827,48 @@ respectively.") (define-public ecl-png-read (sbcl-package->ecl-package sbcl-png-read)) +(define-public sbcl-3b-bmfont + (let ((commit "d1b5bec0de580c2d08ec947a93c56b1400f2a37a") + (revision "1")) + (package + (name "sbcl-3b-bmfont") + (version (git-version "0.0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/3b/3b-bmfont/") + (commit commit))) + (file-name (git-file-name "3b-bmfont" version)) + (sha256 + (base32 "12sgf7m0h6fqzhvkas7vmci6mprj3j3fnz778jlbqbsydln6v2yc")))) + (build-system asdf-build-system/sbcl) + (arguments + `(#:asd-systems + '("3b-bmfont" + "3b-bmfont/text" + "3b-bmfont/common" + "3b-bmfont/xml" + "3b-bmfont/json"))) + (inputs + `(("alexandria" ,sbcl-alexandria) + ("cxml" ,sbcl-cxml) + ("flexi-streams" ,sbcl-flexi-streams) + ("jsown" ,sbcl-jsown) + ("split-sequence" ,sbcl-split-sequence))) + (home-page "https://github.com/3b/3b-bmfont/") + (synopsis "Read/write bmfont metadata files") + (description + "This is a Common Lisp library which provides functionality to +read/write Bit Map Font (BMF) into text, JSON and XML.") + (license license:expat)))) + +(define-public ecl-3b-bmfont + (sbcl-package->ecl-package sbcl-3b-bmfont)) + +(define-public cl-3b-bmfont + (sbcl-package->cl-source-package sbcl-3b-bmfont)) + (define-public sbcl-zpng (package (name "sbcl-zpng") @@ -9072,40 +9519,56 @@ approach to templating.") (sbcl-package->ecl-package sbcl-cl-mysql)) (define-public sbcl-postmodern - (let ((commit "74469b25bbda990ec9b77e0d0eccdba0cd7e721a") - (revision "1")) - (package - (name "sbcl-postmodern") - (version (git-version "1.19" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/marijnh/Postmodern") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "0im7ymnyxjhn2w74jfg76k5gpr0gl33n31akx33hl28722ljd0hd")))) - (build-system asdf-build-system/sbcl) - (native-inputs - `(("fiveam" ,sbcl-fiveam))) - (inputs - `(("alexandria" ,sbcl-alexandria) - ("bordeaux-threads" ,sbcl-bordeaux-threads) - ("closer-mop" ,sbcl-closer-mop) - ("global-vars" ,sbcl-global-vars) - ("md5" ,sbcl-md5) - ("split-sequence" ,sbcl-split-sequence) - ("usocket" ,sbcl-usocket))) - (arguments - ;; TODO: Fix missing dependency errors for simple-date/postgres-glue, - ;; cl-postgres/tests and s-sql/tests. - `(#:tests? #f - #:asd-systems '("postmodern" - "simple-date/postgres-glue"))) - (synopsis "Common Lisp library for interacting with PostgreSQL") - (description - "@code{postmodern} is a Common Lisp library for interacting with + (package + (name "sbcl-postmodern") + (version "1.32.8") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/marijnh/Postmodern") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0vr5inbr8dldf6dsl0qj3h2yrnnsayzfwxfzwkn1pk7xbns2l78q")))) + (build-system asdf-build-system/sbcl) + (native-inputs + `(("fiveam" ,sbcl-fiveam))) + (inputs + `(("alexandria" ,sbcl-alexandria) + ("bordeaux-threads" ,sbcl-bordeaux-threads) + ("cl-base64" ,sbcl-cl-base64) + ("cl-unicode" ,sbcl-cl-unicode) + ("closer-mop" ,sbcl-closer-mop) + ("global-vars" ,sbcl-global-vars) + ("ironclad" ,sbcl-ironclad) + ("local-time" ,sbcl-local-time) + ("md5" ,sbcl-md5) + ("split-sequence" ,sbcl-split-sequence) + ("uax-15" ,sbcl-uax-15) + ("usocket" ,sbcl-usocket))) + (arguments + ;; TODO: (Sharlatan-20210114T171037+0000) tests still failing but on other + ;; step, some functionality in `local-time' prevents passing tests. + ;; Error: + ;; + ;; Can't create directory + ;; /gnu/store + ;; /4f47agf1kyiz057ppy6x5p98i7mcbfsv-sbcl-local-time-1.0.6-2.a177eb9 + ;; /lib/common-lisp/sbcl/local-time/src/integration/ + ;; + ;; NOTE: (Sharlatan-20210124T191940+0000): When set env HOME to /tmp above + ;; issue is resolved but it required live test database to connect to now. + ;; Keep tests switched off. + `(#:tests? #f + #:asd-systems '("cl-postgres" + "s-sql" + "postmodern" + "simple-date" + "simple-date/postgres-glue"))) + (synopsis "Common Lisp library for interacting with PostgreSQL") + (description + "@code{postmodern} is a Common Lisp library for interacting with PostgreSQL databases. It provides the following features: @itemize @@ -9115,9 +9578,27 @@ foreign libraries. @item A syntax for mixing SQL and Lisp code. @item Convenient support for prepared statements and stored procedures. @item A metaclass for simple database-access objects. -@end itemize\n") - (home-page "https://marijnhaverbeke.nl/postmodern/") - (license license:zlib)))) +@end itemize\n + +This package produces 4 systems: postmodern, cl-postgres, s-sql, simple-date + +@code{SIMPLE-DATE} is a very basic implementation of date and time objects, used +to support storing and retrieving time-related SQL types. It is not loaded by +default and you can use local-time (which has support for timezones) instead. + +@code{S-SQL} is used to compile s-expressions to strings of SQL code, escaping +any Lisp values inside, and doing as much as possible of the work at compile +time. + +@code{CL-POSTGRES} is the low-level library used for interfacing with a PostgreSQL +server over a socket. + +@code{POSTMODERN} itself is a wrapper around these packages and provides higher +level functions, a very simple data access object that can be mapped directly to +database tables and some convient utilities. It then tries to put all these +things together into a convenient programming interface") + (home-page "https://marijnhaverbeke.nl/postmodern/") + (license license:zlib))) (define-public cl-postmodern (sbcl-package->cl-source-package sbcl-postmodern)) @@ -9127,17 +9608,49 @@ foreign libraries. (inherit (sbcl-package->ecl-package sbcl-postmodern)) (arguments `(#:tests? #f - #:asd-systems '("postmodern" + #:asd-systems '("cl-postgres" + "s-sql" + "postmodern" + "simple-date" "simple-date/postgres-glue") #:phases (modify-phases %standard-phases (add-after 'unpack 'fix-build (lambda _ (substitute* "cl-postgres.asd" - (("\\) \"usocket\"") - " :ecl) \"usocket\"")) + ((":or :sbcl :allegro :ccl :clisp" all) + (string-append all " :ecl"))) #t))))))) +(define-public sbcl-db3 + (let ((commit "38e5ad35f025769fb7f8dcdc6e56df3e8efd8e6d") + (revision "1")) + (package + (name "sbcl-db3") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/dimitri/cl-db3") + (commit commit))) + (file-name (git-file-name "cl-db3" version)) + (sha256 + (base32 "1i7j0mlri6kbklcx1lsm464s8kmyhhij5c4xh4aybrw8m4ixn1s5")))) + (build-system asdf-build-system/sbcl) + (home-page "https://github.com/dimitri/cl-db3") + (synopsis "Common Lisp library to read dBase III database files") + (description + "This is a Common Lisp library for processing data found in dBase III +database files (dbf and db3 files).") + (license license:public-domain)))) + +(define-public ecl-db3 + (sbcl-package->ecl-package sbcl-db3)) + +(define-public cl-db3 + (sbcl-package->cl-source-package sbcl-db3)) + (define-public sbcl-dbi ;; Master includes a breaking change which other packages depend on since ;; Quicklisp decided to follow it: @@ -9522,6 +10035,115 @@ PascalCase, snake_case, param-case, CONSTANT_CASE and more.") (define-public ecl-cl-change-case (sbcl-package->ecl-package sbcl-cl-change-case)) +(define-public sbcl-modularize + (let ((commit "86c5d9a11fbd2df9f0f03ac10b5d71837c8934ba") + (revision "1")) + (package + (name "sbcl-modularize") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/modularize") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1zys29rfkb649rkgl3snxhajk8d5yf7ryxkrwy020kwdh7zdsg7d")))) + (build-system asdf-build-system/sbcl) + (arguments + `(#:test-asd-file "modularize-test-module.asd" + #:asd-files '("modularize.asd" "modularize-test-module.asd") + #:asd-systems '("modularize" "modularize-test-module"))) + (inputs + `(("documentation-utils" ,sbcl-documentation-utils) + ("trivial-package-local-nicknames" ,sbcl-trivial-package-local-nicknames))) + (home-page "https://shinmera.github.io/modularize/") + (synopsis "Common Lisp modularization framework") + (description + "@code{MODULARIZE} is an attempt at providing a common interface to +segregate major application components. This is achieved by adding special +treatment to packages. Each module is a package that is specially registered, +which allows it to interact and co-exist with other modules in better ways. For +instance, by adding module definition options you can introduce mechanisms to +tie modules together in functionality, hook into each other and so on.") + (license license:zlib)))) + +(define-public ecl-modularize + (sbcl-package->ecl-package sbcl-modularize)) + +(define-public cl-modularize + (sbcl-package->cl-source-package sbcl-modularize)) + +(define-public sbcl-modularize-hooks + (let ((commit "e0348ed3ffd59a9ec31ca4ab28289e748bfbf96a") + (revision "1")) + (package + (name "sbcl-modularize-hooks") + (version (git-version "1.0.2" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/modularize-hooks") + (commit commit))) + (file-name (git-file-name "modularize-hooks" version)) + (sha256 + (base32 "12kjvin8hxidwkzfb7inqv5b6g5qzcssnj9wc497v2ixc56fqdz7")))) + (build-system asdf-build-system/sbcl) + (inputs + `(("closer-mop" ,sbcl-closer-mop) + ("lambda-fiddle" ,sbcl-lambda-fiddle) + ("modularize" ,sbcl-modularize) + ("trivial-arguments" ,sbcl-trivial-arguments))) + (home-page "https://shinmera.github.io/modularize-hooks/") + (synopsis "Generic hooks and triggers extension for Modularize") + (description + "This is a simple extension to @code{MODULARIZE} that allows modules to +define and trigger hooks, which other modules can hook on to.") + (license license:zlib)))) + +(define-public ecl-modularize-hooks + (sbcl-package->ecl-package sbcl-modularize-hooks)) + +(define-public cl-modularize-hooks + (sbcl-package->cl-source-package sbcl-modularize-hooks)) + +(define-public sbcl-modularize-interfaces + (let ((commit "96353657afb8c7aeba7ef5b51eb04c5ed3bcb6ef") + (revision "1")) + (package + (name "sbcl-modularize-interfaces") + (version (git-version "0.9.3" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/modularize-interfaces") + (commit commit))) + (file-name (git-file-name "modularize-interfaces" version)) + (sha256 + (base32 "0bjf4wy39cwf75m7vh0r7mmcchs09yz2lrbyap98hnq8blq70fhc")))) + (build-system asdf-build-system/sbcl) + (inputs + `(("lambda-fiddle" ,sbcl-lambda-fiddle) + ("modularize" ,sbcl-modularize) + ("trivial-arguments" ,sbcl-trivial-arguments) + ("trivial-indent" ,sbcl-trivial-indent))) + (home-page "https://shinmera.github.io/modularize-interfaces/") + (synopsis "Programmatical interfaces extension for Modularize") + (description + "This is an extension to @code{MODULARIZE} that allows your application +to define interfaces in-code that serve both as a primary documentation and as +compliance control.") + (license license:zlib)))) + +(define-public ecl-modularize-interfaces + (sbcl-package->ecl-package sbcl-modularize-interfaces)) + +(define-public cl-modularize-interfaces + (sbcl-package->cl-source-package sbcl-modularize-interfaces)) + (define-public sbcl-moptilities (let ((commit "a436f16b357c96b82397ec018ea469574c10dd41")) (package @@ -10118,8 +10740,8 @@ format.") (sbcl-package->ecl-package sbcl-cl-libsvm-format)) (define-public sbcl-cl-online-learning - (let ((commit "fc7a34f4f161cd1c7dd747d2ed8f698947781423") - (revision "0")) + (let ((commit "87fbef8a340219e853adb3a5bf44a0470da76964") + (revision "1")) (package (name "sbcl-cl-online-learning") (version (git-version "0.5" revision commit)) @@ -10129,10 +10751,10 @@ format.") (uri (git-reference (url "https://github.com/masatoi/cl-online-learning") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-online-learning" version)) (sha256 (base32 - "14x95rlg80ay5hv645ki57pqvy12v28hz4k1w0f6bsfi2rmpxchq")))) + "1lfq04lnxivx59nq5dd02glyqsqzf3vdn4s9b8wnaln5fs8g2ph9")))) (build-system asdf-build-system/sbcl) (native-inputs `(("prove" ,sbcl-prove))) @@ -10140,13 +10762,14 @@ format.") `(("cl-libsvm-format" ,sbcl-cl-libsvm-format) ("cl-store" ,sbcl-cl-store))) (arguments - `(;; FIXME: Tests pass but then the check phase crashes - #:tests? #f)) + `(#:test-asd-file "cl-online-learning-test.asd" + #:asd-systems '("cl-online-learning-test" + "cl-online-learning"))) + (home-page "https://github.com/masatoi/cl-online-learning") (synopsis "Online Machine Learning for Common Lisp") (description "This library contains a collection of machine learning algorithms for online linear classification written in Common Lisp.") - (home-page "https://github.com/masatoi/cl-online-learning") (license license:expat)))) (define-public cl-online-learning @@ -10155,6 +10778,121 @@ online linear classification written in Common Lisp.") (define-public ecl-cl-online-learning (sbcl-package->ecl-package sbcl-cl-online-learning)) +(define-public sbcl-cl-mpg123 + (let ((commit "5f042c839d2ea4a2ff2a7b60c839d8633d64161d") + (revision "1")) + (package + (name "sbcl-cl-mpg123") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shirakumo/cl-mpg123") + (commit commit))) + (file-name (git-file-name "cl-mpg123" version)) + (sha256 + (base32 "1hl721xaczxck008ax2y3jpkm509ry1sg3lklh2k76764m3ndrjf")) + (modules '((guix build utils))) + (snippet + '(begin + ;; Remove bundled pre-compiled libraries. + (delete-file-recursively "static") + #t)))) + (build-system asdf-build-system/sbcl) + (arguments + `(#:asd-files '("cl-mpg123.asd" "cl-mpg123-example.asd") + #:asd-systems '("cl-mpg123" "cl-mpg123-example") + #:phases + (modify-phases %standard-phases + (add-after 'unpack 'fix-paths + (lambda* (#:key inputs #:allow-other-keys) + (substitute* "low-level.lisp" + (("libmpg123.so" all) + (string-append (assoc-ref inputs "libmpg123") + "/lib/" all)))))))) + (inputs + `(("cffi" ,sbcl-cffi) + ("cl-out123" ,sbcl-cl-out123) + ("documentation-utils" ,sbcl-documentation-utils) + ("libmpg123" ,mpg123) + ("trivial-features" ,sbcl-trivial-features) + ("trivial-garbage" ,sbcl-trivial-garbage) + ("verbose" ,sbcl-verbose))) + (home-page "https://shirakumo.github.io/cl-mpg123/") + (synopsis "Common Lisp bindings to libmpg123") + (description + "This is a bindings and wrapper library to @code{libmpg123} allowing for +convenient, extensive, and fast decoding of MPEG1/2/3 (most prominently mp3) +files.") + (license license:zlib)))) + +(define-public ecl-cl-mpg123 + (sbcl-package->ecl-package sbcl-cl-mpg123)) + +(define-public cl-mpg123 + (sbcl-package->cl-source-package sbcl-cl-mpg123)) + +(define-public sbcl-cl-out123 + (let ((commit "6b58d3f8c2a28ad09059ac4c60fb3c781b9b421b") + (revision "1")) + (package + (name "sbcl-cl-out123") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shirakumo/cl-out123") + (commit commit))) + (file-name (git-file-name "cl-out123" version)) + (sha256 + (base32 "0mdwgfax6sq68wvdgjjp78i40ah7wqkpqnvaq8a1c509k7ghdgv1")) + (modules '((guix build utils))) + (snippet + '(begin + ;; Remove bundled pre-compiled libraries. + (delete-file-recursively "static") + #t)))) + (build-system asdf-build-system/sbcl) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'fix-paths + (lambda* (#:key inputs #:allow-other-keys) + (substitute* "low-level.lisp" + (("libout123.so" all) + (string-append (assoc-ref inputs "libout123") + "/lib/" all))))) + ;; NOTE: (Sharlatan-20210129T134529+0000): ECL package `ext' has no + ;; exported macro `without-interrupts' it's moved to `mp' package + ;; https://github.com/Shirakumo/cl-out123/issues/2 + ;; https://gitlab.com/embeddable-common-lisp/ecl/-/blob/develop/src/lsp/mp.lsp + (add-after 'unpack 'fix-ecl-package-name + (lambda _ + (substitute* "wrapper.lisp" + (("ext:without-interrupts.*") "mp:without-interrupts\n")) + #t))))) + (inputs + `(("bordeaux-threads" ,sbcl-bordeaux-threads) + ("cffi" ,sbcl-cffi) + ("documentation-utils" ,sbcl-documentation-utils) + ("libout123" ,mpg123) + ("trivial-features" ,sbcl-trivial-features) + ("trivial-garbage" ,sbcl-trivial-garbage))) + (home-page "https://shirakumo.github.io/cl-out123/") + (synopsis "Common Lisp bindings to libout123") + (description + "This is a bindings library to @code{libout123} which allows easy +cross-platform audio playback.") + (license license:zlib)))) + +(define-public ecl-cl-out123 + (sbcl-package->ecl-package sbcl-cl-out123)) + +(define-public cl-out123 + (sbcl-package->cl-source-package sbcl-cl-out123)) + (define-public sbcl-cl-random-forest (let ((commit "fedb36ce99bb6f4d7e3a7dd6d8b058f331308f91") (revision "1")) @@ -10532,8 +11270,8 @@ than a few Kb.") (sbcl-package->ecl-package sbcl-mmap)) (define-public sbcl-3bz - (let ((commit "d6119083b5e0b0a6dd3abc2877936c51f3f3deed") - (revision "0")) + (let ((commit "569614c40408f3aefc77ba233e0e4bd66d3850ad") + (revision "1")) (package (name "sbcl-3bz") (version (git-version "0.0.0" revision commit)) @@ -10545,7 +11283,7 @@ than a few Kb.") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 "0fyxzyf2b6sc0w8d9g4nlva861565z6f3xszj0lw29x526dd9rhj")))) + (base32 "0kvvlvf50jhhw1s510f3clpr1a68632bq6d698yxcrx722igcrg4")))) (build-system asdf-build-system/sbcl) (inputs `(("alexandria" ,sbcl-alexandria) @@ -10555,7 +11293,7 @@ than a few Kb.") ("nibbles" ,sbcl-nibbles) ("trivial-features" ,sbcl-trivial-features))) (arguments - ;; FIXME: Without the following line, the build fails (see issue 41437). + ;; FIXME: #41437 - Build fails when package name starts from a digit `(#:asd-systems '("3bz"))) (home-page "https://github.com/3b/3bz") (synopsis "Deflate decompression for Common Lisp") @@ -10682,8 +11420,8 @@ and saving 2-dimensional pixel-based images.") (sbcl-package->ecl-package sbcl-opticl)) (define-public sbcl-mcclim - (let ((commit "27b4d7a667c9b3faa74cabcb57706b888314fff7") - (revision "0")) + (let ((commit "04cc542dd4b461b9d56406e40681d1a8f080730f") + (revision "1")) (package (name "sbcl-mcclim") (version (git-version "0.9.7" revision commit)) @@ -10695,7 +11433,7 @@ and saving 2-dimensional pixel-based images.") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 "0jijfgkwas6xnpp5wiii6slcx9pgsalngacb8zm29x6pamx2193h")))) + (base32 "1xjly8i62z72hfhlnz5kjd9i8xhrwckc7avyizxvhih67pkjmsx0")))) (build-system asdf-build-system/sbcl) (native-inputs `(("fiveam" ,sbcl-fiveam) @@ -10806,6 +11544,43 @@ Inflector module.") (define-public ecl-cl-inflector (sbcl-package->ecl-package sbcl-cl-inflector)) +(define-public sbcl-ixf + (let ((commit "ed26f87e4127e4a9e3aac4ff1e60d1f39cca5183") + (revision "1")) + (package + (name "sbcl-ixf") + (version (git-version "0.1.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/dimitri/cl-ixf") + (commit commit))) + (file-name (git-file-name "cl-ixf" version)) + (sha256 + (base32 "1wjdnf4vr9z7lcfc49kl43g6l2i23q9n81siy494k17d766cdvqa")))) + (build-system asdf-build-system/sbcl) + (inputs + `(("alexandria" ,sbcl-alexandria) + ("babel" ,sbcl-babel) + ("cl-ppcre" ,sbcl-cl-ppcre) + ("ieee-floats" ,sbcl-ieee-floats) + ("local-time" ,sbcl-local-time) + ("md5" ,sbcl-md5) + ("split-sequence" ,sbcl-split-sequence))) + (home-page "https://github.com/dimitri/cl-ixf") + (synopsis "Parse IBM IXF file format") + (description + "This is a Common Lisp library to handle the IBM PC version of the IXF +(Integration Exchange Format) file format.") + (license license:public-domain)))) + +(define-public ecl-ixf + (sbcl-package->ecl-package sbcl-ixf)) + +(define-public cl-ixf + (sbcl-package->cl-source-package sbcl-ixf)) + (define-public sbcl-qbase64 (package (name "sbcl-qbase64") @@ -10967,34 +11742,36 @@ hu.dwim systems.") (sbcl-package->ecl-package sbcl-hu.dwim.common)) (define-public sbcl-hu.dwim.defclass-star - (package - (name "sbcl-hu.dwim.defclass-star") - (version "2015-07-09") - (source - (origin - (method url-fetch) - (uri (string-append - "http://beta.quicklisp.org/archive/hu.dwim.defclass-star/" - version "/hu.dwim.defclass-star-" - (string-replace-substring version "-" "") - "-darcs.tgz")) - (sha256 - (base32 "032982lyp0hm0ssxlyh572whi2hr4j1nqkyqlllaj373v0dbs3vs")))) - (build-system asdf-build-system/sbcl) - (native-inputs - `(;; These 2 inputs are only needed tests which are disabled, see below. - ;; ("hu.dwim.common" ,sbcl-hu.dwim.common) - ;; Need cl- package for the :hu.dwim.stefil+hu.dwim.def+swank system. - ;; ("hu.dwim.stefil" ,cl-hu.dwim.stefil) - ("hu.dwim.asdf" ,sbcl-hu.dwim.asdf))) - (arguments - `(#:test-asd-file "hu.dwim.defclass-star.test.asd" - ;; Tests require a circular dependency: hu.dwim.stefil -> hu.dwim.def - ;; -> hu.dwim.util -> hu.dwim.defclass-star. - #:tests? #f)) - (home-page "http://dwim.hu/?_x=dfxn&_f=mRIMfonK") - (synopsis "Simplify definitions with defclass* and friends in Common Lisp") - (description "@code{defclass-star} provides defclass* and defcondition* to + (let ((commit "39d458f1b1bc830d1f5e18a6a35bf0e96a2cfd61")) + (package + (name "sbcl-hu.dwim.defclass-star") + ;; We used to set version from the date when it was a darcs repo, so we + ;; keep the year so that package gets updated on previous installs. + (version (git-version "2021" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/hu-dwim/hu.dwim.defclass-star") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0hfkq2wad98vkyxdg1wh18y86d9w9yqkm8lxkk96szvpwymm7lmq")))) + (build-system asdf-build-system/sbcl) + (native-inputs + `( ;; These 2 inputs are only needed tests which are disabled, see below. + ;; ("hu.dwim.common" ,sbcl-hu.dwim.common) + ;; Need cl- package for the :hu.dwim.stefil+hu.dwim.def+swank system. + ;; ("hu.dwim.stefil" ,cl-hu.dwim.stefil) + ("hu.dwim.asdf" ,sbcl-hu.dwim.asdf))) + (arguments + `(#:test-asd-file "hu.dwim.defclass-star.test.asd" + ;; Tests require a circular dependency: hu.dwim.stefil -> hu.dwim.def + ;; -> hu.dwim.util -> hu.dwim.defclass-star. + #:tests? #f)) + (home-page "https://github.com/hu-dwim/hu.dwim.defclass-star") + (synopsis "Simplify definitions with defclass* and friends in Common Lisp") + (description "@code{defclass-star} provides defclass* and defcondition* to simplify class and condition declarations. Features include: @itemize @@ -11008,7 +11785,7 @@ simplify class and condition declarations. Features include: See @url{https://common-lisp.net/project/defclass-star/configuration.lisp.html} for an example.") - (license license:public-domain))) + (license license:public-domain)))) (define-public cl-hu.dwim.defclass-star (sbcl-package->cl-source-package sbcl-hu.dwim.defclass-star)) @@ -11696,11 +12473,11 @@ collecting values easier.") (base32 "18r3wfarr7lgn78m6c66r0r9aazirv07gy7xgvqkl9pmrz1bc47m")))) (build-system asdf-build-system/sbcl) - (propagated-inputs - `(("alexandria" ,cl-alexandria) - ("anaphora" ,cl-anaphora) - ("collectors" ,cl-collectors) - ("optima" ,cl-optima))) + (inputs + `(("alexandria" ,sbcl-alexandria) + ("anaphora" ,sbcl-anaphora) + ("collectors" ,sbcl-collectors) + ("optima" ,sbcl-optima))) (native-inputs `(("prove" ,sbcl-prove))) (home-page "https://github.com/alex-gutev/cl-environments") @@ -11719,56 +12496,35 @@ CLTL2 environment access API.") (sbcl-package->ecl-package sbcl-cl-environments)) (define-public sbcl-static-dispatch - (package - (name "sbcl-static-dispatch") - (version "0.3") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/alex-gutev/static-dispatch") - (commit (string-append "v" version)))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1wp5yz8liqqic3yifqf33qhccd755pd7ycvsq1j4i7k3f1wm18i0")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("agutil" ,sbcl-agutil) - ("alexandria" ,sbcl-alexandria) - ("anaphora" ,sbcl-anaphora) - ("arrows" ,sbcl-arrows) - ("closer-mop" ,sbcl-closer-mop) - ("iterate" ,sbcl-iterate) - ("trivia" ,sbcl-trivia))) - (propagated-inputs - ;; FIXME: `sbcl-cl-environments' input fails with - ;; - ;; compiling #<CL-SOURCE-FILE "collectors" "collectors"> - ;; Unhandled SB-INT:SIMPLE-FILE-ERROR in thread #<SB-THREAD:THREAD "main thread" RUNNING - ;; {1008238213}>: - ;; Error opening #P"/.../cl-environments/src/common/package-tmp5GEXGEG5.fasl": - ;; Permission denied - `(("cl-environments" ,cl-environments))) - (native-inputs - `(("prove" ,sbcl-prove))) - (arguments - `(#:phases - (modify-phases %standard-phases - ;; Use `arrows' instead of cl-arrows which is abandoned and unlicensed. - ;; https://github.com/nightfly19/cl-arrows/issues/5 - (add-after 'unpack 'use-arrows-instead-of-cl-arrows - (lambda _ - (for-each - (lambda (file) - (substitute* file - ((":cl-arrows") ":arrows"))) - '("static-dispatch.asd" - "src/package.lisp" - "test/methods.lisp" - "test/test.lisp"))))))) - (home-page "https://github.com/alex-gutev/static-dispatch") - (synopsis "Static generic function dispatch for Common Lisp") - (description "Static dispatch is a Common Lisp library, inspired by + (let ((commit "6243afcd152854c52ba33daef7394367b657d9c6") + (revision "1")) + (package + (name "sbcl-static-dispatch") + (version (git-version "0.3" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/alex-gutev/static-dispatch") + (commit commit))) + (file-name (git-file-name "static-dispatch" version)) + (sha256 + (base32 "1lli9ar1xbnhkgb5d01rlw4pvfylg2arrw68np2c07fpkkafimg7")))) + (build-system asdf-build-system/sbcl) + (native-inputs + `(("prove" ,sbcl-prove))) + (inputs + `(("agutil" ,sbcl-agutil) + ("alexandria" ,sbcl-alexandria) + ("anaphora" ,sbcl-anaphora) + ("arrows" ,sbcl-arrows) + ("cl-environments" ,sbcl-cl-environments) + ("closer-mop" ,sbcl-closer-mop) + ("iterate" ,sbcl-iterate) + ("trivia" ,sbcl-trivia))) + (home-page "https://github.com/alex-gutev/static-dispatch") + (synopsis "Static generic function dispatch for Common Lisp") + (description "Static dispatch is a Common Lisp library, inspired by @code{inlined-generic-function}, which allows standard Common Lisp generic function dispatch to be performed statically (at compile time) rather than dynamically (runtime). This is similar to what is known as \"overloading\" in @@ -11780,7 +12536,7 @@ functions, such as adding/removing methods at runtime are not required. An example of such a case is a generic equality comparison function. Currently generic functions are considered far too slow to implement generic arithmetic and comparison operations when used heavily in numeric code.") - (license license:expat))) + (license license:expat)))) (define-public cl-static-dispatch (sbcl-package->cl-source-package sbcl-static-dispatch)) @@ -11811,10 +12567,8 @@ and comparison operations when used heavily in numeric code.") ("anaphora" ,sbcl-anaphora) ("arrows" ,sbcl-arrows) ("cl-custom-hash-table" ,sbcl-custom-hash-table) + ("static-dispatch" ,sbcl-static-dispatch) ("trivia" ,sbcl-trivia))) - (propagated-inputs - ;; FIXME: Same error as for `sbcl-static-dispatch'. - `(("static-dispatch" ,cl-static-dispatch))) (native-inputs `(("prove" ,sbcl-prove))) (arguments @@ -11868,9 +12622,8 @@ predictable cross-platform behavior and some utilities useful for versioning.") (sbcl-package->ecl-package sbcl-defpackage-plus)) (define-public sbcl-deploy - ;; tagged branch is outdated - (let ((revision "1") - (commit "59fd49719ef651a8fc11750bcfb337f132cff75f")) + (let ((commit "9b20e64fe924b9e31832304d87a3a72c383dc6d8") + (revision "2")) (package (name "sbcl-deploy") (version (git-version "1.0.0" revision commit)) @@ -11880,15 +12633,21 @@ predictable cross-platform behavior and some utilities useful for versioning.") (uri (git-reference (url "https://github.com/Shinmera/deploy") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "deploy" version)) (sha256 - (base32 "1vl2116z4kw2pd3qd3n6mmg8g0mnwxr9dgddk86g7j1bis1z8k9a")))) + (base32 "07pfkibaridihg8lbq2czwa4iqifqk24n6rx7bfnv7i49p1ppja1")))) (build-system asdf-build-system/sbcl) + (arguments + `(#:test-asd-file "deploy-test.asd" + #:asd-files '("deploy.asd" + "deploy-test.asd"))) + (native-inputs + `(("cl-mpg123" ,sbcl-cl-mpg123) + ("cl-out123" ,sbcl-cl-out123))) (inputs `(("cffi" ,sbcl-cffi) - ("documentation-utils" ,sbcl-documentation-utils))) - (arguments - '(#:asd-files '("deploy.asd"))) + ("documentation-utils" ,sbcl-documentation-utils) + ("trivial-features" ,sbcl-trivial-features))) (home-page "https://shinmera.github.io/deploy/") (synopsis "Deployment tools for standalone Common Lisp application") (description @@ -11995,6 +12754,77 @@ package.") (define-public ecl-claw-support (sbcl-package->ecl-package sbcl-claw-support)) +(define-public sbcl-claw + (let ((revision "0") + (commit "3cd4a96fca95eb9e8d5d069426694669f81b2250")) + (package + (name "sbcl-claw") + (version (git-version "1.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/borodust/claw") + (commit commit))) + (file-name (git-file-name "claw" version)) + (sha256 + (base32 "146yv0hc4hmk72562ssj2d41143pp84dcbd1h7f4nx1c7hf2bb0d")))) + (build-system asdf-build-system/sbcl) + (inputs + `(("alexandria" ,sbcl-alexandria) + ("cffi" ,sbcl-cffi) + ("cl-json" ,sbcl-cl-json) + ("cl-ppcre" ,sbcl-cl-ppcre) + ("claw-support" ,sbcl-claw-support) + ("local-time" ,sbcl-local-time) + ("trivial-features" ,sbcl-trivial-features))) + (home-page "https://github.com/borodust/claw") + (synopsis "Autowrapper for Common Lisp") + (description + "This is a Common Lisp autowrapping facility for quickly creating clean +and lean bindings to C libraries.") + (license license:bsd-2)))) + +(define-public cl-claw + (sbcl-package->cl-source-package sbcl-claw)) + +(define-public ecl-claw + (sbcl-package->ecl-package sbcl-claw)) + +(define-public sbcl-claw-utils + (let ((revision "0") + (commit "efe25016501973dc369f067a64c7d225802bc56f")) + (package + (name "sbcl-claw-utils") + ;; version is not specified + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/borodust/claw-utils") + (commit commit))) + (file-name (git-file-name "claw-utils" version)) + (sha256 + (base32 "01df3kyf2qs3czi332dnz2s35x2j0fq46vgmsw7wjrrvnqc22mk5")))) + (build-system asdf-build-system/sbcl) + (inputs + `(("alexandria" ,sbcl-alexandria) + ("cffi" ,sbcl-cffi) + ("claw" ,sbcl-claw))) + (home-page "https://github.com/borodust/claw-utils") + (synopsis "Utilities for easier autowrapping") + (description + "This Common Lisp library contains various handy utilties to help +autowrapping with @code{claw}.") + (license license:expat)))) + +(define-public cl-claw-utils + (sbcl-package->cl-source-package sbcl-claw-utils)) + +(define-public ecl-claw-utils + (sbcl-package->ecl-package sbcl-claw-utils)) + (define-public sbcl-array-operations (let ((commit "75cbc3b1adb2e3ce2109489753d0f290b071e81b") (revision "0")) @@ -12743,3 +13573,704 @@ compression/decompression using bindings to the libzstd C library.") (define-public ecl-zstd (sbcl-package->ecl-package sbcl-zstd)) + +(define-public sbcl-agnostic-lizard + (let ((commit "fe3a73719f05901c8819f8995a3ebae738257952") + (revision "1")) + (package + (name "sbcl-agnostic-lizard") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://gitlab.common-lisp.net/mraskin/agnostic-lizard") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0ax78y8w4zlp5dcwyhz2nq7j3shi49qn31dkfg8lv2jlg7mkwh2d")))) + (build-system asdf-build-system/sbcl) + (synopsis "Almost correct portable code walker for Common Lisp") + (description + "Agnostic Lizard is a portable implementation of a code walker and in +particular of the macroexpand-all function (and macro) that makes a best +effort to be correct while not expecting much beyond what the Common Lisp +standard requires. + +It aims to be implementation-agnostic and to climb the syntax trees.") + (home-page "https://gitlab.common-lisp.net/mraskin/agnostic-lizard") + (license license:gpl3+)))) + +(define-public cl-agnostic-lizard + (sbcl-package->cl-source-package sbcl-agnostic-lizard)) + +(define-public ecl-agnostic-lizard + (sbcl-package->ecl-package sbcl-agnostic-lizard)) + +(define-public sbcl-dynamic-classes + (package + (name "sbcl-dynamic-classes") + (version "1.0.2") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/gwkkwg/dynamic-classes") + (commit (string-append "version-" version)))) + (file-name (git-file-name "dynamic-classes" version)) + (sha256 + (base32 "1z3ag6w4ff0v6715xa9zhvwjqnp4i6zrjfmxdz8m115sklbwgm6c")))) + (build-system asdf-build-system/sbcl) + (inputs + `(("metatilities-base" ,sbcl-metatilities-base))) + (arguments + ;; NOTE: (Sharlatan-20210106222900+0000) Circular dependencies and failing + ;; test suites. lift-standard.config contains referances to deprecated + ;; functionality. + `(#:tests? #f)) + (home-page "https://common-lisp.net/project/dynamic-classes/") + (synopsis "Dynamic class definition for Common Lisp") + (description "Dynamic-Classes helps to ease the prototyping process by +bringing dynamism to class definition.") + (license license:expat))) + +(define-public ecl-dynamic-classes + (sbcl-package->ecl-package sbcl-dynamic-classes)) + +(define-public cl-dynamic-classes + (sbcl-package->cl-source-package sbcl-dynamic-classes)) + +(define-public sbcl-cl-markdown + ;; NOTE: (Sharlatan-20210106214629+0000) latest version tag + ;; "version-0.10.6_version-0.10.6" is failing to build due to missing system + ;; #:container-dynamic-classes + (package + (name "sbcl-cl-markdown") + (version "0.10.4") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/gwkkwg/cl-markdown") + (commit (string-append "version-" version)))) + (file-name (git-file-name "cl-markdown" version)) + (sha256 + (base32 "1wdjbdd1zyskxf7zlilcp6fmwkivybj0wjp64vvzb265d5xi7p8p")))) + (build-system asdf-build-system/sbcl) + (inputs + `(("anaphora" ,sbcl-anaphora) + ("cl-containers" ,sbcl-cl-containers) + ("cl-ppcre" ,sbcl-cl-ppcre) + ("dynamic-classes" ,sbcl-dynamic-classes) + ("metabang-bind" ,sbcl-metabang-bind) + ("metatilities-base" ,sbcl-metatilities-base))) + (arguments + ;; NOTE: (Sharlatan-20210107213629+0000) Tests depend on too many not + ;; available systems, which themself are abandoned. + `(#:tests? #f)) + (home-page "https://common-lisp.net/project/cl-markdown/") + (synopsis "Common Lisp rewrite of Markdown") + (description + "This is an implementation of a Markdown parser in Common Lisp.") + (license license:expat))) + +(define-public ecl-cl-markdown + (sbcl-package->ecl-package sbcl-cl-markdown)) + +(define-public cl-markdown + (sbcl-package->cl-source-package sbcl-cl-markdown)) + +(define-public sbcl-magicffi + (let ((commit "d88f2f280c31f639e4e05be75215d8a8dce6aef2")) + (package + (name "sbcl-magicffi") + (version (git-version "0.0.0" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/dochang/magicffi/") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0p6ysa92fk34bhxpw7bycbfgw150fv11z9x8jr9xb4lh8cm2hvp6")))) + (build-system asdf-build-system/sbcl) + (native-inputs + `(("alexandria" ,sbcl-alexandria))) + (inputs + `(("cffi" ,sbcl-cffi) + ("ppcre" ,sbcl-cl-ppcre) + ("libmagic" ,file))) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'fix-paths + (lambda* (#:key inputs #:allow-other-keys) + (let ((magic (assoc-ref inputs "libmagic"))) + (substitute* "grovel.lisp" + (("/usr/include/magic.h") + (string-append magic "/include/magic.h"))) + (substitute* "api.lisp" + ((":default \"libmagic\"" all) + (string-append ":default \"" magic "/lib/libmagic\""))))))))) + (home-page "https://common-lisp.net/project/magicffi/") + (synopsis "Common Lisp interface to libmagic based on CFFI") + (description + "MAGICFFI is a Common Lisp CFFI interface to libmagic(3), the file type +determination library using @emph{magic} numbers.") + (license license:bsd-2)))) + +(define-public ecl-magicffi + (sbcl-package->ecl-package sbcl-magicffi)) + +(define-public cl-magicffi + (sbcl-package->cl-source-package sbcl-magicffi)) + +(define-public sbcl-shlex + (let ((commit "c5616dffca0d4d8ddbc1cd6f37a96d88477b2740")) + (package + (name "sbcl-shlex") + (version (git-version "0.0.0" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/ruricolist/cl-shlex") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1nas024n4wv319bf40aal96g72bgi9nkapj2chywj2cc6r8hzkfg")))) + (build-system asdf-build-system/sbcl) + (inputs + `(("alexandria" ,sbcl-alexandria) + ("serapeum" ,sbcl-serapeum) + ("ppcre" ,sbcl-cl-ppcre) + ("unicode" ,sbcl-cl-unicode))) + (home-page "https://github.com/ruricolist/cl-shlex") + (synopsis "Common Lisp lexical analyzer for shell-like syntaxes") + (description + "This library contains a lexer for syntaxes that use shell-like rules +for quoting and commenting. It is a port of the @code{shlex} module from Python’s +standard library.") + (license license:expat)))) + +(define-public ecl-shlex + (sbcl-package->ecl-package sbcl-shlex)) + +(define-public cl-shlex + (sbcl-package->cl-source-package sbcl-shlex)) + +(define-public sbcl-cmd + (let ((commit "e6a54dbf660bf229c80abc124fa47e7bb6d20c93")) + (package + (name "sbcl-cmd") + (version (git-version "0.0.1" "2" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/ruricolist/cmd/") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1i0l8ci4cnkx84q4afmpkq51nxah24fqpi6k9kgjbxz6li3zp8hy")))) + (build-system asdf-build-system/sbcl) + (inputs + `(("alexandria" ,sbcl-alexandria) + ("coreutils" ,coreutils) + ("serapeum" ,sbcl-serapeum) + ("shlex" ,sbcl-shlex) + ("trivia" ,sbcl-trivia))) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'fix-paths + (lambda* (#:key inputs #:allow-other-keys) + (let ((bin (string-append (assoc-ref inputs "coreutils") "/bin"))) + (substitute* "cmd.lisp" + (("\"env\"") (format #f "\"~a/env\"" bin)) + (("\"pwd\"") (format #f "\"~a/pwd\"" bin))))))))) + (home-page "https://github.com/ruricolist/cmd") + (synopsis "Conveniently run external programs from Common Lisp") + (description + "A utility for running external programs, built on UIOP. +Cmd is designed to be natural to use, protect against shell interpolation and +be usable from multi-threaded programs.") + (license license:expat)))) + +(define-public ecl-cmd + (sbcl-package->ecl-package sbcl-cmd)) + +(define-public cl-cmd + (sbcl-package->cl-source-package sbcl-cmd)) + +(define-public sbcl-ppath + (let ((commit "eb1a8173b4d1d691ea9a7699412123462f58c3ce")) + (package + (name "sbcl-ppath") + (version (git-version "0.1" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/fourier/ppath/") + (commit commit))) + (file-name (git-file-name name commit)) + (sha256 + (base32 "1c46q9lmzqv14z80d3fwdawgn3pn4922x31fyqvsvbcjm4hd16fb")))) + (build-system asdf-build-system/sbcl) + (inputs + `(("alexandria" ,sbcl-alexandria) + ("cffi" ,sbcl-cffi) + ("osicat" ,sbcl-osicat) + ("ppcre" ,sbcl-cl-ppcre) + ("split-sequence" ,sbcl-split-sequence) + ("trivial-features" ,sbcl-trivial-features))) + (native-inputs + `(("cl-fad" ,sbcl-cl-fad) + ("prove" ,sbcl-prove))) + (home-page "https://github.com/fourier/ppath") + (synopsis "Common Lisp's implementation of the Python's os.path module") + (description + "This library is a path strings manipulation library inspired by +Python's @code{os.path}. All functionality from @code{os.path} is supported on +major operation systems. + +The philosophy behind is to use simple strings and \"dumb\" string +manipulation functions to handle paths and filenames. Where possible the +corresponding OS system functions are called.") + (license license:bsd-2)))) + +(define-public ecl-ppath + (sbcl-package->ecl-package sbcl-ppath)) + +(define-public cl-ppath + (sbcl-package->cl-source-package sbcl-ppath)) + +(define-public sbcl-trivial-escapes + (let ((commit "1eca78da2078495d09893be58c28b3aa7b8cc4d1")) + (package + (name "sbcl-trivial-escapes") + (version (git-version "1.2.0" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/williamyaoh/trivial-escapes") + (commit commit))) + (file-name (git-file-name name commit)) + (sha256 + (base32 "0v6h8lk17iqv1qkxgqjyzn8gi6v0hvq2vmfbb01md3zjvjqxn6lr")))) + (build-system asdf-build-system/sbcl) + (inputs + `(("named-readtables" ,sbcl-named-readtables))) + (native-inputs + `(("fiveam" ,sbcl-fiveam))) + (home-page "https://github.com/williamyaoh/trivial-escapes") + (synopsis "C-style escape directives for Common Lisp") + (description + "This Common Lisp library interprets escape characters the same way that +most other programming language do. +It provides four readtables. The default one lets you write strings like this: +@code{#\"This string has\na newline in it!\"}.") + (license license:public-domain)))) + +(define-public ecl-trivial-escapes + (sbcl-package->ecl-package sbcl-trivial-escapes)) + +(define-public cl-trivial-escapes + (sbcl-package->cl-source-package sbcl-trivial-escapes)) + +(define-public sbcl-cl-indentify + (let ((commit "eb770f434defa4cd41d84bca822428dfd0dbac53")) + (package + (name "sbcl-cl-indentify") + (version (git-version "0.1" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/yitzchak/cl-indentify") + (commit commit))) + (file-name (git-file-name name commit)) + (sha256 + (base32 "0ha36bhg474vr76vfhr13szc8cfdj1ickg92k1icz791bqaqg67p")))) + (build-system asdf-build-system/sbcl) + (inputs + `(("alexandria" ,sbcl-alexandria) + ("command-line-arguments" ,sbcl-command-line-arguments) + ("trivial-gray-streams" ,sbcl-trivial-gray-streams))) + (native-inputs + `(("trivial-escapes" ,sbcl-trivial-escapes) + ("rove" ,sbcl-rove))) + (home-page "https://github.com/yitzchak/cl-indentify") + (synopsis "Code beautifier for Common Lisp") + (description + "A library and command line utility to automatically indent Common Lisp +source files.") + (license license:expat)))) + +(define-public ecl-cl-indentify + (sbcl-package->ecl-package sbcl-cl-indentify)) + +(define-public cl-indentify + (sbcl-package->cl-source-package sbcl-cl-indentify)) + +(define-public sbcl-concrete-syntax-tree + (let ((commit "abd242a59dadc5452aa9dbc1d313c83ec2c11f46")) + (package + (name "sbcl-concrete-syntax-tree") + (version (git-version "0.0.0" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/s-expressionists/Concrete-Syntax-Tree") + (commit commit))) + (file-name (git-file-name name commit)) + (sha256 + (base32 "1lyrglc3h1if44gxd9cwv90wa90nrdjvb7fry39b1xn8ywdfa7di")))) + (build-system asdf-build-system/sbcl) + (inputs + `(("acclimation" ,sbcl-acclimation))) + (home-page "https://github.com/s-expressionists/Concrete-Syntax-Tree") + (synopsis "Parse Common Lisp code into a concrete syntax tree") + (description + "This library is intended to solve the problem of source tracking for +Common Lisp code. + +By \"source tracking\", it is meant that code elements that have a known +origin in the form of a position in a file or in an editor buffer are +associated with some kind of information about this origin. + +Since the exact nature of such origin information depends on the Common Lisp +implementation and the purpose of wanting to track that origin, the library +does not impose a particular structure of this information. Instead, it +provides utilities for manipulating source code in the form of what is called +concrete syntax trees (CSTs for short) that preserve this information about +the origin.") + (license license:bsd-2)))) + +(define-public ecl-concrete-syntax-tree + (sbcl-package->ecl-package sbcl-concrete-syntax-tree)) + +(define-public cl-concrete-syntax-tree + (sbcl-package->cl-source-package sbcl-concrete-syntax-tree)) + +(define-public sbcl-eclector + (package + (name "sbcl-eclector") + (version "0.5.0") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/s-expressionists/Eclector") + (commit version))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0bwkla0jdp5bg0q1zca5wg22b0nbdmglgax345nrhsf8bdrh47wm")))) + (build-system asdf-build-system/sbcl) + (inputs + `(("acclimation" ,sbcl-acclimation) + ("alexandria" ,sbcl-alexandria) + ("closer-mop" ,sbcl-closer-mop) + ("concrete-syntax-tree" ,sbcl-concrete-syntax-tree))) + (native-inputs + `(("fiveam" ,sbcl-fiveam))) + (arguments + '(#:asd-systems '("eclector" + "eclector-concrete-syntax-tree"))) + (home-page "https://s-expressionists.github.io/Eclector/") + (synopsis "Highly customizable, portable Common Lisp reader") + (description + "Eclector is a portable Common Lisp reader that is highly customizable, +can recover from errors and can return concrete syntax trees. + +In contrast to many other reader implementations, eclector can recover from +most errors in the input supplied to it and continue reading. This capability +is realized as a restart. + +It can also produce instances of the concrete syntax tree classes provided by +the concrete syntax tree library.") + (license license:bsd-2))) + +(define-public ecl-eclector + (sbcl-package->ecl-package sbcl-eclector)) + +(define-public cl-eclector + (sbcl-package->cl-source-package sbcl-eclector)) + +(define-public sbcl-jsown + (let ((commit "744c4407bef58dfa876d9da0b5c0205d869e7977")) + (package + (name "sbcl-jsown") + (version (git-version "1.0.1" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/madnificent/jsown") + (commit commit))) + (file-name (git-file-name name commit)) + (sha256 + (base32 "0gadvmf1d9bq35s61z76psrsnzwwk12svi66jigf491hv48wigw7")))) + (build-system asdf-build-system/sbcl) + (home-page "https://github.com/madnificent/jsown") + (synopsis "Fast JSON reader / writer library for Common Lisp") + (description + "@code{jsown} is a high performance Common Lisp JSON parser. Its aim +is to allow for the fast parsing of JSON objects in Common Lisp. Recently, +functions and macros have been added to ease the burden of writing and editing +@code{jsown} objects. + +@code{jsown} allows you to parse JSON objects quickly to a modifiable Lisp +list and write them back. If you only need partial retrieval of objects, +@code{jsown} allows you to select the keys which you would like to see parsed. +@code{jsown} also has a JSON writer and some helper methods to alter the JSON +objects themselves.") + (license license:expat)))) + +(define-public ecl-jsown + (sbcl-package->ecl-package sbcl-jsown)) + +(define-public cl-jsown + (sbcl-package->cl-source-package sbcl-jsown)) + +(define-public sbcl-system-locale + (let ((commit "4b334bc2fa45651bcaa28ae7d9331095d6bf0a17")) + (package + (name "sbcl-system-locale") + (version (git-version "1.0.0" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/system-locale/") + (commit commit))) + (file-name (git-file-name name commit)) + (sha256 + (base32 "00p5c053kmgq4ks6l9mxsqz6g3bjcybvkvj0bh3r90qgpkaawm1p")))) + (build-system asdf-build-system/sbcl) + (inputs + `(("documentation-utils" ,sbcl-documentation-utils))) + (home-page "https://shinmera.github.io/system-locale/") + (synopsis "Get the system's locale and language settings in Common Lisp") + (description + "This library retrieves locale information configured on the +system. This is helpful if you want to write applications and libraries that +display messages in the user's native language.") + (license license:zlib)))) + +(define-public ecl-system-locale + (sbcl-package->ecl-package sbcl-system-locale)) + +(define-public cl-system-locale + (sbcl-package->cl-source-package sbcl-system-locale)) + +(define-public sbcl-language-codes + (let ((commit "e7aa0e37cb97a3d37d6bc7316b479d01bff8f42e")) + (package + (name "sbcl-language-codes") + (version (git-version "1.0.0" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/language-codes") + (commit commit))) + (file-name (git-file-name name commit)) + (sha256 + (base32 "0py176ibmsc01n5r0q1bs1ykqf5jwdbh8kx0j1a814l9y51241v0")))) + (build-system asdf-build-system/sbcl) + (inputs + `(("documentation-utils" ,sbcl-documentation-utils))) + (home-page "https://shinmera.github.io/language-codes/") + (synopsis "Map ISO language codes to language names in Common Lisp") + (description + "This is a small library providing the ISO-639 language code to +language name mapping.") + (license license:zlib)))) + +(define-public ecl-language-codes + (sbcl-package->ecl-package sbcl-language-codes)) + +(define-public cl-language-codes + (sbcl-package->cl-source-package sbcl-language-codes)) + +(define-public sbcl-multilang-documentation + (let ((commit "59e798a07e949e8957a20927f52aca425d84e4a0")) + (package + (name "sbcl-multilang-documentation") + (version (git-version "1.0.0" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/multilang-documentation") + (commit commit))) + (file-name (git-file-name name commit)) + (sha256 + (base32 "13y5jskx8n2b7kimpfarr8v777w3b7zj5swg1b99nj3hk0843ixw")))) + (build-system asdf-build-system/sbcl) + (inputs + `(("documentation-utils" ,sbcl-documentation-utils) + ("language-codes" ,sbcl-language-codes) + ("system-locale" ,sbcl-system-locale))) + (home-page "https://shinmera.github.io/multilang-documentation/") + (synopsis "Add multiple languages support to Common Lisp documentation") + (description + "This library provides a drop-in replacement function for +cl:documentation that supports multiple docstrings per-language, allowing you +to write documentation that can be internationalised.") + (license license:zlib)))) + +(define-public ecl-multilang-documentation + (sbcl-package->ecl-package sbcl-multilang-documentation)) + +(define-public cl-multilang-documentation + (sbcl-package->cl-source-package sbcl-multilang-documentation)) + +(define-public sbcl-trivial-do + (let ((commit "03a1729f1e71bad3ebcf6cf098a0cce52dfa1163")) + (package + (name "sbcl-trivial-do") + (version (git-version "0.1" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/yitzchak/trivial-do") + (commit commit))) + (file-name (git-file-name name commit)) + (sha256 + (base32 "1ffva79nkicc7wc8c2ic5nayis3b2rk5sxzj74yjkymkjgbpcrgd")))) + (build-system asdf-build-system/sbcl) + (home-page "https://github.com/yitzchak/trivial-do") + (synopsis "Additional dolist style macros for Common Lisp") + (description + "Additional dolist style macros for Common Lisp, such as +@code{doalist}, @code{dohash}, @code{dolist*}, @code{doplist}, @code{doseq} +and @code{doseq*}.") + (license license:zlib)))) + +(define-public ecl-trivial-do + (sbcl-package->ecl-package sbcl-trivial-do)) + +(define-public cl-trivial-do + (sbcl-package->cl-source-package sbcl-trivial-do)) + +(define-public sbcl-common-lisp-jupyter + (let ((commit "61a9a8e7a18e2abd7af7c697ba5146fd19bd9d62")) + (package + (name "sbcl-common-lisp-jupyter") + (version (git-version "0.1" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/yitzchak/common-lisp-jupyter") + (commit commit))) + (file-name (git-file-name name commit)) + (sha256 + (base32 "0zyzl55l45w9z65ygi5pcwda5w5p1j1bb0p2zg2n5cpv8344dkh2")))) + (build-system asdf-build-system/sbcl) + (inputs + `(("alexandria" ,sbcl-alexandria) + ("babel" ,sbcl-babel) + ("bordeaux-threads" ,sbcl-bordeaux-threads) + ("cl-base64" ,sbcl-cl-base64) + ("cl-indentify" ,sbcl-cl-indentify) + ("closer-mop" ,sbcl-closer-mop) + ("eclector" ,sbcl-eclector) + ("ironclad" ,sbcl-ironclad) + ("iterate" ,sbcl-iterate) + ("jsown" ,sbcl-jsown) + ("multilang-documentation" ,sbcl-multilang-documentation) + ("pzmq" ,sbcl-pzmq) + ("puri" ,sbcl-puri) + ("static-vectors" ,sbcl-static-vectors) + ("trivial-do" ,sbcl-trivial-do) + ("trivial-garbage" ,sbcl-trivial-garbage) + ("trivial-gray-streams" ,sbcl-trivial-gray-streams) + ("trivial-mimes" ,sbcl-trivial-mimes))) + (home-page "https://yitzchak.github.io/common-lisp-jupyter/") + (synopsis "Common Lisp kernel for Jupyter") + (description + "This is a Common Lisp kernel for Jupyter along with a library for +building Jupyter kernels, based on Maxima-Jupyter which was based on +@code{cl-jupyter}.") + (license license:zlib)))) + +(define-public ecl-common-lisp-jupyter + (sbcl-package->ecl-package sbcl-common-lisp-jupyter)) + +(define-public cl-common-lisp-jupyter + (sbcl-package->cl-source-package sbcl-common-lisp-jupyter)) + +(define-public sbcl-radiance + (let ((commit "5ffbe1f157edd17a13194495099efd81e052df85") + (revision "1")) + (package + (name "sbcl-radiance") + (version (git-version "2.1.2" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shirakumo/radiance") + (commit commit))) + (file-name (git-file-name "radiance" version)) + (sha256 + (base32 "0hbkcnmnlj1cqzbv18zmla2iwbl65kxilz9764hndf8x8as1539c")))) + (build-system asdf-build-system/sbcl) + (arguments + `(#:tests? #f ; TODO: The tests require some configuration. + #:phases + (modify-phases %standard-phases + (add-after 'unpack 'disable-quicklisp + (lambda _ + ;; Disable the automatic installation of systems by Quicklisp. + ;; (Maybe there would be a way to package Quicklisp and make it + ;; install things in the user's directory instead of + ;; /gnu/store/...). + (substitute* "interfaces.lisp" + (("\\(unless \\(asdf:find-system configured-implementation NIL\\)" + all) + (string-append "#+quicklisp " all)))))))) + (native-inputs + `(("alexandria" ,sbcl-alexandria) + ("dexador" ,sbcl-dexador) + ("parachute" ,sbcl-parachute) + ("verbose" ,sbcl-verbose))) + (inputs + `(("babel" ,sbcl-babel) + ("bordeaux-threads" ,sbcl-bordeaux-threads) + ("cl-ppcre" ,sbcl-cl-ppcre) + ("closer-mop" ,sbcl-closer-mop) + ("documentation-utils" ,sbcl-documentation-utils) + ("deploy" ,sbcl-deploy) + ("form-fiddle" ,sbcl-form-fiddle) + ("lambda-fiddle" ,sbcl-lambda-fiddle) + ("local-time" ,sbcl-local-time) + ("modularize-hooks" ,sbcl-modularize-hooks) + ("modularize-interfaces" ,sbcl-modularize-interfaces) + ("puri" ,sbcl-puri) + ("trivial-indent" ,sbcl-trivial-indent) + ("trivial-mimes" ,sbcl-trivial-mimes) + ("ubiquitous-concurrent" ,sbcl-ubiquitous))) + (home-page "https://shirakumo.github.io/radiance/") + (synopsis "Common Lisp web application environment") + (description + "Radiance is a web application environment, which is sort of like a web +framework, but more general, more flexible. It should let you write personal +websites and generally deployable applications easily and in such a way that +they can be used on practically any setup without having to undergo special +adaptations.") + (license license:zlib)))) + +(define-public ecl-radiance + (sbcl-package->ecl-package sbcl-radiance)) + +(define-public cl-radiance + (sbcl-package->cl-source-package sbcl-radiance)) |