@@ -64,6 +64,8 @@ ;;; Common Lisp compilers and tooling go to lisp.scm. ;;; Common Lisp applications should go to the most appropriate file, ;;; e.g. StumpWM is in wm.scm. +;;; Common Lisp libraries related to code testing facilities go +;;; to lisp-check.scm. (define-module (gnu packages lisp-xyz) #:use-module (gnu packages) @@ -135,911 +137,604 @@ #:use-module (srfi srfi-1) #:use-module (srfi srfi-19)) -(define-public sbcl-alexandria-plus - (let ((commit "adafb09838a84895bedb119f8253b89b6a04a2c5") - (revision "0")) +(define-public sbcl-3b-bmfont + (let ((commit "332c2262705f161627fc18add0310451a42799af") + (revision "3")) (package - (name "sbcl-alexandria-plus") - ;; Version is stated in the ASD file. - (version (git-version "1.1.0" revision commit)) + (name "sbcl-3b-bmfont") + (version (git-version "0.0.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/Symbolics/alexandria-plus") + (url "https://github.com/3b/3b-bmfont/") (commit commit))) - (file-name (git-file-name "cl-alexandria-plus" version)) + (file-name (git-file-name "cl-3b-bmfont" version)) (sha256 - (base32 "1w9r19610h599303gqlx2x5n8mmdynss2gyl7xilg5h6v8z3hkfl")))) + (base32 "11wnqa1wx9vji6cmxl5m5qnf12mqc6n7d5g8038r1wayq88bxia6")))) (build-system asdf-build-system/sbcl) (arguments - '(#:asd-systems '("alexandria+"))) - (native-inputs - (list sbcl-parachute)) + `(#:asd-systems '("3b-bmfont" + "3b-bmfont/common" + "3b-bmfont/json" + "3b-bmfont/text" + "3b-bmfont/xml"))) (inputs - (list sbcl-alexandria)) - (home-page "https://symbolics.github.io/alexandria-plus/") - (synopsis "Conservative set of extensions to Alexandria utilities") - (description - "@code{cl-alexandria-plus} is a conservative set of extensions to -@code{cl-alexandria} utilities.") - (license license:ms-pl)))) - -(define-public cl-alexandria-plus - (sbcl-package->cl-source-package sbcl-alexandria-plus)) - -(define-public ecl-alexandria-plus - (sbcl-package->ecl-package sbcl-alexandria-plus)) - -(define-public sbcl-alexandria - (let ((commit "009b7e532071d9777bdbd63b82d776555da95916") - (revision "0")) - (package - (name "sbcl-alexandria") - (version (git-version "1.4" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://gitlab.common-lisp.net/alexandria/alexandria.git") - (commit commit))) - (file-name (git-file-name "cl-alexandria" version)) - (sha256 - (base32 "0pdj779j3nwzn8f1661vf00rrjrbks1xgiq0rvwjw6qyxsfqfnl9")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-rt)) - (synopsis "Collection of portable utilities for Common Lisp") + (list sbcl-alexandria + sbcl-cxml + sbcl-flexi-streams + sbcl-jsown + sbcl-parse-number + sbcl-split-sequence)) + (home-page "https://github.com/3b/3b-bmfont/") + (synopsis "Read/write bmfont metadata files") (description - "Alexandria is a collection of portable utilities. It does not contain -conceptual extensions to Common Lisp. It is conservative in scope, and -portable between implementations.") - (home-page "https://common-lisp.net/project/alexandria/") - (license license:public-domain)))) - -(define-public cl-alexandria - (sbcl-package->cl-source-package sbcl-alexandria)) - -(define-public ecl-alexandria - (sbcl-package->ecl-package sbcl-alexandria)) + "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 sbcl-reader - (package - (name "sbcl-reader") - (version "0.10.0") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/digikar99/reader") - (commit (string-append "v" version)))) - (sha256 - (base32 "0pbv6w0d8d4qmfkdsz2rk21bp1las9r7pyvpmd95qjz7kpxrirl7")) - (file-name (git-file-name "cl-reader" version)))) - (build-system asdf-build-system/sbcl) - (arguments - (list - #:phases - #~(modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "reader.lisp" - (("echo") - (search-input-file inputs "/bin/echo")))))))) - (inputs - (list coreutils ; Needed for call to echo. - sbcl-alexandria - sbcl-fiveam ; Tests are written directly in the source files. - sbcl-hash-set - sbcl-iterate - sbcl-split-sequence - sbcl-trivial-types)) - (synopsis "Reader macros for common objects and data structures") - (description "This package provides a utility library intended -at providing configurable reader macros for common tasks such as -accessors, hash-tables, sets, uiop:run-program, arrays and a few others.") - (home-page "https://github.com/digikar99/reader/") - (license license:expat))) +(define-public ecl-3b-bmfont + (sbcl-package->ecl-package sbcl-3b-bmfont)) -(define-public cl-reader - (sbcl-package->cl-source-package sbcl-reader)) +(define-public cl-3b-bmfont + (sbcl-package->cl-source-package sbcl-3b-bmfont)) -(define-public ecl-reader - (package - (inherit (sbcl-package->ecl-package sbcl-reader)) - (arguments - ;; TODO: Tests fail on call to coreutils echo for ecl. - `(#:tests? #f)))) +(define sbcl-3b-bmfont/shinmera + (let ((commit "58e529d24b7799d56b4b3f9c8a953b585d42c7d2") + (revision "1")) + (package (inherit sbcl-3b-bmfont) + (version (git-version "0.0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/3b-bmfont/") + (commit commit))) + (file-name (git-file-name "3b-bmfont2" version)) + (sha256 + (base32 "17zby669b64rhxhk2szamzdgvispimh6ici05xa6x2vz4rvk71jq"))))))) -(define-public sbcl-st-json - (let ((commit "4a0025bcc5b6921454822f1b9f38f697b4eeaf43") - (revision "0")) +(define-public sbcl-3bmd + (let ((commit "e68b2d442f29b4534c1c8e2f2cdf7583643a2fc5") + (revision "4")) (package - (name "sbcl-st-json") + (name "sbcl-3bmd") (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/marijnh/ST-JSON") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "06qrhr5iw73k96lai2x9w52l6gnmlxy7fsr0r35gz6nz1f71x7gx")))) - (build-system asdf-build-system/sbcl) - (home-page "https://marijnhaverbeke.nl/st-json/") - (synopsis "JSON for Common Lisp") - (description - "ST-JSON (@code{ST} because it originated at Streamtech) is a Common Lisp - library for encoding and decoding JSON values (as specified on json.org). - -This library does mostly the same thing as CL-JSON, but is simpler and more -precise about types (distinguishing boolean false, the empty array, and the -empty object).") - (license license:zlib)))) - -(define-public cl-st-json - (sbcl-package->cl-source-package sbcl-st-json)) - -(define-public ecl-st-json - (sbcl-package->ecl-package sbcl-st-json)) - -(define-public sbcl-stdutils - (let ((commit "4a4e5a4036b815318282da5dee2a22825369137b") - (revision "0")) - (package - (name "sbcl-stdutils") - (version (git-version "1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/eslick/cl-stdutils") + (url "https://github.com/3b/3bmd") (commit commit))) - (file-name (git-file-name "cl-stdutils" version)) (sha256 - (base32 "16vxxphqdq8264x0aanm36x9r6d3ci1gjf4vf46mwl59gcff4wcj")))) + (base32 "12xqih1gnwsn1baqm7bq3kxss73phn06gvd0v1h1vwsjd1xgpq3g")) + (file-name (git-file-name "cl-3bmd" version)))) (build-system asdf-build-system/sbcl) - (arguments '(#:tests? #f)) ; There are no tests. + (arguments + `(#:asd-systems + '("3bmd" + "3bmd-ext-definition-lists" + "3bmd-ext-math" + "3bmd-ext-tables" + "3bmd-ext-wiki-links" + "3bmd-youtube" + "3bmd-ext-code-blocks") + #:phases + (modify-phases %standard-phases + (add-after 'unpack 'fix-python3-path + (lambda _ + (substitute* "code-blocks.lisp" + (("python3") (which "python3")))))))) + (native-inputs + (list sbcl-fiasco)) (inputs - (list sbcl-cl-fad - sbcl-cl-ppcre)) - (home-page "https://github.com/eslick/cl-stdutils/") - (synopsis "Grab bag of Common Lisp utility functions") + (list python + python-pygments + sbcl-alexandria + sbcl-colorize + sbcl-split-sequence + sbcl-esrap)) + (home-page "https://github.com/3b/3bmd") + (synopsis "Markdown processor in Command Lisp using esrap parser") (description - "This package provides a grab bag of miscellaneous Common Lisp -utilities.") - (license license:bsd-3)))) + "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-stdutils - (sbcl-package->cl-source-package sbcl-stdutils)) +(define-public cl-3bmd + (sbcl-package->cl-source-package sbcl-3bmd)) -(define-public ecl-stdutils - (sbcl-package->ecl-package sbcl-stdutils)) +(define-public ecl-3bmd + (sbcl-package->ecl-package sbcl-3bmd)) -(define-public sbcl-langutils - (let ((commit "38beec7a82eeb35b0bfb0824a41d13ed94fc648b") - (revision "0")) +(define-public sbcl-3bz + (let ((commit "569614c40408f3aefc77ba233e0e4bd66d3850ad") + (revision "1")) (package - (name "sbcl-langutils") - (version (git-version "1.0" revision commit)) + (name "sbcl-3bz") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/eslick/cl-langutils") + (url "https://github.com/3b/3bz") (commit commit))) - (file-name (git-file-name "cl-langutils" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "15y9x5wkg3fqndc04w2sc650fnwimxp4gjgpv9xvvdm9x4v433x6")))) + (base32 "0kvvlvf50jhhw1s510f3clpr1a68632bq6d698yxcrx722igcrg4")))) (build-system asdf-build-system/sbcl) - (arguments '(#:tests? #f)) ; There are no tests. (inputs - (list sbcl-stdutils - sbcl-s-xml-rpc)) - (home-page "https://langutils.common-lisp.dev/") - (synopsis "Common Lisp natural language processing toolkit") + (list sbcl-alexandria + sbcl-babel + sbcl-cffi + sbcl-mmap + sbcl-nibbles + sbcl-trivial-features)) + (home-page "https://github.com/3b/3bz") + (synopsis "Deflate decompression for Common Lisp") (description - "This package provides a hierarchy of major functions and auxiliary -functions related to the structured analysis and processing of open -text.") - (license license:bsd-3)))) - -(define-public cl-langutils - (sbcl-package->cl-source-package sbcl-langutils)) - -(define-public ecl-langutils - (sbcl-package->ecl-package sbcl-langutils)) - -(define-public sbcl-hash-set - (let ((commit "6feb20de457f14e24a83815be1097aa02cca5986") - (revision "0")) - (package - (name "sbcl-hash-set") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/samebchase/hash-set") - (commit commit))) - (file-name (git-file-name "cl-hash-set" version)) - (sha256 - (base32 "0a966y9yfarhmki4wwzg371ziaygnp13yc6r13w9zz327fkhz8na")))) - (build-system asdf-build-system/sbcl) - (native-inputs (list sbcl-fiveam)) - (inputs (list sbcl-alexandria)) - (home-page "https://github.com/samebchase/hash-set/") - (synopsis "Implementation of a hash-set") - (description "This package provides an implementation of the -hash-set data structure. It has constant time lookup, insertion and -deletion.") - (license license:unlicense)))) + "3bz is an implementation of Deflate decompression (RFC 1951) optionally +with zlib (RFC 1950) or gzip (RFC 1952) wrappers, with support for reading from +foreign pointers (for use with mmap and similar, etc), and from CL octet +vectors and streams.") + (license license:expat)))) -(define-public cl-hash-set - (sbcl-package->cl-source-package sbcl-hash-set)) +(define-public cl-3bz + (sbcl-package->cl-source-package sbcl-3bz)) -(define-public ecl-hash-set - (sbcl-package->ecl-package sbcl-hash-set)) +(define-public ecl-3bz + (sbcl-package->ecl-package sbcl-3bz)) -(define-public sbcl-duologue - (let ((commit "ea1ada244a81da65f85b548823c9a6d7c9c145e1") +(define-public sbcl-3d-math + (let ((commit "3831b1706d225def95a7301ef48b393b563f0114") (revision "0")) (package - (name "sbcl-duologue") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-3d-math") + (version (git-version "1.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/mmontone/duologue") + (url "https://github.com/Shinmera/3d-math") (commit commit))) - (file-name (git-file-name "cl-duologue" version)) + (file-name (git-file-name "cl-3d-math" version)) (sha256 - (base32 "1yg7f27im9h0m6jihcay1p7alfhzm9hafwm5dw5hsyacy8f2cwk2")))) + (base32 "052vzx5j7bag9dxvl0j0wrm244js1djldyn31rwxgkq7965rmi5r")))) (build-system asdf-build-system/sbcl) - (native-inputs (list sbcl-stefil)) + (native-inputs + (list sbcl-parachute)) (inputs - (list sbcl-alexandria - sbcl-anaphora - sbcl-chronicity - sbcl-cl-ansi-text - sbcl-cl-fad - sbcl-clavier - sbcl-drakma)) - (home-page "https://github.com/mmontone/duologue/") - (synopsis "High level user interaction library") + (list sbcl-documentation-utils + sbcl-type-templates)) + (home-page "https://shinmera.github.io/3d-math/") + (synopsis "Linear algebra for 2D and 3D computations") (description - "Duologue is high-level interaction library for Common Lisp. It features -coloured printing via @code{cl-ansi-text} and readline completion.") - (license (list license:expat - ;; https://github.com/mmontone/duologue/issues/9 - license:gpl3+))))) - -(define-public cl-duologue - (sbcl-package->cl-source-package sbcl-duologue)) - -(define-public ecl-duologue - (sbcl-package->ecl-package sbcl-duologue)) - -(define-public sbcl-alea - (package - (name "sbcl-alea") - (version "1.0") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/eXodiquas/alea") - (commit (string-append "v" version)))) - (file-name (git-file-name "cl-alea" version)) - (sha256 - (base32 "0nd9fdjli22ygfw3c8k9nh7d36c92866hics5aij6x7ly1q781gz")))) - (build-system asdf-build-system/sbcl) - (native-inputs (list sbcl-fiveam)) - (synopsis "Dice rolling library") - (description - "This package provides a Common Lisp library for dice rolling and working -with dice-roll statistics.") - (home-page "https://github.com/eXodiquas/alea") - (license license:expat))) + "The @code{3d-math} library implements types, operators, and algorithms +commonly used in math for 2D and 3D graphics. It supersedes and combines the +prior libraries @code{3d-vectors}, @code{3d-matrices}, @code{3d-quaternions}, +and @code{3d-transforms}. The new API is largely but not entirely backwards +compatible, and adds new functionality.") + (license license:zlib)))) -(define-public cl-alea - (sbcl-package->cl-source-package sbcl-alea)) +(define-public cl-3d-math + (sbcl-package->cl-source-package sbcl-3d-math)) -(define-public ecl-alea - (sbcl-package->ecl-package sbcl-alea)) +(define-public ecl-3d-math + (sbcl-package->ecl-package sbcl-3d-math)) -(define-public sbcl-cf - (let ((commit "fbc025b6f274687ee9acc8d07496d44999ac428e") +(define-public sbcl-3d-matrices + (let ((commit "b4f5a58299f8437fad2d77f0879c374e3430f4b5") (revision "2")) (package - (name "sbcl-cf") - (version (git-version "1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://codeberg.org/glv/cl-cf") - (commit commit))) - (file-name (git-file-name "cl-cf" version)) - (sha256 - (base32 "182laa57j9qs567g75qwf8vh4xb0d22lr94x84r32dy28mrwi5ig")))) - (build-system asdf-build-system/sbcl) - (native-inputs (list sbcl-fiveam)) - (synopsis "Continued fractions library") - (description "CF is a Common Lisp library for doing computations using -continued fractions.") - (home-page "https://codeberg.org/glv/cl-cf") - (license license:gpl3+)))) - -(define-public cl-cf - (sbcl-package->cl-source-package sbcl-cf)) - -(define-public ecl-cf - (sbcl-package->ecl-package sbcl-cf)) - -(define-public sbcl-bubble-operator-upwards - (let ((commit "846275a318b960de81b62caecb1e31930f70aef6") - (revision "0")) - (package - (name "sbcl-bubble-operator-upwards") - (version (git-version "1.0" revision commit)) + (name "sbcl-3d-matrices") + (version (git-version "1.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/Hexstream/bubble-operator-upwards") + (url "https://github.com/Shinmera/3d-matrices") (commit commit))) - (file-name (git-file-name "cl-bubble-operator-upwards" version)) + (file-name (git-file-name "cl-3d-matrices" version)) (sha256 - (base32 "0ybsy29ms3yrxgr7f2146lr6z4vm070dvdyzvwwxjh4dgm9na7bi")))) + (base32 "1s8b4zlmqwyplghs73riz1khf0c5sk64w6b12jd599091d5nr6sr")))) (build-system asdf-build-system/sbcl) (native-inputs (list sbcl-parachute)) - (home-page "https://www.hexstreamsoft.com/libraries/bubble-operator-upwards/") - (synopsis "Function that bubbles an operator upwards in a form") - (description - "@code{bubble-operator-upwards} is a function that bubbles an operator -upwards in a form, demultiplexing all alternative branches by way of -cartesian product.") - (license license:unlicense)))) - -(define-public cl-bubble-operator-upwards - (sbcl-package->cl-source-package sbcl-bubble-operator-upwards)) - -(define-public ecl-bubble-operator-upwards - (sbcl-package->ecl-package sbcl-bubble-operator-upwards)) - -(define-public sbcl-map-bind - (let ((commit "532d55d93540c632e22b2cd264b5daa5f9d3d900") - (revision "0")) - (package - (name "sbcl-map-bind") - (version (git-version "1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Hexstream/map-bind") - (commit commit))) - (file-name (git-file-name "cl-map-bind" version)) - (sha256 - (base32 "0hfy65xyqc4zqfncn11pp3hjjkdz7m91cynnv91s3lgcl3kffva0")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-parachute)) - (home-page "https://www.hexstreamsoft.com/libraries/map-bind/") - (synopsis "Macro favouring positional references over naming") - (description - "@code{MAP-BIND} is a macro that allows visual grouping of variables with -their corresponding values in calls to mapping operators when using an -inline @code{LAMBDA}.") - (license license:unlicense)))) - -(define-public cl-map-bind - (sbcl-package->cl-source-package sbcl-map-bind)) - -(define-public ecl-cl-map-bind - (sbcl-package->ecl-package sbcl-map-bind)) - -(define-public sbcl-positional-lambda - (let ((commit "a43a7bb4ef6faa277e6a7440ec9839711c4b9d28") - (revision "0")) - (package - (name "sbcl-positional-lambda") - (version (git-version "2.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Hexstream/positional-lambda") - (commit commit))) - (file-name (git-file-name "cl-positional-lambda" version)) - (sha256 - (base32 "1l27mw5ciqz7rnjq1lwslgk220i8iqcr39rs8b7hxkp1yqmah5zq")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-parachute)) (inputs - (list sbcl-map-bind)) - (home-page "https://www.hexstreamsoft.com/libraries/positional-lambda/") - (synopsis "Macro favouring positional references over naming") + (list sbcl-3d-vectors sbcl-documentation-utils)) + (home-page "https://shinmera.github.io/3d-matrices/") + (synopsis "Utility library implementing 2x2, 3x3, 4x4 and NxM matrices") (description - "This package provides a concise, intuitive and flexible macro for -trivial lambdas that eschews explicit naming of parameter variables in favor -of positional references, with support for a used or ignored &rest parameter -and automatic declaration of ignored parameters when logical @code{gaps} -are left in the positional references. Further convenience features -are provided.") - (license license:unlicense)))) - -(define-public cl-positional-lambda - (sbcl-package->cl-source-package sbcl-positional-lambda)) - -(define-public ecl-cl-positional-lambda - (sbcl-package->ecl-package sbcl-positional-lambda)) - -(define-public sbcl-bodge-utilities - (let ((commit "6304bac4abe06d53579e2c0fc4437d14ff077d9f") - (revision "1")) - (package - (name "sbcl-bodge-utilities") - (version (git-version "1.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/borodust/bodge-utilities") - (commit commit))) - (file-name (git-file-name "bodge-utilities" version)) - (sha256 - (base32 "1z1blj05q71vzh323qwyn9p3xs7v0mq2yhwfyzza5libp37wqm3c")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-alexandria - sbcl-cffi - sbcl-claw - sbcl-dissect - sbcl-local-time - sbcl-log4cl - sbcl-split-sequence - sbcl-static-vectors - sbcl-trivial-gray-streams)) - (home-page "https://github.com/borodust/bodge-utilities") - (synopsis "Common Lisp utilities library for CL-BODGE") - (description - "This Common Lisp library provides utilities for the @emph{Bodge} library -collection.") - (license license:expat)))) + "@code{3D-MATRICES} is a library implementing common matrix operations, +mainly intended as the counterpiece to @code{3d-vectors} and thus being aimed at +operations in 3D space.") + (license license:zlib)))) -(define-public ecl-bodge-utilities - (sbcl-package->ecl-package sbcl-bodge-utilities)) +(define-public cl-3d-matrices + (sbcl-package->cl-source-package sbcl-3d-matrices)) -(define-public cl-bodge-utilities - (sbcl-package->cl-source-package sbcl-bodge-utilities)) +(define-public ecl-3d-matrices + (sbcl-package->ecl-package sbcl-3d-matrices)) -(define-public sbcl-meta - (let ((commit "74faea662139fbbfb9c99341aaed989f5b0e9da3") +(define-public sbcl-3d-quaternions + (let ((commit "b79c15cca8d9c409216a6cee8ec9e182dcdec9e2") (revision "0")) (package - (name "sbcl-meta") + (name "sbcl-3d-quaternions") (version (git-version "1.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://gitlab.common-lisp.net/frideau/meta") + (url "https://github.com/Shinmera/3d-quaternions") (commit commit))) - (file-name (git-file-name "cl-meta" version)) + (file-name (git-file-name "cl-3d-quaternions" version)) (sha256 - (base32 "08s53zj3mcx82kszp1bg2vsb4kydvkc70kj4hpq9h1l5a1wh44cy")))) + (base32 "1mrq6yhb90mhvxdkg3fx58ci5yj5xlixbbzf1q6p76wyq40qjv76")))) (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-parachute)) (inputs - (list sbcl-named-readtables)) - (home-page "https://gitlab.common-lisp.net/frideau/meta") - (synopsis "Recursive-descent parser DSL for Common Lisp") + (list sbcl-3d-matrices sbcl-3d-vectors sbcl-documentation-utils)) + (home-page "https://shinmera.github.io/3d-quaternions/") + (synopsis "Quaternion and dual-quaternion functionality in Common Lisp") (description - "This package provides a recursive-descent parser DSL for Common Lisp. -It's intended as a simpler alternative to parser generators.") - (license license:bsd-2)))) - -(define-public cl-meta - (sbcl-package->cl-source-package sbcl-meta)) - -(define-public ecl-meta - (sbcl-package->ecl-package sbcl-meta)) - -(define-public sbcl-cl-smtp - (let ((commit "ed47d326fad867ee11323fa3a0f307b5d40e8f2b") - (revision "0")) - (package - (name "sbcl-cl-smtp") - (version (git-version "20191031.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://gitlab.common-lisp.net/cl-smtp/cl-smtp") - (commit commit))) - (file-name (git-file-name "cl-smtp" version)) - (sha256 - (base32 "0vjjfapcrdc5671jz2d24h8zvpz7skq1x6pi9fvw6ls5sgms6fr0")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-cl+ssl - sbcl-cl-base64 - sbcl-flexi-streams - sbcl-trivial-gray-streams - sbcl-usocket)) - (home-page "https://gitlab.common-lisp.net/cl-smtp/cl-smtp") - (synopsis "Simple Common Lisp SMTP client") - (description "This package provides a client for SMTP.") - (license license:llgpl)))) - -(define-public cl-smtp - (sbcl-package->cl-source-package sbcl-cl-smtp)) - -(define-public ecl-cl-smtp - (sbcl-package->ecl-package sbcl-cl-smtp)) - -(define-public sbcl-clavier - (let ((commit "9b1424eaad131e114a45b400784079124b5e2321") - (revision "1")) - (package - (name "sbcl-clavier") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/mmontone/clavier") - (commit commit))) - (file-name (git-file-name "cl-clavier" version)) - (sha256 - (base32 "1gjd0rhxs2x7gn3fw1hnxivmm4ca4f1wxlg0fqv8fdfabgzsvl5y")))) - (build-system asdf-build-system/sbcl) - (native-inputs (list sbcl-stefil)) - (inputs - (list sbcl-alexandria - sbcl-chronicity - sbcl-cl-fad - sbcl-cl-ppcre - sbcl-closer-mop)) - (home-page "https://github.com/mmontone/clavier/") - (synopsis "General purpose validation library") - (description "Clavier is a general purpose validation library for -Common Lisp.") - (license license:expat)))) - -(define-public cl-clavier - (sbcl-package->cl-source-package sbcl-clavier)) - -(define-public ecl-clavier - (sbcl-package->ecl-package sbcl-clavier)) - -(define-public sbcl-cl-inotify - (let ((commit "66f29e01ec28355ebba8292411b4de90eebd76a3") - (revision "0")) - (package - (name "sbcl-cl-inotify") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Ferada/cl-inotify") - (commit commit))) - (file-name (git-file-name "cl-inotify" version)) - (sha256 - (base32 "0d3bvp5lqnddzhk1w9yyli03njbkhc8d129a058g0j49kgd47c7v")))) - (build-system asdf-build-system/sbcl) - (native-inputs (list sbcl-fiveam)) - (inputs - (list libfixposix - sbcl-binary-types - sbcl-cffi - sbcl-osicat - sbcl-trivial-utf-8)) - (synopsis "Common Lisp interface to the Linux inotify API") - (description - "@code{cl-inotify} uses @code{cl-cffi} to provide a Common Lisp -interface to the Linux inotify API.") - (home-page "https://github.com/Ferada/cl-inotify/") - (license license:bsd-2)))) + "This is a library for quaternions. It contains most of the quaternion +operations one would usually expect out of such a library and offers them both +in non-modifying and modifying versions where applicable. It also tries to be +efficient where plausible. Each quaternion is made up of @code{float}s, which +by default are @code{single-float}s, as they do not require value boxing on +most modern systems and compilers.") + (license license:zlib)))) -(define-public cl-inotify - (sbcl-package->cl-source-package sbcl-cl-inotify)) +(define-public cl-3d-quaternions + (sbcl-package->cl-source-package sbcl-3d-quaternions)) -(define-public ecl-cl-inotify - (sbcl-package->ecl-package sbcl-cl-inotify)) +;; TODO: Build failure: +;; https://github.com/Shinmera/3d-quaternions/issues/2 +;; +;; (define-public ecl-3d-quaternions +;; (sbcl-package->ecl-package sbcl-3d-quaternions)) -(define-public sbcl-file-notify - (let ((commit "f12dc2f2aae5fee13355cd93a8cae0c4c412b76d") +(define-public sbcl-3d-spaces + (let ((commit "a93f4915affcf65617366297ad8bd2ec77bae702") (revision "0")) (package - (name "sbcl-file-notify") + (name "sbcl-3d-spaces") (version (git-version "1.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/Shinmera/file-notify") + (url "https://github.com/Shirakumo/3d-spaces") (commit commit))) - (file-name (git-file-name "cl-file-notify" version)) + (file-name (git-file-name "cl-3d-spaces" version)) (sha256 - (base32 "0788d98rqm1krl8nbfh8qshvyf6g336i9bqrdhkx06cfvbh0wcny")))) + (base32 "1m5cg5zy1731dcgkm1p4m53z1zsp387xligxh32pdrnrhc2lzhmf")))) (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-parachute)) (inputs - (list sbcl-cffi + (list sbcl-3d-math sbcl-documentation-utils - sbcl-trivial-features)) - (home-page "https://github.com/Shinmera/file-notify") - (synopsis "Get notifications for file accesses and changes") + sbcl-for + sbcl-trivial-extensible-sequences)) + (home-page "https://shirakumo.github.io/3d-spaces/") + (synopsis "Implementations of various spatial query structures") (description - "File-Notify is a Common Lisp library for getting notifications for file -accesses and changes.") + "The 3D-Spaces library implements a number of spatial query data +structures; structures that can answer spatial range queries for optimized +lookup, particularly suited for games.") (license license:zlib)))) -(define-public cl-file-notify - (sbcl-package->cl-source-package sbcl-file-notify)) +(define-public cl-3d-spaces + (sbcl-package->cl-source-package sbcl-3d-spaces)) -(define-public ecl-file-notify - (sbcl-package->ecl-package sbcl-file-notify)) +(define-public ecl-3d-spaces + (sbcl-package->ecl-package sbcl-3d-spaces)) -(define-public sbcl-file-select - (let ((commit "ef25f6d7c78ed9e0b62119979af8c4b5b0f8c774") - (revision "1")) +(define-public sbcl-3d-transforms + (let ((commit "1d44509387d0747cd0351e95a533eca609058632") + (revision "0")) (package - (name "sbcl-file-select") + (name "sbcl-3d-transforms") (version (git-version "1.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/Shinmera/file-select") + (url "https://github.com/Shinmera/3d-transforms") (commit commit))) - (file-name (git-file-name "file-select" version)) + (file-name (git-file-name "cl-3d-transforms" version)) (sha256 - (base32 "1qh32ymljw5c98zzbvjfq6jzwlzs4qxi8gh4gw8pixir6y1inxaa")))) + (base32 "03pmv7dh1j6kl16ch6lnvxzjrld4jbr3jx8slzkiipgzdxg74pcx")))) (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-parachute)) (inputs - (list sbcl-cffi - sbcl-documentation-utils - sbcl-float-features)) - (home-page "https://shinmera.github.io/file-select/") - (synopsis "Invoke the native file selection dialogs to open or save files") + (list sbcl-3d-matrices + sbcl-3d-quaternions + sbcl-3d-vectors + sbcl-documentation-utils)) + (home-page "https://shinmera.github.io/3d-transforms/") + (synopsis + "Common structure to encapsulate spatial transformations in Common Lisp") (description - "This library allows you to open native file dialogs to open and save -files. This is useful if you have an application that's primarily text based -and would like a more convenient file selection utility, or if you are working -with a UI toolkit that does not offer a way to access the native file dialogs -directly.") + "This is a library that uses the other 3d-* math libraries to present an +encapsulation for a spatial transformation. It offers convenience functions for +operating on such transformations and for converting between them and the +alternative 4x4 matrix representation.") (license license:zlib)))) -(define-public cl-file-select - (sbcl-package->cl-source-package sbcl-file-select)) +(define-public cl-3d-transforms + (sbcl-package->cl-source-package sbcl-3d-transforms)) -(define-public ecl-file-select - (sbcl-package->ecl-package sbcl-file-select)) +;; TODO: Build failure: +;; https://github.com/Shinmera/3d-quaternions/issues/2 +;; +;; (define-public ecl-3d-transforms +;; (sbcl-package->ecl-package sbcl-3d-transforms)) -(define-public sbcl-bodge-queue - (let ((commit "948c9a501dcd412689952d09eb7453ec2722336a") - (revision "0")) +(define-public sbcl-3d-vectors + (let ((commit "257969402864ac3859d77b981abf0aa5373c4e78") + (revision "2")) (package - (name "sbcl-bodge-queue") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-3d-vectors") + (version (git-version "3.1.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/borodust/bodge-queue") + (url "https://github.com/Shinmera/3d-vectors") (commit commit))) - (file-name (git-file-name "bodge-queue" version)) + (file-name (git-file-name "cl-3d-vectors" version)) (sha256 - (base32 "148hjikqk8v2m30mj15xh89zni6szf9z3prav580qk9dqr8djjdr")))) + (base32 "0vmf7nycc49ydcy0dfs25cgs655kwjc6jcjvpwxw61jq4gl2fh7x")))) (build-system asdf-build-system/sbcl) (native-inputs - (list sbcl-fiveam)) - (home-page "https://github.com/borodust/bodge-queue") - (synopsis "Simple queue for Common Lisp") - (description "This Common Lisp library provides a simple FIFO -implementation with no external dependencies.") - (license license:expat)))) + (list sbcl-parachute)) + (inputs + (list sbcl-documentation-utils)) + (home-page "https://shinmera.github.io/3d-vectors/") + (synopsis "Utility library implementing 2D, 3D, and 4D vectors") + (description + "@code{3D-VECTORS} is a library for vector math in 3D space. It contains +most of the vector operations one would usually expect out of such a library and +offers them both in non-modifying and modifying versions where applicable.") + (license license:zlib)))) -(define-public cl-bodge-queue - (sbcl-package->cl-source-package sbcl-bodge-queue)) +(define-public cl-3d-vectors + (sbcl-package->cl-source-package sbcl-3d-vectors)) -(define-public ecl-bodge-queue - (sbcl-package->ecl-package sbcl-bodge-queue)) +(define-public ecl-3d-vectors + (sbcl-package->ecl-package sbcl-3d-vectors)) -(define-public sbcl-list-named-class - (let ((commit "2955791a7469131bcab42d800883f27993ee1d62") +(define-public sbcl-40ants-doc + (let ((commit "7725ff67a380e9ebfc6155e14d91e650f256711b") (revision "0")) (package - (name "sbcl-list-named-class") - (version (git-version "0.1" revision commit)) + (name "sbcl-40ants-doc") + (version (git-version "0.1.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/phoe/list-named-class") + (url "https://github.com/40ants/doc") (commit commit))) - (file-name (git-file-name "cl-list-named-class" version)) (sha256 - (base32 "1bdi9q9wvfj66jji3n9hpjrj9271ial2awsb0xw80bmy6wqbg8kq")))) + (base32 "1v6gnhrk02vsixmprzk4wvvj7vh11vp5waxyih0qz2ih8d38r5pg")) + (file-name (git-file-name "cl-40ants-doc" version)))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-1am)) + (arguments + ;; TODO: Add remaining dependencies of 40ants-doc-full and + ;; 40ants-doc-test missing from Guix. + '(#:asd-systems '("40ants-doc" + ;;"40ants-doc-full" + ) + #:tests? #f)) + ;;(native-inputs + ;; (list sbcl-rove)) (inputs - (list sbcl-alexandria sbcl-closer-mop)) - (home-page "https://github.com/phoe/list-named-class/") - (synopsis "Name classes after lists of symbols") + (list sbcl-named-readtables + sbcl-pythonic-string-reader + ;; For 40ants-doc-full: + ;;sbcl-3bmd + ;;sbcl-alexandria + ;;sbcl-babel + ;;sbcl-cl-cookie + ;;sbcl-cl-fad + ;;sbcl-cl-ppcre + ;;sbcl-common-doc ; Missing from Guix + ;;sbcl-common-html ; Missing from Guix + ;;sbcl-commondoc-markdown ; Missing from Guix + ;;sbcl-dexador + ;;sbcl-docs-builder ; Missing from Guix + ;;sbcl-fare-utils + ;;sbcl-jonathan + ;;sbcl-lass + ;;sbcl-local-time + ;;sbcl-log4cl + ;;sbcl-slime-swank + ;;sbcl-slynk + ;;sbcl-spinneret + ;;sbcl-stem ; Missing from Guix; also, license is unconfirmed + ;;sbcl-str + ;;sbcl-tmpdir ; Missing from Guix + ;;sbcl-trivial-extract ; Missing from Guix + ;;sbcl-xml-emitter + )) + (home-page "https://40ants.com/doc/") + (synopsis "Exploratory programming environment and documentation generator") (description - "This package makes it possible to name classes by lists of symbols -instead of symbols.") + "@code{40ants-doc} provides a rudimentary explorable programming +environment. The narrative primarily lives in so-called sections that mix +Markdown docstrings with references to functions, variables, etc., all of +which should probably have their own docstrings. + +The primary focus is on making code easily explorable by using SLIME's +@kbd{M-.} (@code{slime-edit-definition}). Generating documentation in +Markdown or HTML format from sections and all the referenced items is also +implemented. + +With the simplistic tools provided, one may obtain results similar to literate +programming, but documentation is generated from code, not the other way +around, and there is no support for chunking. Code comes first, code must +look pretty, documentation is code. + +@code{40ants-doc} is a fork of MGL-PAX with fewer dependencies (only +@code{named-readtables} and @code{pythonic-string-reader}) for the core +system, and additional features in the full system.") (license license:expat)))) -(define-public cl-list-named-class - (sbcl-package->cl-source-package sbcl-list-named-class)) +(define-public cl-40ants-doc + (sbcl-package->cl-source-package sbcl-40ants-doc)) -(define-public ecl-list-named-class - (sbcl-package->ecl-package sbcl-list-named-class)) +(define-public ecl-40ants-doc + (sbcl-package->ecl-package sbcl-40ants-doc)) -(define-public sbcl-golden-utils - (let ((commit "e43914ad2bdb0c8e1b1f10ef591aafc3c55b89e7") - (revision "4")) +(define-public sbcl-abstract-classes + (let ((commit "7fa74f1e057f9ba7c1ffecff14f049f979e45267") + (revision "1")) (package - (name "sbcl-golden-utils") - (version (git-version "0.0.0" revision commit)) - (home-page "https://github.com/lisp-mirror/golden-utils") + (name "sbcl-abstract-classes") + (version (git-version "1.7.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url home-page) + (url "https://bitbucket.org/eeeickythump/cl-abstract-classes") (commit commit))) - (file-name (git-file-name "cl-golden-utils" version)) + (file-name (git-file-name "cl-abstract-classes" version)) (sha256 - (base32 "09vq29wjr3x7h3fshwxg8h1psy4p73yl61cjljarpqjhsgz7lmbp")))) + (base32 "06lby4i6xbbgs7kgb0f3fqybvyskyg6djhrf967lnysv7hn3zpg9")))) (build-system asdf-build-system/sbcl) (inputs - (list sbcl-alexandria)) - (synopsis "Common Lisp utility library") + `(("closer-mop" ,sbcl-closer-mop))) + (arguments + `(#:asd-systems '("abstract-classes" "singleton-classes"))) + (home-page "https://bitbucket.org/eeeickythump/cl-abstract-classes") + (synopsis "Abstract, final, and singleton metaclasses for CLOS") (description - "This is a Common Lisp library providing various utilities.") - (license license:expat)))) + "This package provides Common Lisp extension to the MOP to allow +abstract, final and singleton classes.") + (license license:public-domain)))) -(define-public ecl-golden-utils - (sbcl-package->ecl-package sbcl-golden-utils)) +(define-public ecl-abstract-classes + (sbcl-package->ecl-package sbcl-abstract-classes)) -(define-public cl-golden-utils - (sbcl-package->cl-source-package sbcl-golden-utils)) +(define-public cl-abstract-classes + (sbcl-package->cl-source-package sbcl-abstract-classes)) -(define-public sbcl-asdf-finalizers - (let ((commit "7f537f6c598b662ae987c6acc268dd27c25977e0") +(define-public sbcl-access + (let ((commit "a4f87fc1007f5c9a0a2abfddc1c23a77e87096f8") (revision "1")) (package - (name "sbcl-asdf-finalizers") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-access") + (version (git-version "1.6.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://gitlab.common-lisp.net/asdf/asdf-finalizers") + (url "https://github.com/AccelerationNet/access") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-access" version)) (sha256 - (base32 "1w56c9yjjydjshsgqxz57qlp2v3r4ilbisnsgiqphvxnhvd41y0v")))) + (base32 "0zdjqhb9rvnlq6nzmsp7372gi91k1rq9bz510m6hcki7g3r01iv5")))) (build-system asdf-build-system/sbcl) (native-inputs - `(("fare-utils" ,sbcl-fare-utils) - ("hu.dwim.stefil" ,sbcl-hu.dwim.stefil))) - (home-page "https://gitlab.common-lisp.net/asdf/asdf-finalizers") - (synopsis "Enforced calling of finalizers for Lisp code") - (description "This library allows you to implement and enforce proper -finalization of compile-time constructs while building Lisp source files. - -It produces two systems: asdf-finalizers and list-of.") - (license license:expat)))) + (list sbcl-lisp-unit2)) + (inputs + (list sbcl-alexandria + sbcl-cl-ppcre + sbcl-closer-mop + sbcl-iterate)) + (synopsis + "Common lisp library to unify access to dictionary-like structures") + (description + "This is a Common lisp library to unify access to the most common +dictionary-like data structures.") + (home-page "https://github.com/AccelerationNet/access") + (license license:bsd-3)))) -(define-public ecl-asdf-finalizers - (sbcl-package->ecl-package sbcl-asdf-finalizers)) +(define-public ecl-access + (sbcl-package->ecl-package sbcl-access)) -(define-public cl-asdf-finalizers - (sbcl-package->cl-source-package sbcl-asdf-finalizers)) +(define-public cl-access + (sbcl-package->cl-source-package sbcl-access)) -(define-public sbcl-asdf-system-connections - (let ((commit "9f085240febccccff99d9d3bb687fcaafffd3f5e") - (revision "1")) +(define-public sbcl-acclimation + (let ((commit "4d51150902568fcd59335f4cc4cfa022df6116a5")) (package - (name "sbcl-asdf-system-connections") - (version (git-version "0.8.4" revision commit)) + (name "sbcl-acclimation") + (version (git-version "0.0.0" "1" commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/gwkkwg/asdf-system-connections") + (url "https://github.com/robert-strandh/Acclimation") (commit commit))) - (file-name (git-file-name "cl-asdf-system-connections" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "06kg0m8bv383qq3r34x0f8hz6p6zxcw02qn7kj960vcnrp5a5b3y")))) + (base32 + "1aw7rarjl8ai57h0jxnp9hr3dka7qrs55mmbl1p6rhd6xj8mp9wq")))) (build-system asdf-build-system/sbcl) - (home-page "https://github.com/gwkkwg/asdf-system-connections") - (synopsis "Common Lisp ASDF system auto-loading extension") - (description - "This package provides a Common Lisp ASDF system auto-loading -extension.") - (license license:expat)))) - -(define-public ecl-asdf-system-connections - (sbcl-package->ecl-package sbcl-asdf-system-connections)) - -(define-public cl-asdf-system-connections - (sbcl-package->cl-source-package sbcl-asdf-system-connections)) - -(define-public sbcl-net.didierverna.asdf-flv - (package - (name "sbcl-net.didierverna.asdf-flv") - (version "2.1") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/didierverna/asdf-flv") - (commit (string-append "version-" version)))) - (file-name (git-file-name "asdf-flv" version)) - (sha256 - (base32 "1fi2y4baxan103jbg4idjddzihy03kwnj2mzbwrknw4d4x7xlgwj")))) - (build-system asdf-build-system/sbcl) - (synopsis "Common Lisp ASDF extension to provide support for file-local variables") - (description "ASDF-FLV provides support for file-local variables through -ASDF. A file-local variable behaves like @code{*PACKAGE*} and -@code{*READTABLE*} with respect to @code{LOAD} and @code{COMPILE-FILE}: a new -dynamic binding is created before processing the file, so that any -modification to the variable becomes essentially file-local. + (home-page "https://github.com/robert-strandh/Acclimation") + (synopsis "Internationalization library for Common Lisp") + (description "This project is meant to provide tools for +internationalizing Common Lisp programs. -In order to make one or several variables file-local, use the macros -@code{SET-FILE-LOCAL-VARIABLE(S)}.") - (home-page "https://www.lrde.epita.fr/~didier/software/lisp/misc.php#asdf-flv") - (license (license:non-copyleft - "https://www.gnu.org/prep/maintain/html_node/License-Notices-for-Other-Files.html" - "GNU All-Permissive License")))) +One important aspect of internationalization is of course the language used in +error messages, documentation strings, etc. But with this project we provide +tools for all other aspects of internationalization as well, including dates, +weight, temperature, names of physical quantitites, etc.") + (license license:bsd-2)))) -(define-public cl-net.didierverna.asdf-flv - (sbcl-package->cl-source-package sbcl-net.didierverna.asdf-flv)) +(define-public cl-acclimation + (sbcl-package->cl-source-package sbcl-acclimation)) -(define-public ecl-net.didierverna.asdf-flv - (sbcl-package->ecl-package sbcl-net.didierverna.asdf-flv)) +(define-public ecl-acclimation + (sbcl-package->ecl-package sbcl-acclimation)) -(define-public sbcl-command-line-arguments - (let ((commit "fbac862fb01c0e368141204f3f639920462c23fe") - (revision "1")) +(define-public sbcl-acl-compat + ;; There does not seem to be proper releases. + (let ((commit "cac1d6920998ddcbee8310a873414732e707d8e5")) (package - (name "sbcl-command-line-arguments") - (version (git-version "2.0.0" revision commit)) + (name "sbcl-acl-compat") + (version (git-version "0.1.1" "1" commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/fare/command-line-arguments") + (url "git://git.code.sf.net/p/portableaserve/git") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "acl-compat" version)) (sha256 - (base32 "054m1ikndzqf72mb9ajaa64136cwr3bgag4yfbi1574a9vq75mjq")))) + (base32 "0ak6mqp84sjr0a7h5svr16vra4bf4fcx6wpir0n88dc1vjwy5xqa")))) (build-system asdf-build-system/sbcl) - (home-page "https://github.com/fare/command-line-arguments") - (synopsis "Trivial command-line argument parsing library for Common Lisp") - (description "This is a library to abstract away the parsing of -Unix-style command-line arguments. Use it in conjunction with asdf:program-op -or cl-launch for portable processing of command-line arguments.") - (license license:expat)))) - -(define-public ecl-command-line-arguments - (sbcl-package->ecl-package sbcl-command-line-arguments)) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'cd-acl-compat + (lambda _ + (chdir "acl-compat") + #t))))) + (inputs + `(("puri" ,sbcl-puri) + ("cl-ppcre" ,sbcl-cl-ppcre) + ("ironclad" ,sbcl-ironclad) + ("cl-fad" ,sbcl-cl-fad))) + (home-page "https://sourceforge.net/projects/portableaserve/") + (synopsis "AllegroServe, a web server written in Common Lisp") + (description + "The server part of AllegroServe can be used either as a standalone web +server or a module loaded into an application to provide a user interface to +the application. AllegroServe's proxy ability allows it to run on the gateway +machine between some internal network and the Internet. AllegroServe's client +functions allow Lisp programs to explore the web.") + (license license:llgpl)))) -(define-public cl-command-line-arguments - (sbcl-package->cl-source-package sbcl-command-line-arguments)) +(define-public cl-acl-compat + (sbcl-package->cl-source-package sbcl-acl-compat)) (define-public sbcl-adopt (package @@ -1065,2256 +760,1795 @@ Common Lisp, heavily influenced by Python's @code{optparse} and @code{argparse}.") (license license:expat))) +(define-public cl-adopt + (sbcl-package->cl-source-package sbcl-adopt)) + (define-public ecl-adopt (sbcl-package->ecl-package sbcl-adopt)) -(define-public cl-adopt - (sbcl-package->cl-source-package sbcl-adopt)) +(define-public sbcl-agnostic-lizard + (let ((commit "fe1a1d7d80c8b56163754e0e5b3653fd750ad298") + (revision "2")) + (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 "cl-agnostic-lizard" version)) + (sha256 + (base32 "0amzshh6v3mp24j0h2cinv4zvdlg4kih04md5biakwhnmcw4j4pr")))) + (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. -(define-public sbcl-clingon - (let ((commit "379fc41e7b3977661f1454cf35acdbfae046d40d") - (revision "0")) +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-agutil + (let ((commit "df188d754d472da9faa1601a48f1f37bb7b34d68")) (package - (name "sbcl-clingon") - (version (git-version "0.5.0" revision commit)) + (name "sbcl-agutil") + (version (git-version "0.0.1" "1" commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/dnaeon/clingon") + (url "https://github.com/alex-gutev/agutil/") (commit commit))) - (file-name (git-file-name "cl-clingon" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "11p9lplx0fc5ghx601i150vrd46zdbvw0hfrbrrrdqplxaqpywq5")))) + (base32 "1xpnyzksk2xld64b6lw6rw0gn5zxlb77jwna59sd4yl7kxhxlfpf")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-rove)) (inputs - (list sbcl-bobbin - sbcl-cl-reexport - sbcl-split-sequence - sbcl-with-user-abort)) - (home-page "https://github.com/dnaeon/clingon") - (synopsis "Command-line option parsing library for Common Lisp") - (description - "@code{clingon} is a command-line option parsing library for Common -Lisp. Its features include: -@itemize -@item Support for subcommands -@item Support for command aliases -@item Support for short and long options -@item Related options may be grouped into categories -@item Short options may be collapsed into a single argument, as in -@option{-xyz} -@item Long options support the notations @option{--long-opt arg} and -@option{--long-opt=arg} -@item Automatic generation of help/usage information for commands and -subcommands -@item Out-of-the-box support for @option{--version} and @option{--help} -@item Support for various kinds of options including string, integer, -boolean, switch, enum, list, counter, filepath, etc. -@item Subcommands can look up global options defined in parent commands -@item Support for required options -@item Options can be initialized via environment variables -@item Single interface for creating options using @code{CLINGON:MAKE-OPTION} -@item Generate documentation for your command-line application -@item Support for @code{pre-hook} and @code{post-hook} actions for commands, -which allow invoking functions before and after the respective handler of the -command is executed -@item Support for Bash and Zsh completions -@item Extensibility, so if you don't find something you need you can extend it -by developing a new option kind, or even a new mechanism for initializing -options, e.g., by looking up an external key/value store -@end itemize") - (license license:bsd-2)))) + (list sbcl-alexandria sbcl-trivia)) + (home-page "https://github.com/alex-gutev/agutil/") + (synopsis "Collection of Common Lisp utilities") + (description "A collection of Common Lisp utility functions and macros +mostly not found in other utility packages.") + (license license:expat)))) -(define-public cl-clingon - (sbcl-package->cl-source-package sbcl-clingon)) +(define-public cl-agutil + (sbcl-package->cl-source-package sbcl-agutil)) -(define-public ecl-clingon - (sbcl-package->ecl-package sbcl-clingon)) +(define-public ecl-agutil + (sbcl-package->ecl-package sbcl-agutil)) -(define-public sbcl-command-line-args +(define-public sbcl-alea (package - (name "sbcl-command-line-args") - (version "0.1.1") + (name "sbcl-alea") + (version "1.0") (source (origin (method git-fetch) (uri (git-reference - (url "https://git.sr.ht/~whereiseveryone/command-line-args") + (url "https://github.com/eXodiquas/alea") (commit (string-append "v" version)))) - (file-name (git-file-name "cl-command-line-args" version)) + (file-name (git-file-name "cl-alea" version)) (sha256 - (base32 "140xnz2v0v3hfg3dp2fhidw8ns6lxd3a5knm07wqdp48ksg119wy")))) + (base32 "0nd9fdjli22ygfw3c8k9nh7d36c92866hics5aij6x7ly1q781gz")))) (build-system asdf-build-system/sbcl) - (arguments - '(#:asd-systems '("whereiseveryone.command-line-args"))) - (inputs - (list sbcl-alexandria - sbcl-charje.documentation - sbcl-cl-str - sbcl-serapeum - sbcl-trivia)) - (home-page "https://git.sr.ht/~whereiseveryone/command-line-args") - (synopsis "Automatically generate command line interfaces") - (description "Command-Line-Args provides a main macro (@code{command}) -that wraps a @code{defun} form and creates a new function that parses the -command line arguments. It has support for command-line options, positional, -and variadic arguments. It also generates a basic help message. The -interface is meant to be easy and non-intrusive.") - (license license:agpl3+))) - -(define-public cl-command-line-args - (sbcl-package->cl-source-package sbcl-command-line-args)) + (native-inputs (list sbcl-fiveam)) + (synopsis "Dice rolling library") + (description + "This package provides a Common Lisp library for dice rolling and working +with dice-roll statistics.") + (home-page "https://github.com/eXodiquas/alea") + (license license:expat))) -(define-public ecl-command-line-args - (sbcl-package->ecl-package sbcl-command-line-args)) +(define-public cl-alea + (sbcl-package->cl-source-package sbcl-alea)) -(define-public sbcl-cl-irc - (let ((commit "963823537c7bfcda2edd4c44d172192da6722175") - (revision "0")) - (package - (name "sbcl-cl-irc") - (version (git-version "0.9.2" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://salsa.debian.org/common-lisp-team/cl-irc.git") - (commit commit))) - (file-name (git-file-name "cl-irc" version)) - (sha256 - (base32 "1b3nqbb4pj377lxl47rfgrs82pidadnrc65l48bk553c2f59b52w")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-rt)) - (inputs - `(("cl+ssl" ,sbcl-cl+ssl) - ("flexi-streams" ,sbcl-flexi-streams) - ("split-sequence" ,sbcl-split-sequence) - ("usocket" ,sbcl-usocket))) - (arguments - `(#:asd-test-systems '("cl-irc-test"))) - (synopsis "IRC client library for Common Lisp") - (description "@code{cl-irc} is a Common Lisp IRC client library that -features (partial) DCC, CTCP and all relevant commands from the IRC -RFCs (RFC2810, RFC2811 and RFC2812). +(define-public ecl-alea + (sbcl-package->ecl-package sbcl-alea)) -Features: -@itemize -@item implements all commands in the RFCs -@item extra convenience commands such as op/deop, ban, ignore, etc. -@item partial DCC SEND/CHAT support -@item event driven model with hooks makes interfacing easy -@item the user can keep multiple connections -@item all CTCP commands -@end itemize\n") - (home-page "https://common-lisp.net/project/cl-irc/") - (license license:bsd-2)))) +(define-public sbcl-alexa + (package + (name "sbcl-alexa") + (version "2.1.1") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/quil-lang/alexa") + (commit (string-append "v" version)))) + (file-name (git-file-name "cl-alexa" version)) + (sha256 + (base32 "1y9jyz9gfmd02h492kf7v3mmpbhc0yfh4ka2rzd1vczq6fl8qgqv")))) + (build-system asdf-build-system/sbcl) + (native-inputs (list sbcl-fiasco)) + (inputs (list sbcl-alexandria sbcl-cl-ppcre)) + (synopsis "Lexical Analyzer Generator for Common Lisp") + (description + "ALEXA is a tool similar to lex or flex for generating lexical analyzers. +Unlike tools like lex, however, ALEXA defines a domain-specific language +within your Lisp program, so you don't need to invoke a separate tool.") + (home-page "https://github.com/quil-lang/alexa") + (license license:bsd-3))) -(define-public cl-irc - (sbcl-package->cl-source-package sbcl-cl-irc)) +(define-public ecl-alexa + (sbcl-package->ecl-package sbcl-alexa)) -(define-public ecl-cl-irc - (sbcl-package->ecl-package sbcl-cl-irc)) +(define-public cl-alexa + (sbcl-package->cl-source-package sbcl-alexa)) -(define-public sbcl-coleslaw - (let ((commit "e7e68ce6020d13b14bf212890a7d8973d7af3b40") +(define-public sbcl-alexandria + (let ((commit "009b7e532071d9777bdbd63b82d776555da95916") (revision "0")) (package - (name "sbcl-coleslaw") - (version (git-version "0.9.7" revision commit)) + (name "sbcl-alexandria") + (version (git-version "1.4" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/coleslaw-org/coleslaw") + (url "https://gitlab.common-lisp.net/alexandria/alexandria.git") (commit commit))) - (file-name (git-file-name "cl-coleslaw" version)) + (file-name (git-file-name "cl-alexandria" version)) (sha256 - (base32 "1w21a272q4x7nlr4kbmwwvkjvb4hpnw869byvy47vv361y7pimws")))) + (base32 "0pdj779j3nwzn8f1661vf00rrjrbks1xgiq0rvwjw6qyxsfqfnl9")))) (build-system asdf-build-system/sbcl) - (outputs '("out" "bin")) - (arguments - '(#:asd-systems '("coleslaw" "coleslaw-cli") - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda _ - (substitute* "plugins/publish-gh-pages.sh" - (("^rsync\\b") (which "rsync"))) - (substitute* '("plugins/rsync.lisp" - "src/coleslaw.lisp") - (("\\brun-program \"rsync\\b") - (string-append "run-program \"" (which "rsync")))))) - (add-after 'create-asdf-configuration 'build-program - (lambda* (#:key outputs #:allow-other-keys) - (build-program - (string-append (assoc-ref outputs "bin") "/bin/coleslaw") - outputs - #:dependencies '("coleslaw-cli") - #:entry-program '((apply (function coleslaw-cli::main) - arguments)) - #:compress? #t)))))) (native-inputs - (list sbcl-prove)) - (inputs - (list rsync - sbcl-3bmd - sbcl-alexandria - sbcl-cl-fad - sbcl-cl-ppcre - sbcl-cl-unicode - sbcl-clack - sbcl-closer-mop - sbcl-closure-template - sbcl-inferior-shell - sbcl-local-time - sbcl-trivia)) - (home-page "https://github.com/coleslaw-org/coleslaw") - (synopsis "Static site generator") + (list sbcl-rt)) + (synopsis "Collection of portable utilities for Common Lisp") (description - "Coleslaw is a static site generator written in Common Lisp.") - (license license:bsd-2)))) + "Alexandria is a collection of portable utilities. It does not contain +conceptual extensions to Common Lisp. It is conservative in scope, and +portable between implementations.") + (home-page "https://common-lisp.net/project/alexandria/") + (license license:public-domain)))) -(define-public cl-coleslaw - (sbcl-package->cl-source-package sbcl-coleslaw)) +(define-public cl-alexandria + (sbcl-package->cl-source-package sbcl-alexandria)) -(define-public ecl-coleslaw - (sbcl-package->ecl-package sbcl-coleslaw)) +(define-public ecl-alexandria + (sbcl-package->ecl-package sbcl-alexandria)) -(define-public sbcl-cl-all - (let ((commit "4ce1ea9d9f33c0dd6212044e7952a0c854757ace") +(define-public sbcl-alexandria-plus + (let ((commit "adafb09838a84895bedb119f8253b89b6a04a2c5") (revision "0")) (package - (name "sbcl-cl-all") - (version (git-version "1.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shinmera/cl-all") - (commit commit))) - (file-name (git-file-name "cl-all" version)) - (sha256 - (base32 "0n4sjarj373zpxn78m32rmhxnsnr8qahdslrd9vrkkwjpzar2bwp")))) - (build-system asdf-build-system/sbcl) - (outputs '("out" "bin")) - (arguments - (list - #:phases - #~(modify-phases %standard-phases - (add-after 'create-asdf-configuration 'build-program - (lambda* (#:key outputs #:allow-other-keys) - (build-program - (string-append (assoc-ref outputs "bin") "/bin/cl-all") - outputs - #:entry-program '((cl-all:toplevel arguments)) - #:compress? #t)))))) - (home-page "https://github.com/Shinmera/cl-all") - (synopsis "Evaluate Common Lisp expressions in multiple implementations") - (description "@samp{cl-all} is a library and script for evaluating Common -Lisp expressions in multiple implementations.") - (license license:zlib)))) - -(define-public cl-all - (sbcl-package->cl-source-package sbcl-cl-all)) - -(define-public sbcl-tripod - (let ((commit "b019a27cd7eb895870f84b0eb6c3edc5d7b05928") - (revision "1")) - (package - (name "sbcl-tripod") - (version (git-version "0.0.1" revision commit)) + (name "sbcl-alexandria-plus") + ;; Version is stated in the ASD file. + (version (git-version "1.1.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/aartaka/tripod") + (url "https://github.com/Symbolics/alexandria-plus") (commit commit))) - (file-name (git-file-name "cl-tripod" version)) + (file-name (git-file-name "cl-alexandria-plus" version)) (sha256 - (base32 "0y8sns6njq9x7km58vpj7gx4cia9zkcpng3d38300xk0nnk2kz8w")))) + (base32 "1w9r19610h599303gqlx2x5n8mmdynss2gyl7xilg5h6v8z3hkfl")))) (build-system asdf-build-system/sbcl) - (outputs '("out" "bin")) (arguments - (list #:phases - #~(modify-phases %standard-phases - (add-after 'create-asdf-configuration 'build-program - (lambda* (#:key outputs #:allow-other-keys) - ;; FIXME: Using #$output:bin here prevents cl-tripod and - ;; ecl-tripod from building, but using assoc-ref works. - (build-program (string-append ;; #$output:bin - (assoc-ref outputs "bin") - "/bin/tripod") - outputs - #:entry-program '((tripod:entry-point)) - #:compress? #t)))))) + '(#:asd-systems '("alexandria+"))) + (native-inputs + (list sbcl-parachute)) (inputs - (list sbcl-alexandria - sbcl-cl-gopher - sbcl-cl-markdown - sbcl-clss - sbcl-hunchentoot - sbcl-local-time - sbcl-nactivitypub - sbcl-njson - sbcl-phos - sbcl-plump - sbcl-trivial-mimes)) - (home-page "https://aartaka.me/blog/tripod") - (synopsis "Common Lisp web server aiming to ease website hosting") + (list sbcl-alexandria)) + (home-page "https://symbolics.github.io/alexandria-plus/") + (synopsis "Conservative set of extensions to Alexandria utilities") (description - "Tripod is a Common Lisp web server aiming to ease plain text, HTML, -and Gopher website hosting.") - (license license:bsd-2)))) + "@code{cl-alexandria-plus} is a conservative set of extensions to +@code{cl-alexandria} utilities.") + (license license:ms-pl)))) -(define-public cl-tripod - ;; No "bin" output for the source package. - (let ((pkg (sbcl-package->cl-source-package sbcl-tripod))) - (package/inherit pkg - (outputs '("out"))))) +(define-public cl-alexandria-plus + (sbcl-package->cl-source-package sbcl-alexandria-plus)) -(define-public ecl-tripod - ;; FIXME: Making a standalone binary doesn't work with ECL. - (let ((pkg (sbcl-package->ecl-package sbcl-tripod))) - (package/inherit pkg - (outputs '("out")) - (arguments - (substitute-keyword-arguments (package-arguments pkg) - ((#:phases phases) - #~(modify-phases #$phases - (delete 'build-program)))))))) +(define-public ecl-alexandria-plus + (sbcl-package->ecl-package sbcl-alexandria-plus)) -(define-public sbcl-trivial-timeout - (let ((commit "e70d9b4f7caeab83ea6ac50d724470fe49561e66") - (revision "2")) +(define-public sbcl-alloy + (let ((commit "628974de537affb5b44ad548347f67c16efffcfc") + (revision "3")) (package - (name "sbcl-trivial-timeout") - (version (git-version "0.1.5" revision commit)) + (name "sbcl-alloy") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/hraban/trivial-timeout") + (url "https://github.com/Shirakumo/alloy") (commit commit))) - (file-name (git-file-name "trivial-timeout" version)) + (file-name (git-file-name "cl-alloy" version)) (sha256 - (base32 "0s8z9aj6b3kv21yiyk13cjylzf5zlnw9v86vcff477m1gk9yddjs")))) + (base32 "0fx294qwxshgijss000pbjbnbwxqvxyw6p3mva36qljhbbkw2fxy")))) (build-system asdf-build-system/sbcl) (native-inputs - (list sbcl-lift)) - (home-page "https://github.com/hraban/trivial-timeout") - (synopsis "Timeout library for Common Lisp") + (list sbcl-alexandria sbcl-parachute)) + (inputs + (list sbcl-array-utils sbcl-closer-mop sbcl-documentation-utils + sbcl-float-features sbcl-colored sbcl-stealth-mixin + sbcl-cl-opengl sbcl-font-discovery sbcl-uax-14 sbcl-sdf)) + (arguments + ;; Dismiss alloy-svg, since it is not completed: + ;; https://github.com/Shirakumo/alloy/issues/24 + '(#:asd-systems '("alloy" + "alloy-animation" + "alloy-opengl" + "alloy-opengl-msdf" + "alloy-opengl-png" + "alloy-simple" + "alloy-simple-presentations" + "alloy-windowing"))) + (home-page "https://shirakumo.github.io/alloy/") + (synopsis + "Common Lisp user interface protocol and toolkit implementation") (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") - (version "0.9.3") - (source (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/sionescu/bordeaux-threads") - (commit (string-append "v" version)))) - (sha256 - (base32 "0pp3w5hsph47sqagr4j2pbg3ddb29jx93zg8kvxsp2c4flp0qz0f")) - (file-name (git-file-name "cl-bordeaux-threads" version)))) - (inputs (list sbcl-alexandria - sbcl-global-vars - sbcl-trivial-features - sbcl-trivial-garbage)) - (native-inputs (list sbcl-fiveam)) - (build-system asdf-build-system/sbcl) - (arguments - (list - #:phases - #~(modify-phases %standard-phases - (add-after 'unpack 'adjust-test-sleep - (lambda _ - ;; 0.001 is too short for some slower machines. - (substitute* '("test/tests-v1.lisp" - "test/tests-v2.lisp") - (("sleep 0\\.001") "sleep 0.002"))))))) - (synopsis "Portable shared-state concurrency library for Common Lisp") - (description "BORDEAUX-THREADS is a proposed standard for a minimal -MP/Threading interface. It is similar to the CLIM-SYS threading and lock -support.") - (home-page "https://common-lisp.net/project/bordeaux-threads/") - (license license:x11))) - -(define-public cl-bordeaux-threads - (sbcl-package->cl-source-package sbcl-bordeaux-threads)) - -(define-public ecl-bordeaux-threads - (sbcl-package->ecl-package sbcl-bordeaux-threads)) - -(define-public sbcl-trivial-gray-streams - (let ((revision "1") - (commit "2b3823edbc78a450db4891fd2b566ca0316a7876")) - (package - (name "sbcl-trivial-gray-streams") - (version (git-version "2.0" revision commit)) - (source - (origin - (method git-fetch) - (uri - (git-reference - (url "https://github.com/trivial-gray-streams/trivial-gray-streams") - (commit commit))) - (sha256 - (base32 "1hipqwwd5ylskybd173rvlsk7ds4w4nq1cmh9952ivm6dgh7pwzn")) - (file-name (git-file-name "cl-trivial-gray-streams" version)))) - (build-system asdf-build-system/sbcl) - (synopsis "Compatibility layer for Gray streams implementations") - (description "Gray streams is an interface proposed for inclusion with -ANSI CL by David N. Gray. The proposal did not make it into ANSI CL, but most -popular CL implementations implement it. This package provides an extremely -thin compatibility layer for gray streams.") - (home-page "https://www.cliki.net/trivial-gray-streams") - (license license:x11)))) + "Alloy is a user interface toolkit. It is defined through a set of +protocols that allow for a clear interface, as well as a standardised way to +integrate Alloy into a target backend.") + (license license:zlib)))) -(define-public cl-trivial-gray-streams - (sbcl-package->cl-source-package sbcl-trivial-gray-streams)) +(define-public cl-alloy + (sbcl-package->cl-source-package sbcl-alloy)) -(define-public ecl-trivial-gray-streams - (sbcl-package->ecl-package sbcl-trivial-gray-streams)) +(define-public ecl-alloy + (sbcl-package->ecl-package sbcl-alloy)) -(define-public sbcl-flexi-streams - (let ((commit "74a1027311371a57258eba1bc908e050f5702277") +(define-public sbcl-amb + (let ((commit "884bef69a1ea02f3b9deae0341e1a038ff31b896") (revision "0")) (package - (name "sbcl-flexi-streams") - (version (git-version "1.0.19" revision commit)) - (source + (name "sbcl-amb") + (version (git-version "1.0.0" revision commit)) + (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/edicl/flexi-streams") + (url "https://github.com/phoe/amb") (commit commit))) - (file-name (git-file-name "cl-flexi-streams" version)) + (file-name (git-file-name "cl-amb" version)) (sha256 - (base32 "04azqvz11s8dngy49bjl19hrfn0ip1b7m0szm4hlppq364msil7b")))) - (build-system asdf-build-system/sbcl) - (arguments - (list #:phases - #~(modify-phases %standard-phases - (add-after 'unpack 'make-git-checkout-writable - (lambda _ - (for-each make-file-writable (find-files "."))))))) - (inputs - (list sbcl-trivial-gray-streams)) - (synopsis "Implementation of virtual bivalent streams for Common Lisp") - (description "Flexi-streams is an implementation of \"virtual\" bivalent -streams that can be layered atop real binary or bivalent streams and that can -be used to read and write character data in various single- or multi-octet -encodings which can be changed on the fly. It also supplies in-memory binary -streams which are similar to string streams.") - (home-page "http://weitz.de/flexi-streams/") - (license license:bsd-3)))) - -(define-public cl-flexi-streams - (sbcl-package->cl-source-package sbcl-flexi-streams)) - -(define-public ecl-flexi-streams - (sbcl-package->ecl-package sbcl-flexi-streams)) - -(define-public sbcl-cl-abnf - ;; There are no releases - (let ((commit "ba1fbb104dedbdaddb1ef93d2e4da711bd96cd70") - (revision "1")) - (package - (name "sbcl-cl-abnf") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/dimitri/cl-abnf") - (commit commit))) - (file-name (git-file-name "cl-abnf" version)) - (sha256 - (base32 "0f09nsndxa90acm71zd4qdnp40v705a4sqm04mnv9x76h6dlggmz")))) + (base32 "1klh1aakklj1famrff0sccnwlv8238b1q446288aqnqgxxw6pf21")))) (build-system asdf-build-system/sbcl) (inputs - `(("cl-ppcre" ,sbcl-cl-ppcre) - ("esrap" ,sbcl-esrap))) - (arguments - `(#:asd-systems '("abnf"))) - (home-page "https://github.com/dimitri/cl-abnf") - (synopsis "ABNF parser generator for Common Lisp") - (description "This Common Lisp library implements a parser generator for -the ABNF grammar format as described in RFC2234. The generated parser is a -regular expression scanner provided by the cl-ppcre lib, which means that we -can't parse recursive grammar definition. One such definition is the ABNF -definition as given by the RFC. Fortunately, as you have this lib, you most -probably don't need to generate another parser to handle that particular ABNF -grammar.") + (list sbcl-alexandria)) + (native-inputs + (list sbcl-parachute)) + (synopsis "Implementation of John McCarthy's ambiguous operator") + (description + "@code{cl-amb} provides an implementation of John McCarthy's ambiguous +operator in portable Common Lisp.") + (home-page "https://github.com/phoe/amb/") (license license:expat)))) -(define-public cl-abnf - (sbcl-package->cl-source-package sbcl-cl-abnf)) - -(define-public ecl-cl-abnf - (sbcl-package->ecl-package sbcl-cl-abnf)) - -(define-public sbcl-select - (let ((commit "df7920fc451b6d15345040ce4a3ee1ea2818ab1a") - (revision "0")) - (package - (name "sbcl-select") - (version (git-version "1.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Lisp-Stat/select") - (commit commit))) - (file-name (git-file-name "cl-select" version)) - (sha256 - (base32 "0bhpvfqp7n33pia4y62qi31bx86gjl2nxjy529rfawac57c9rxv3")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-alexandria - sbcl-anaphora - sbcl-let-plus)) - (native-inputs - (list sbcl-fiveam)) - (home-page "https://lisp-stat.github.io/select/") - (synopsis "Library for taking slices from array-like objects") - (description - "This is a library for selecting portions of sequences, arrays or -data-frames.") - (license license:ms-pl)))) - -(define-public cl-select - (sbcl-package->cl-source-package sbcl-select)) +(define-public cl-amb + (sbcl-package->cl-source-package sbcl-amb)) -(define-public ecl-select - (sbcl-package->ecl-package sbcl-select)) +(define-public ecl-amb + (sbcl-package->ecl-package sbcl-amb)) -(define-public sbcl-cl-ppcre +(define-public sbcl-anaphora (package - (name "sbcl-cl-ppcre") - (version "2.1.1") + (name "sbcl-anaphora") + (version "0.9.8") (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/edicl/cl-ppcre") - (commit (string-append "v" version)))) - (file-name (git-file-name "cl-ppcre" version)) + (url "https://github.com/tokenrove/anaphora") + (commit version))) (sha256 - (base32 "0dwvr29diqzcg5n6jvbk2rnd90i05l7n828hhw99khmqd0kz7xsi")))) + (base32 "1ds5ab0rzkrhfl29xpvmvyxmkdyj9mi19p330pz603lx95njjc0b")) + (file-name (git-file-name "cl-anaphora" version)))) (build-system asdf-build-system/sbcl) (native-inputs - (list sbcl-flexi-streams)) - (arguments - `(#:phases - (modify-phases %standard-phases - (add-after 'unpack 'disable-ppcre-unicode - ;; cl-ppcre and cl-ppcre-unicode are put in different packages - ;; to work around the circular dependency between edicl/cl-ppcre - ;; and edicl/cl-unicode. - (lambda _ - (delete-file "cl-ppcre-unicode.asd") - #t))))) - (synopsis "Portable regular expression library for Common Lisp") - (description "CL-PPCRE is a portable regular expression library for Common -Lisp, which is compatible with perl. It is pretty fast, thread-safe, and -compatible with ANSI-compliant Common Lisp implementations.") - (home-page "http://weitz.de/cl-ppcre/") - (license license:bsd-2))) + (list sbcl-rt)) + (synopsis "The anaphoric macro collection from Hell") + (description + "Anaphora is the anaphoric macro collection from Hell: it includes many +new fiends in addition to old friends like @command{aif} and +@command{awhen}.") + (home-page "https://github.com/tokenrove/anaphora") + (license license:public-domain))) -(define-public cl-ppcre - (sbcl-package->cl-source-package sbcl-cl-ppcre)) +(define-public cl-anaphora + (sbcl-package->cl-source-package sbcl-anaphora)) -(define-public ecl-cl-ppcre - (sbcl-package->ecl-package sbcl-cl-ppcre)) +(define-public ecl-anaphora + (sbcl-package->ecl-package sbcl-anaphora)) -(define-public sbcl-one-more-re-nightmare - (let ((commit "5b0b02e59f90964baf5737abd13300fa82f27667") +;;; Split the antik package in two to work around the circular dependency +;;; between antik/antik and antik/gsll. +(define-public sbcl-antik-base + (let ((commit "e4711a69b3d6bf37b5727af05c3cfd03e8428ba3") (revision "1")) (package - (name "sbcl-one-more-re-nightmare") + (name "sbcl-antik-base") (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/telekons/one-more-re-nightmare") + (url "https://gitlab.common-lisp.net/antik/antik.git") (commit commit))) - (file-name (git-file-name "cl-one-more-re-nightmare" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "0mwgjgnp8dsf2zn0290px5q89z93zs0v4dhvs3rcir4mpiw8rbsn")))) + (base32 + "047ga2c38par2xbgg4qx6hwv06qhf1c1f67as8xvir6s80lip1km")))) (build-system asdf-build-system/sbcl) + (inputs + `(("alexandria" ,sbcl-alexandria) + ("cffi" ,sbcl-cffi) + ("cl-ppcre" ,sbcl-cl-ppcre) + ("drakma" ,sbcl-drakma) + ("fare-utils" ,sbcl-fare-utils) + ("iterate" ,sbcl-iterate) + ("metabang-bind" ,sbcl-metabang-bind) + ("named-readtables" ,sbcl-named-readtables) + ("split-sequence" ,sbcl-split-sequence) + ("static-vectors" ,sbcl-static-vectors) + ("trivial-garbage" ,sbcl-trivial-garbage) + ("trivial-utf-8" ,sbcl-trivial-utf-8))) + (native-inputs + (list sbcl-lisp-unit)) (arguments - '(#:asd-test-systems '("one-more-re-nightmare-tests") + '(#:asd-systems '("antik-base" + "foreign-array") #:phases (modify-phases %standard-phases - (add-after 'unpack 'fix-tests + (add-after 'unpack 'fix-build (lambda _ - (substitute* "Tests/one-more-re-nightmare-tests.asd" - ((":depends-on") - (string-append - ":perform (test-op (o c) (symbol-call :one-more-re-nightmare-tests '#:run-tests))" - "\n :depends-on")))))))) - (native-inputs - (list sbcl-lparallel sbcl-parachute)) - (inputs - (list sbcl-alexandria - sbcl-babel - sbcl-bordeaux-threads - sbcl-dynamic-mixins - sbcl-esrap - sbcl-stealth-mixin - sbcl-trivia - sbcl-trivial-indent)) - (home-page "https://github.com/telekons/one-more-re-nightmare") - (synopsis "Regular expression compiler in Common Lisp") - (description "@code{one-more-re-nightmare} is a regular expression engine -that uses the technique presented in Regular-expression derivatives -re-examined (Owens, Reppy and Turon, 2009; -@url{doi:10.1017/S0956796808007090}) to interpret and compile regular -expressions.") - (license license:bsd-2)))) - -(define-public cl-one-more-re-nightmare - (sbcl-package->cl-source-package sbcl-one-more-re-nightmare)) + (for-each delete-file + '("antik.asd" + "physical-dimension.asd" + "science-data.asd")) + #t))))) + (synopsis "Scientific and engineering computation in Common Lisp") + (description + "Antik provides a foundation for scientific and engineering +computation in Common Lisp. It is designed not only to facilitate +numerical computations, but to permit the use of numerical computation +libraries and the interchange of data and procedures, whether +foreign (non-Lisp) or Lisp libraries. It is named after the +Antikythera mechanism, one of the oldest examples of a scientific +computer known.") + (home-page "https://common-lisp.net/project/antik/") + (license license:gpl3)))) -(define-public ecl-one-more-re-nightmare - (sbcl-package->ecl-package sbcl-one-more-re-nightmare)) +(define-public cl-antik-base + (sbcl-package->cl-source-package sbcl-antik-base)) -(define-public sbcl-parse - (let ((commit "2351ee78acac065fcf10b8713d3f404e2e910786") - (revision "1")) +(define-public ecl-antik-base + (let ((pkg (sbcl-package->ecl-package sbcl-antik-base))) (package - (name "sbcl-parse") - (version (git-version "1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/massung/parse") - (commit commit))) - (file-name (git-file-name "parse" version)) - (sha256 - (base32 "0l18yabyh7jizm5lgvra0jxi8s1cfwghidi6ix1pyixjkdbjlmvy")))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/massung/parse") - (synopsis "Monadic parsing for Common Lisp") - (description - "PARSE is a simple token parsing library for Common Lisp.") - (license license:asl2.0)))) + (inherit pkg) + (arguments + (substitute-keyword-arguments (package-arguments pkg) + ((#:phases phases) + `(modify-phases ,phases + (add-after 'unpack 'fix-readtable + (lambda _ + (substitute* "input-output/readtable.lisp" + (("#-ccl") + "#-(or ccl ecl)")) + #t))))))))) -(define-public ecl-parse - (sbcl-package->ecl-package sbcl-parse)) +(define-public sbcl-antik + (package + (inherit sbcl-antik-base) + (name "sbcl-antik") + (inputs + `(("antik-base" ,sbcl-antik-base) + ("gsll" ,sbcl-gsll))) + (arguments + '(#:asd-systems '("antik" + "science-data") + #:phases + (modify-phases %standard-phases + (add-after 'unpack 'fix-build + (lambda _ + (for-each delete-file + '("antik-base.asd" + "foreign-array.asd")) + #t))))))) -(define-public cl-parse - (sbcl-package->cl-source-package sbcl-parse)) +(define-public cl-antik + (sbcl-package->cl-source-package sbcl-antik)) -(define-public sbcl-re - (let ((commit "cfbc1f482970221e80d445080a188fd5c755cd2c") - (revision "1")) +(define-public sbcl-april + (let ((commit "bdd74f168ec82f28fe4ab692f2c0af39441a5701") + (revision "3")) (package - (name "sbcl-re") + (name "sbcl-april") (version (git-version "1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/massung/re") - (commit commit))) - (file-name (git-file-name "re" version)) - (sha256 - (base32 "1y2gq2sckspnq8118bix55p2j43dk9qn3p8a2rplp1ip2qxqbb1i")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-parse)) - (home-page "https://github.com/massung/re") - (synopsis "Lua-style Pattern Matching for Common Lisp") - (description - "RE is a small, portable, lightweight, and quick, regular -expression library for Common Lisp. It is a non-recursive, backtracing VM.") - (license license:asl2.0)))) - -(define-public ecl-re - (sbcl-package->ecl-package sbcl-re)) - -(define-public cl-re - (sbcl-package->cl-source-package sbcl-re)) - -(define-public sbcl-boost-json - (let ((commit "eca166f5ff1f10bad14e00b9fd5bf9fcf3691a47") - (revision "0")) - (package - (name "sbcl-boost-json") - (version (git-version "1.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/cl-boost/json") + (url "https://github.com/phantomics/april") (commit commit))) - (file-name (git-file-name "cl-boost-json" version)) + (file-name (git-file-name "cl-april" version)) (sha256 - (base32 "12k0470899qsll2qixksxf2vrhjmskk3nzp1di9k04n1b29nrakd")))) + (base32 "0hvlp2286z1ksa7jr7r661kdr0lpfv25n5chl72jrzq5zz70lidx")) + (modules '((guix build utils))) + (snippet '(begin + ;; Remove bundled Apache-relicensed MaxPC. + (delete-file-recursively "maxpc-apache") + ;; Ensure references are to upstream MaxPC. + (substitute* "vex/vex.asd" + (("maxpc-apache") "maxpc")))))) (build-system asdf-build-system/sbcl) - (arguments - '(#:phases - (modify-phases %standard-phases - ;; See <https://github.com/cl-boost/json/pull/2>. - (add-after 'unpack 'fix-decode-symbol - (lambda _ - (substitute* '("decode.lisp" "encode.lisp") - (("formfeed") "page"))))))) - (home-page "https://github.com/cl-boost/json") - (synopsis "JSON encoding and decoding for Common Lisp") + (inputs + (list sbcl-alexandria + sbcl-array-operations + sbcl-cl-ppcre + sbcl-cl-unicode + sbcl-lparallel + sbcl-maxpc + sbcl-parse-number + sbcl-prove + sbcl-random-state + sbcl-serapeum + sbcl-simple-date-time + sbcl-symbol-munger + sbcl-trivia)) + (home-page "https://github.com/phantomics/april") + (synopsis "Array Programming Re-Imagined in Lisp") (description - "BOOST-JSON is a simple JSON parsing library for Common Lisp.") + "April compiles a subset of the APL programming language into +Common Lisp. Leveraging Lisp's powerful macros and numeric processing +faculties, it brings APL's expressive potential to bear for Lisp developers. +Replace hundreds of lines of number-crunching code with a single line of +APL.") (license license:asl2.0)))) -(define-public cl-boost-json - (sbcl-package->cl-source-package sbcl-boost-json)) +(define-public cl-april + (sbcl-package->cl-source-package sbcl-april)) -(define-public ecl-boost-json - (sbcl-package->ecl-package sbcl-boost-json)) +(define-public ecl-april + (sbcl-package->ecl-package sbcl-april)) -(define-public sbcl-boost-parse - (let ((commit "c8f7e536b950752f3e35003e7ee0446e0fd51b50") - (revision "0")) +(define-public sbcl-archive + (let ((commit "631271c091ed02994bec3980cb288a2cf32c7cdc") + (revision "1")) (package - (name "sbcl-boost-parse") - (version (git-version "1.0" revision commit)) + (name "sbcl-archive") + (version (git-version "0.9" revision commit)) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/sharplispers/archive") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "0pvsc9fmybx7rxd0kmzq4shi6hszdpwdc1sfy7jwyfxf8n3hnv4p")))) + (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-cl-fad sbcl-trivial-gray-streams)) + (synopsis "Common Lisp library for tar and cpio archives") + (description + "This is a Common Lisp library to read and write disk-based file +archives such as those generated by the tar and cpio programs on Unix.") + (home-page "https://github.com/sharplispers/archive") + (license license:bsd-3)))) + +(define-public cl-archive + (sbcl-package->cl-source-package sbcl-archive)) + +(define-public ecl-archive + (sbcl-package->ecl-package sbcl-archive)) + +(define-public sbcl-arnesi + (let ((commit "1e7dc4cb2cad8599113c7492c78f4925e839522e") + (revision "1")) + (package + (name "sbcl-arnesi") + (version (git-version "2.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/cl-boost/parse") + (url "https://github.com/AccelerationNet/arnesi") (commit commit))) - (file-name (git-file-name "cl-boost-parse" version)) + (file-name (git-file-name "arnesi" version)) (sha256 - (base32 "0djnp392n9wgpr9r2ycnwkglad5mn285yvr53jx3g7anm2p8r0vf")))) + (base32 "0jgj2xgd1gq6rf8ia43lkmbrbxnp8rgs053br9azfa25ygk3ikbh")))) (build-system asdf-build-system/sbcl) - (home-page "https://github.com/cl-boost/parse") - (synopsis "Monadic parsing for Common Lisp") + (arguments + ;; FIXME: (Sharlatan-20210523T190315+0100): Tests failed on + ;; special-lisp-var-rebount-in/cc + ;; + ;; ; processing (TEST SPECIAL-LISP-VAR-REBOUND-IN/CC ...) + ;; ; wrote .../sbcl/arnesi/t/call-cc-tmp5GEXGEG5.fasl + ;; ; compilation finished in 0:00:00.028 + ;; Unhandled SIMPLE-ERROR in thread + ;; #<SB-THREAD:THREAD "main thread" RUNNING {100B768173}>: + ;; Sorry, No walker for the special operater DECLARE defined. + ;; + ;; Backtrace for: #<SB-THREAD:THREAD "main thread" RUNNING {100B768173}> + ;; 0: (SB-DEBUG::DEBUGGER-DISABLED-HOOK #<SIMPLE-ERROR "Sorry, + ;; No walker for the special operater ~S defined." + ;; {1001FAF9D3}> #<unused argument> :QUIT T) + ;; + `(#:tests? #f)) + (native-inputs + (list sbcl-fiveam)) + (inputs + `(("cl-ppcre" ,sbcl-cl-ppcre) + ("collectors" ,sbcl-collectors) + ("swank" ,sbcl-slime-swank))) + (home-page "https://github.com/AccelerationNet/arnesi") + (synopsis "Common Lisp utility suite") (description - "BOOST-PARSE is a simple token parsing library for Common Lisp.") - (license license:asl2.0)))) + "ARNESI is Common Lisp utilities library similar to ALEXANDRIA, ANAPHORA +or GOLDEN-UTILS.") + (license license:bsd-3)))) -(define-public cl-boost-parse - (sbcl-package->cl-source-package sbcl-boost-parse)) +(define-public ecl-arnesi + (sbcl-package->ecl-package sbcl-arnesi)) -(define-public ecl-boost-parse - (sbcl-package->ecl-package sbcl-boost-parse)) +(define-public cl-arnesi + (sbcl-package->cl-source-package sbcl-arnesi)) -(define-public sbcl-boost-re - (let ((commit "d279fc58abf76d0c40aa6cde42e17a0591bc2c5d") +(define-public sbcl-array-operations + (let ((commit "75cbc3b1adb2e3ce2109489753d0f290b071e81b") (revision "0")) (package - (name "sbcl-boost-re") - (version (git-version "1.0" revision commit)) + (name "sbcl-array-operations") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/cl-boost/re") + (url "https://github.com/bendudson/array-operations") (commit commit))) - (file-name (git-file-name "cl-boost-re" version)) + (file-name (git-file-name "array-operations" version)) (sha256 - (base32 "1h9c2rdhw6m1pm67gqbj46y2vb1kc3i1c9y3l4qhgfz14dbk80a2")))) + (base32 "0ip49hhq32w80qsc7jmspyda5r2rsszvw0mk2r3341cld78sz9ya")))) (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-alexandria sbcl-clunit2)) (inputs - (list sbcl-boost-parse)) - (home-page "https://github.com/cl-boost/re") - (synopsis "Lua-style string pattern matching for Common Lisp") + (list sbcl-let-plus)) + (synopsis "Simple array operations library for Common Lisp") (description - "BOOST-RE is a small, portable, lightweight, and quick, regular -expression library for Common Lisp. It is a non-recursive, backtracking VM.") - (license license:asl2.0)))) + "This library is a collection of functions and macros for manipulating +Common Lisp arrays and performing numerical calculations with them.") + (home-page "https://github.com/bendudson/array-operations") + (license license:expat)))) -(define-public cl-boost-re - (sbcl-package->cl-source-package sbcl-boost-re)) +(define-public cl-array-operations + (sbcl-package->cl-source-package sbcl-array-operations)) -(define-public ecl-boost-re - (sbcl-package->ecl-package sbcl-boost-re)) +(define-public ecl-array-operations + (sbcl-package->ecl-package sbcl-array-operations)) -(define-public sbcl-boost-lexer - (let ((commit "139ca9e9580f890698deec05061e495376b7735a") +(define-public sbcl-array-utils + (let ((commit "29da8fccf6093fe8f8c7b2daef7de1a428ef1834") (revision "0")) (package - (name "sbcl-boost-lexer") - (version (git-version "1.0" revision commit)) + (name "sbcl-array-utils") + (version (git-version "1.2.0" revision commit)) (source (origin (method git-fetch) - (uri (git-reference - (url "https://github.com/cl-boost/lexer") - (commit commit))) - (file-name (git-file-name "cl-boost-lexer" version)) + (uri + (git-reference + (url "https://github.com/Shinmera/array-utils") + (commit commit))) + (file-name (git-file-name "cl-array-utils" version)) (sha256 - (base32 "01vsczb5cn62k2hkkn39xwh5fjn2x0b507n7afia98jnhhk3d5x4")))) + (base32 "1d66s2inb9hpw27hdb20x27dychmpn1mn35v0mlsib848qdz87az")))) (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-parachute)) (inputs - (list sbcl-boost-re)) - (home-page "https://github.com/cl-boost/lexer") - (synopsis "String tokenizing for Common Lisp") + (list sbcl-documentation-utils)) + (synopsis "Tiny collection of array and vector utilities for Common Lisp") (description - "BOOST-LEXER is a tokenizer for Common Lisp that makes heavy use of -BOOST-RE.") - (license license:asl2.0)))) + "A miniature toolkit that contains some useful shifting/popping/pushing +functions for arrays and vectors. Originally from Plump.") + (home-page "https://shinmera.github.io/array-utils/") + (license license:zlib)))) -(define-public cl-boost-lexer - (sbcl-package->cl-source-package sbcl-boost-lexer)) +(define-public cl-array-utils + (sbcl-package->cl-source-package sbcl-array-utils)) -(define-public ecl-boost-lexer - (sbcl-package->ecl-package sbcl-boost-lexer)) +(define-public ecl-array-utils + (sbcl-package->ecl-package sbcl-array-utils)) -(define-public sbcl-ubiquitous - (let ((commit "35eb7bd9e1b3daee1705f6b41260775180cce8af") - (revision "1")) +(define-public sbcl-arrow-macros + ;; The latest upstream version tag is dated (pushed in 2020), use the latest + ;; commit instead. + (let ((commit "16bdfd31298182099c7d70df4598104e5a38b05e") + (revision "0")) (package - (name "sbcl-ubiquitous") - (version (git-version "2.0.0" revision commit)) + (name "sbcl-arrow-macros") + (version (git-version "0.2.7" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/Shinmera/ubiquitous") + (url "https://github.com/hipeta/arrow-macros") (commit commit))) - (file-name (git-file-name "ubiquitous" version)) + (file-name (git-file-name "arrow-macros" version)) (sha256 - (base32 "1xlkaqmjcpkiv2xl2s2pvvrv976dlc846wm16s1lj62iy1315i49")))) + (base32 "0q4vpysk4h9ghs5zmnzzilky9jyz7i8n0x0p98nq528crbrkh6c4")))) (build-system asdf-build-system/sbcl) - (inputs - `(("bordeaux-threads" ,sbcl-bordeaux-threads))) - (arguments - '(#:asd-systems '("ubiquitous" - "ubiquitous-concurrent"))) - (home-page "https://shinmera.github.io/ubiquitous/") - (synopsis "Application configuration mechanism for Common Lisp") + (native-inputs (list sbcl-fiveam)) + (home-page "https://github.com/hipeta/arrow-macros/") + (synopsis "Clojure-like arrow macros in 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)))) + "Arrow-macros provides clojure-like arrow macros (ex. ->, ->>) and diamond wands +in swiss-arrows.") + (license license:expat)))) -(define-public ecl-ubiquitous - (sbcl-package->ecl-package sbcl-ubiquitous)) +(define-public cl-arrow-macros + (sbcl-package->cl-source-package sbcl-arrow-macros)) -(define-public cl-ubiquitous - (sbcl-package->cl-source-package sbcl-ubiquitous)) +(define-public ecl-arrow-macros + (sbcl-package->ecl-package sbcl-arrow-macros)) -(define-public sbcl-uax-14 - (let ((commit "0432162525119c401d3d705bb9bcc9580a03914f") - (revision "1")) +(define-public sbcl-arrows + (let ((commit "df7cf0067e0132d9697ac8b1a4f1b9c88d4f5382") + (revision "0")) (package - (name "sbcl-uax-14") - (version (git-version "1.0.0" revision commit)) + (name "sbcl-arrows") + (version (git-version "0.2.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/Shinmera/uax-14") + (url "https://gitlab.com/Harleqin/arrows.git") (commit commit))) - (file-name (git-file-name "uax-14" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "1sb2s58k01yjaggaq8i7kbyfsh6mzyqbiz1vm59smxn9qqwd8apm")))) + (base32 + "042k9vkssrqx9nhp14wdzm942zgdxvp35mba0p2syz98i75im2yy")))) (build-system asdf-build-system/sbcl) (native-inputs - (list sbcl-parachute sbcl-cl-ppcre)) - (inputs - (list sbcl-documentation-utils)) - (arguments - `(#:asd-systems '("uax-14"))) - (home-page "https://shinmera.github.io/uax-14/") - (synopsis "Unicode Standard Annex #14 for standardised line breaking") + (list sbcl-hu.dwim.stefil)) + (synopsis "Clojure-like arrow macros for Common Lisp") (description - "This is an implementation of the Unicode Standards Annex -#14 (@url{http://www.unicode.org/reports/tr14/}) line breaking algorithm. It -provides a fast and convenient way to determine line breaking opportunities in -text. - -Note that this algorithm does not support break opportunities that require -morphological analysis. In order to handle such cases, please consult a system -that provides this kind of capability, such as a hyphenation algorithm. - -Also note that this system is completely unaware of layouting decisions. Any -kind of layouting decisions, such as which breaks to pick, how to space -between words, how to handle bidirectionality, and what to do in emergency -situations when there are no breaks on an overfull line are left up to the -user.") - (license license:zlib)))) - -(define-public ecl-uax-14 - (sbcl-package->ecl-package sbcl-uax-14)) - -(define-public cl-uax-14 - (sbcl-package->cl-source-package sbcl-uax-14)) - -(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 - (list 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)) - -(define-public ecl-uax-15 - (sbcl-package->ecl-package sbcl-uax-15)) - -(define-public sbcl-cl-unicode - (package - (name "sbcl-cl-unicode") - (version "0.1.6") - (source (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/edicl/cl-unicode") - (commit (string-append "v" version)))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "0ykx2s9lqfl74p1px0ik3l2izd1fc9jd1b4ra68s5x34rvjy0hza")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-flexi-streams)) - (inputs - (list sbcl-cl-ppcre)) - (home-page "http://weitz.de/cl-unicode/") - (synopsis "Portable Unicode library for Common Lisp") - (description "CL-UNICODE is a portable Unicode library Common Lisp, which -is compatible with perl. It is pretty fast, thread-safe, and compatible with -ANSI-compliant Common Lisp implementations.") - (license license:bsd-2))) - -(define-public ecl-cl-unicode - (sbcl-package->ecl-package sbcl-cl-unicode)) - -(define-public cl-unicode - (sbcl-package->cl-source-package sbcl-cl-unicode)) - -(define-public sbcl-cl-ppcre-unicode - (package (inherit sbcl-cl-ppcre) - (name "sbcl-cl-ppcre-unicode") - (inputs - (list sbcl-cl-ppcre sbcl-cl-unicode)) - (arguments - `(#:phases - (modify-phases %standard-phases - (add-after 'unpack 'disable-ppcre - ;; cl-ppcre and cl-ppcre-unicode are put in different packages - ;; to work around the circular dependency between edicl/cl-ppcre - ;; and edicl/cl-unicode. - (lambda _ - (delete-file "cl-ppcre.asd") - #t))))))) - -(define-public cl-ppcre-unicode - (sbcl-package->cl-source-package sbcl-cl-ppcre-unicode)) - -(define-public ecl-cl-ppcre-unicode - (sbcl-package->ecl-package sbcl-cl-ppcre-unicode)) - -(define-public sbcl-zpb-ttf - (package - (name "sbcl-zpb-ttf") - (version "1.0.6") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/xach/zpb-ttf") - (commit (string-append "release-" version)))) - (file-name (git-file-name "cl-zpb-ttf" version)) - (sha256 - (base32 "043xga76jms7dipcwnyh8lkj3gx66cvrkwhc728hjaf7axarvcmv")))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/xach/zpb-ttf") - (synopsis "TrueType font file access for Common Lisp") - (description - "ZPB-TTF is a TrueType font file parser that provides an interface for -reading typographic metrics, glyph outlines, and other information from the -file.") - (license license:bsd-2))) + "This library implements the @code{->} and @code{->>} macros from +Clojure, as well as several expansions on the idea.") + (home-page "https://gitlab.com/Harleqin/arrows") + (license license:public-domain)))) -(define-public ecl-zpb-ttf - (sbcl-package->ecl-package sbcl-zpb-ttf)) +(define-public cl-arrows + (sbcl-package->cl-source-package sbcl-arrows)) -(define-public cl-zpb-ttf - (sbcl-package->cl-source-package sbcl-zpb-ttf)) +(define-public ecl-arrows + (sbcl-package->ecl-package sbcl-arrows)) -(define-public sbcl-zip - ;; named branch is outdated - (let ((commit "688b1545dd7a4fe355556768bb03f8bd9b847a87") +(define-public sbcl-asdf-finalizers + (let ((commit "7f537f6c598b662ae987c6acc268dd27c25977e0") (revision "1")) (package - (name "sbcl-zip") + (name "sbcl-asdf-finalizers") (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/bluelisp/zip") + (url "https://gitlab.common-lisp.net/asdf/asdf-finalizers") (commit commit))) + (file-name (git-file-name name version)) (sha256 - (base32 "0s08a6fq182fzsbfyvihqbdllq6gxcwkvphxnrd9wwz65dhg5y66")) - (file-name (git-file-name "cl-zip" version)))) + (base32 "1w56c9yjjydjshsgqxz57qlp2v3r4ilbisnsgiqphvxnhvd41y0v")))) + (build-system asdf-build-system/sbcl) + (native-inputs + `(("fare-utils" ,sbcl-fare-utils) + ("hu.dwim.stefil" ,sbcl-hu.dwim.stefil))) + (home-page "https://gitlab.common-lisp.net/asdf/asdf-finalizers") + (synopsis "Enforced calling of finalizers for Lisp code") + (description "This library allows you to implement and enforce proper +finalization of compile-time constructs while building Lisp source files. + +It produces two systems: asdf-finalizers and list-of.") + (license license:expat)))) + +(define-public cl-asdf-finalizers + (sbcl-package->cl-source-package sbcl-asdf-finalizers)) + +(define-public ecl-asdf-finalizers + (sbcl-package->ecl-package sbcl-asdf-finalizers)) + +(define-public sbcl-asd-generator + (let ((commit "27f94971a7c68c4dcb51e3f6be4142743d0c44e8") + (revision "0")) + (package + (name "sbcl-asd-generator") + (version (git-version "1.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/phoe/asd-generator") + (commit commit))) + (sha256 + (base32 "0yiybl7b9x1f85v0drj0yw9821y3yfhya4n6gycnv5vvx6jp9by4")) + (file-name (git-file-name "cl-asd-generator" commit)))) (build-system asdf-build-system/sbcl) (inputs - (list sbcl-babel - sbcl-cl-fad - sbcl-salza2 - sbcl-trivial-gray-streams)) - (synopsis "Zip library written in Common Lisp") - (description "This package provide a Common Lisp library for .zip-file -reading and writing.") - (home-page "https://zip.common-lisp.dev") - (license (list license:bsd-2 license:llgpl))))) + (list sbcl-cl-fad + sbcl-iterate + sbcl-alexandria + sbcl-trivia)) + (home-page "https://github.com/phoe/asd-generator") + (synopsis "Automatic generator for .asd files") + (description + "This package provides an automatic generator for ASDF's .asd files.") + (license license:gpl3+)))) -(define-public ecl-zip - (sbcl-package->ecl-package sbcl-zip)) +(define-public cl-asd-generator + (sbcl-package->cl-source-package sbcl-asd-generator)) -(define-public cl-zip - (sbcl-package->cl-source-package sbcl-zip)) +(define-public ecl-asd-generator + (sbcl-package->ecl-package sbcl-asd-generator)) -(define-public sbcl-zippy - (let ((commit "ed9bca591ded2ff27a9ac95d9a60827773a0e707") +(define-public sbcl-asdf-system-connections + (let ((commit "9f085240febccccff99d9d3bb687fcaafffd3f5e") (revision "1")) (package - (name "sbcl-zippy") - (version (git-version "1.1.0" revision commit)) + (name "sbcl-asdf-system-connections") + (version (git-version "0.8.4" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/Shinmera/zippy/") + (url "https://github.com/gwkkwg/asdf-system-connections") (commit commit))) + (file-name (git-file-name "cl-asdf-system-connections" version)) (sha256 - (base32 "16cvyyf2nzd9r3fcy4w6d5wh8n3x833wldmrxmnzd3k2xrkhzfl9")) - (file-name (git-file-name "zippy" version)))) + (base32 "06kg0m8bv383qq3r34x0f8hz6p6zxcw02qn7kj960vcnrp5a5b3y")))) (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-documentation-utils - sbcl-file-attributes - sbcl-pathname-utils - sbcl-alexandria - sbcl-nibbles - sbcl-babel - sbcl-3bz - sbcl-salza2)) - (synopsis "Fast zip archive library") - (description "Zippy is a library for the PKWARE Zip archive format. It -can read and write zip files. It features: - -@itemize -@item archive inspection without extraction; -@item Zip64 support; -@item split archive support; -@item PKWARE decryption; -@item fast deflate decompression thanks to 3bz; -@item operates on streams and vectors; -@item can compress stream->stream; -@item extensible for other encryption and compression mechanisms. -@end itemize\n") - (home-page "https://shinmera.github.io/zippy/") - (license license:zlib)))) - -(define-public ecl-zippy - (sbcl-package->ecl-package sbcl-zippy)) - -(define-public cl-zippy - (sbcl-package->cl-source-package sbcl-zippy)) - -(define-public sbcl-cl-vectors - (package - (name "sbcl-cl-vectors") - (version "0.1.5") - (source - (origin - (method url-fetch) - (uri (string-append "http://projects.tuxee.net/cl-vectors/" - "files/cl-vectors-" version ".tar.gz")) - (sha256 - (base32 - "04lhwi0kq8pkwhgd885pk80m1cp9sfvjjn5zj70s1dnckibhdmqh")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("zpb-ttf" ,sbcl-zpb-ttf))) - (arguments - '(#:asd-systems '("cl-vectors" - "cl-paths" - "cl-paths-ttf" - "cl-aa" - "cl-aa-misc"))) - (home-page "http://projects.tuxee.net/cl-vectors/") - (synopsis "Create, transform and render anti-aliased vectorial paths") - (description - "This is a pure Common Lisp library to create, transform and render -anti-aliased vectorial paths.") - (license license:expat))) + (home-page "https://github.com/gwkkwg/asdf-system-connections") + (synopsis "Common Lisp ASDF system auto-loading extension") + (description + "This package provides a Common Lisp ASDF system auto-loading +extension.") + (license license:expat)))) -(define-public ecl-cl-vectors - (sbcl-package->ecl-package sbcl-cl-vectors)) +(define-public cl-asdf-system-connections + (sbcl-package->cl-source-package sbcl-asdf-system-connections)) -(define-public cl-vectors - (sbcl-package->cl-source-package sbcl-cl-vectors)) +(define-public ecl-asdf-system-connections + (sbcl-package->ecl-package sbcl-asdf-system-connections)) -(define-public sbcl-spatial-trees - ;; There have been no releases. - (let ((commit "81fdad0a0bf109c80a53cc96eca2e093823400ba") - (revision "1")) +(define-public sbcl-aserve + ;; There does not seem to be proper releases. + (let ((commit "cac1d6920998ddcbee8310a873414732e707d8e5") + (revision "2")) (package - (name "sbcl-spatial-trees") - (version (git-version "0" revision commit)) + (name "sbcl-aserve") + (version (git-version "1.2.50" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/rpav/spatial-trees") + ;; https://github.com/franzinc/aserve/ seems to be incompatible + ;; with SBCL, etc. + (url "git://git.code.sf.net/p/portableaserve/git") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "aserve" version)) (sha256 - (base32 - "11rhc6h501dwcik2igkszz7b9n515cr99m5pjh4r2qfwgiri6ysa")))) + (base32 "0ak6mqp84sjr0a7h5svr16vra4bf4fcx6wpir0n88dc1vjwy5xqa")) + (patches (search-patches + ;; Add HTML5 elements to htmlgen. + ;; Adapted from https://github.com/franzinc/aserve/ commits: + ;; * e47bd763: "rfe12668: add HTML 5 elements to htmlgen" + ;; * 7371ce59: "fix bugs in rfe12668 implementation" + "sbcl-aserve-add-HTML-5-elements.patch" + "sbcl-aserve-fix-rfe12668.patch")))) (build-system asdf-build-system/sbcl) (arguments - ;; We cannot build "spatial-trees-viz" here because it depends on - ;; mcclim which depends on spatial-trees. FIXME: Break the circle. - '(#:asd-systems '("spatial-trees" "spatial-trees.nns"))) + `(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'cd-aserve + (lambda _ + (chdir "aserve") + #t)) + (add-after 'cd-aserve 'fix-asd + (lambda _ + (substitute* "aserve.asd" + ((" :force t") "")) + #t)) + (add-after 'cd-aserve 'fix-tests + (lambda _ + (substitute* "test/t-aserve.cl" + (("\\(asdf:oos 'asdf:load-op :ptester\\)") "")) + #t))))) (inputs - (list sbcl-alexandria sbcl-optima sbcl-iterate)) - (native-inputs - (list sbcl-fiveam)) - (home-page "https://github.com/rpav/spatial-trees") - (synopsis "Dynamic index data structures for spatially-extended data") + `(("acl-compat" ,sbcl-acl-compat))) + (home-page + "https://franz.com/support/documentation/current/doc/aserve/aserve.html") + (synopsis "AllegroServe, a web server written in Common Lisp") (description - "Spatial-trees is a set of dynamic index data structures for -spatially-extended data.") - (license license:bsd-3)))) - -(define-public ecl-spatial-trees - (sbcl-package->ecl-package sbcl-spatial-trees)) + "The server part of AllegroServe can be used either as a standalone web +server or a module loaded into an application to provide a user interface to +the application. AllegroServe's proxy ability allows it to run on the gateway +machine between some internal network and the Internet. AllegroServe's client +functions allow Lisp programs to explore the web.") + (license license:llgpl)))) -(define-public cl-spatial-trees - (sbcl-package->cl-source-package sbcl-spatial-trees)) +(define-public cl-aserve + (sbcl-package->cl-source-package sbcl-aserve)) -(define-public sbcl-flexichain - ;; There are no releases. - (let ((commit "9af644a6323f303a936a391b956babcbfe7b0c67") - (revision "2")) +(define-public sbcl-assoc-utils + (let ((commit "74af16a3c0f10ad35e406167de02984744fc7854") + (revision "1")) (package - (name "sbcl-flexichain") - (version (git-version "1.5.1" revision commit)) + (name "sbcl-assoc-utils") + (version (git-version "0.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/robert-strandh/Flexichain") + (url "https://github.com/fukamachi/assoc-utils") (commit commit))) - (file-name (git-file-name "cl-flexichain" version)) + (file-name (git-file-name "cl-assoc-utils" version)) (sha256 - (base32 "1ivkffnkc1iqmpl1p1rgyfbbgjmjcid4iszvdql1jjz324lq94g6")))) + (base32 "1yac1v7zmdxj0p6rvwrrhyqvy7yjfhmqbchkwqhhr89gpjvvaick")))) (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-trivial-garbage)) - (home-page "https://github.com/robert-strandh/Flexichain.git") - (synopsis "Dynamically add elements to or remove them from sequences") + (arguments + '(#:asd-systems '("assoc-utils-test" "assoc-utils"))) + (native-inputs + (list sbcl-prove)) + (home-page "https://github.com/fukamachi/assoc-utils") + (synopsis "Utilities for manipulating association lists in Common Lisp") (description - "This package provides an implementation of the flexichain protocol, -allowing client code to dynamically add elements to, and delete elements from -a sequence (or chain) of such elements.") - (license license:lgpl2.1+)))) + "@code{assoc-utils} provides utilities for manipulating association +lists in Common Lisp.") + (license license:public-domain)))) -(define-public ecl-flexichain - (sbcl-package->ecl-package sbcl-flexichain)) +(define-public cl-assoc-utils + (sbcl-package->cl-source-package sbcl-assoc-utils)) -(define-public cl-flexichain - (sbcl-package->cl-source-package sbcl-flexichain)) +(define-public ecl-assoc-utils + (sbcl-package->ecl-package sbcl-assoc-utils)) -(define-public sbcl-cl-pdf - (let ((commit "ee904a118a0f060279ad9d253a3e8e3997609213") - (revision "3")) +(define-public sbcl-atomichron + (let ((commit "5b3578bbad8c37ab559e56924d98c373efe11de5") + (revision "0")) (package - (name "sbcl-cl-pdf") - (version (git-version "2.0.0" revision commit)) + (name "sbcl-atomichron") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/mbattyani/cl-pdf") + (url "https://github.com/no-defun-allowed/atomichron") (commit commit))) - (file-name (git-file-name "cl-pdf" version)) + (file-name (git-file-name "cl-atomichron" version)) (sha256 - (base32 "0j7hbqv6yzrgx0inqinpw8h22728l53ccciw6iymzz4g92j9fzlq")))) + (base32 "1fmmhb3pbv7j4d1cc02zv24bpd0kd2agfjjcj46w3gmv1bb0hva1")))) (build-system asdf-build-system/sbcl) (inputs - (list sbcl-iterate sbcl-zpb-ttf)) - (arguments - `(#:asd-systems '("cl-pdf" "cl-pdf-parser"))) - (home-page "https://github.com/mbattyani/cl-pdf") - (synopsis "Common Lisp library for generating PDF files") + (list sbcl-atomics sbcl-bordeaux-threads)) + (home-page "https://github.com/no-defun-allowed/atomichron") + (synopsis "Atomic metering library for Common Lisp") (description - "CL-PDF is a cross-platform Common Lisp library for generating PDF -files.") + "@code{atomichron} is a Common Lisp library which implements a time +meter which tracks how many times a form is evaluated, and how long evaluation +takes. It uses atomic instructions so that meters will present correct +results in the presence of multiple threads, while trying to minimize +synchronization latency.") (license license:bsd-2)))) -(define-public ecl-cl-pdf - (sbcl-package->ecl-package sbcl-cl-pdf)) +(define-public cl-atomichron + (sbcl-package->cl-source-package sbcl-atomichron)) -(define-public cl-pdf - (sbcl-package->cl-source-package sbcl-cl-pdf)) +(define-public ecl-atomichron + (sbcl-package->ecl-package sbcl-atomichron)) -(define-public sbcl-clx - (let ((commit "38400456d66823e417d1d27d339b09885e25eb59") - (revision "1")) +(define-public sbcl-atomics + ;; No release in years. + (let ((commit "b7477024894e322bff9c85e6d81e5e8d1d4eae59") + (revision "2")) (package - (name "sbcl-clx") - (version (git-version "0.7.5" revision commit)) + (name "sbcl-atomics") + (version (git-version "1.0.0" revision commit)) (source (origin (method git-fetch) - (uri - (git-reference - (url "https://github.com/sharplispers/clx") - (commit commit))) + (uri (git-reference + (url "https://github.com/Shinmera/atomics") + (commit commit))) + (file-name (git-file-name "cl-atomics" version)) (sha256 - (base32 "1c05gjqh5lil2sgma0yap4mxd9y1cjkp933hyx1iaj14950nhfnl")) - (file-name (git-file-name "cl-clx" version)))) + (base32 "1ah6fgvfva0axnhj4sp1qy6gjyw41fkhpnv998di0wbp6hls8j39")))) (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-documentation-utils)) (native-inputs - (list sbcl-fiasco xorg-server-for-tests)) - (arguments - (list #:phases - #~(modify-phases %standard-phases - (add-before 'check 'prepare-test-environment - (lambda _ - (system "Xvfb :1 &") - (setenv "DISPLAY" ":1")))))) - (home-page "https://www.cliki.net/portable-clx") - (synopsis "X11 client library for Common Lisp") - (description "CLX is an X11 client library for Common Lisp. The code was -originally taken from a CMUCL distribution, was modified somewhat in order to -make it compile and run under SBCL, then a selection of patches were added -from other CLXes around the net.") - (license license:x11)))) + (list sbcl-parachute)) + (home-page "https://shinmera.github.io/atomics/") + (synopsis "Common Lisp portability layer for atomic operations") + (description + "This is a library for access to atomic operation primitives such as +compare-and-swap. It aims to be a rather thin layer over what the +implementations offer.") + (license license:zlib)))) -(define-public cl-clx - (sbcl-package->cl-source-package sbcl-clx)) +(define-public cl-atomics + (sbcl-package->cl-source-package sbcl-atomics)) -(define-public ecl-clx - (sbcl-package->ecl-package sbcl-clx)) +(define-public ecl-atomics + (sbcl-package->ecl-package sbcl-atomics)) -(define-public sbcl-cl-wayland - (let ((commit "a92a5084b64102f538ab90212e99c7863e5338ae") - (revision "0")) +(define-public sbcl-authentic + (let ((commit "4e9194dda227b98f56dda1c2a2480efcc2d1f973") + (revision "2")) (package - (name "sbcl-cl-wayland") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-authentic") + (version (git-version "0.1.2" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/sdilts/cl-wayland") + (url "https://github.com/charje/cl-authentic") (commit commit))) - (file-name (git-file-name "cl-wayland" version)) + (file-name (git-file-name "cl-authentic" version)) (sha256 - (base32 "1r4fn9dc0dz2b30k8z243yacx1y5z21qk4zh2ildj7ak51qx53zf")))) + (base32 "0ncsxrybnx0pjsndv3j8w4lphlpcsld8sxg3c5b46fb3a8nd4ssf")))) (build-system asdf-build-system/sbcl) - (arguments - (list #:phases - #~(modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "wayland-server-core.lisp" - (("libwayland-server.so") - (search-input-file inputs - "/lib/libwayland-server.so")))))))) + (native-inputs + (list sbcl-fiveam)) (inputs - (list sbcl-cffi - sbcl-closer-mop - wayland)) - (home-page "https://github.com/sdilts/cl-wayland") - (synopsis "Common Lisp FFI bindings for libwayland") - (description - "This package provides Common Lisp FFI bindings for libwayland, -primarily for the mahogany window manager.") - (license license:bsd-3)))) + (list sbcl-clsql sbcl-ironclad)) + (home-page "https://github.com/charje/cl-authentic") + (synopsis "User/password management for Common Lisp applications") + (description "Authentic provides a light-weight and extendible +solution to user/password management for Common Lisp applications. It has +features such as safe password storage in a database, password reset, user +confirmation tokens, and user authentication.") + (license license:llgpl)))) -(define-public cl-wayland - (sbcl-package->cl-source-package sbcl-cl-wayland)) +(define-public ecl-authentic + (sbcl-package->ecl-package sbcl-authentic)) -(define-public ecl-cl-wayland - (sbcl-package->ecl-package sbcl-cl-wayland)) +(define-public cl-authentic + (sbcl-package->cl-source-package sbcl-authentic)) -(define-public sbcl-clx-truetype - (let ((commit "c6e10a918d46632324d5863a8ed067a83fc26de8") - (revision "1")) +(define-public sbcl-babel + ;; No release since 2014. + (let ((commit "627d6a60d0ffc82a3687b39ba8a99128031504d9") + (revision "3")) (package - (name "sbcl-clx-truetype") - (version (git-version "0.0.1" revision commit)) + (name "sbcl-babel") + (version (git-version "0.5.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/l04m33/clx-truetype") + (url "https://github.com/cl-babel/babel") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-babel" version)) (sha256 - (base32 - "079hyp92cjkdfn6bhkxsrwnibiqbz4y4af6nl31lzw6nm91j5j37")) - (modules '((guix build utils))) - (snippet - '(begin - (substitute* "package.lisp" - ((":export") ":export\n :+font-cache-filename+")) - #t)))) + (base32 "1sndap9ykyyvrzlqm9smgqy49r3n67l926yg0hb7pm00plj0y380")))) (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-hu.dwim.stefil)) (inputs - (list sbcl-clx - sbcl-zpb-ttf - sbcl-cl-vectors - sbcl-cl-fad - sbcl-cl-store - sbcl-trivial-features)) - (home-page "https://github.com/l04m33/clx-truetype") - (synopsis "Antialiased TrueType font rendering using CLX and XRender") - (description "CLX-TrueType is pure common lisp solution for -antialiased TrueType font rendering using CLX and XRender extension.") - (license license:expat)))) + (list sbcl-alexandria sbcl-trivial-features)) + (home-page "https://common-lisp.net/project/babel/") + (synopsis "Charset encoding and decoding library") + (description "Babel is a charset encoding and decoding library, not unlike +GNU libiconv, but completely written in Common Lisp.") + (license (list license:bsd-2 license:expat))))) -(define-public cl-clx-truetype - (sbcl-package->cl-source-package sbcl-clx-truetype)) +(define-public cl-babel + (sbcl-package->cl-source-package sbcl-babel)) -(define-public ecl-clx-truetype - (sbcl-package->ecl-package sbcl-clx-truetype)) +(define-public ecl-babel + (sbcl-package->ecl-package sbcl-babel)) -(define-public sbcl-slynk - ;; Update together with emacs-sly. - (let ((commit "9c43bf65b967e12cef1996f1af5f0671d8aecbf4") - (revision "9")) +(define-public sbcl-binary-types + (let ((commit "9ec42042a50403961c08179a892ae3de725b1d7a")) (package - (name "sbcl-slynk") - (version (git-version "1.0.43" revision commit)) + (name "sbcl-binary-types") + (version (git-version "1.2" "1" commit)) (source (origin (method git-fetch) - (uri - (git-reference - (url "https://github.com/joaotavora/sly") - (commit commit))) + (uri (git-reference + (url "https://github.com/frodef/binary-types/") + (commit commit))) + (file-name (git-file-name "binary-types" version)) (sha256 - (base32 "15nyr02ykkws4q79jcmxcawddg8sgq9v5l8k7jv7gg3hnpzxjlb2")) - (file-name (git-file-name "cl-slynk" version)))) + (base32 "0kp4xwblfxh7gmgqc38k9xzrqlcr0q1jm5167ma1pajdxd3182j8")))) (build-system asdf-build-system/sbcl) - (outputs '("out" "image")) - (arguments - `(#:phases - (modify-phases %standard-phases - (add-after 'create-asdf-configuration 'build-image - (lambda* (#:key outputs #:allow-other-keys) - (build-image (string-append - (assoc-ref outputs "image") - "/bin/slynk") - outputs - #:dependencies '("slynk" - "slynk/arglists" - "slynk/fancy-inspector" - "slynk/package-fu" - "slynk/mrepl" - "slynk/trace-dialog" - "slynk/profiler" - "slynk/stickers" - "slynk/indentation" - "slynk/retro")) - #t))))) - (synopsis "Common Lisp IDE for Emacs") - (description "SLY is a fork of SLIME, an IDE backend for Common Lisp. -It also features a completely redesigned REPL based on Emacs's own -full-featured @code{comint-mode}, live code annotations, and a consistent interactive -button interface. Everything can be copied to the REPL. One can create -multiple inspectors with independent history.") - (home-page "https://github.com/joaotavora/sly") - (license license:public-domain) - (properties `((cl-source-variant . ,(delay cl-slynk))))))) + (home-page "https://github.com/frodef/binary-types/") + (synopsis "Read and write binary records for Common Lisp") + (description + "Binary-types is a Common Lisp package for reading and writing binary +files. Binary-types provides macros that are used to declare the mapping +between Lisp objects and some binary (i.e. octet-based) representation.") + (license license:bsd-3)))) -(define-public cl-slynk - (sbcl-package->cl-source-package sbcl-slynk)) +(define-public cl-binary-types + (sbcl-package->cl-source-package sbcl-binary-types)) -(define-public ecl-slynk - (let ((pkg (sbcl-package->ecl-package sbcl-slynk))) - (package - (inherit pkg) - (outputs '("out")) - (arguments - (substitute-keyword-arguments (package-arguments pkg) - ((#:phases phases) - `(modify-phases ,phases - (delete 'build-image)))))))) +(define-public ecl-binary-types + (sbcl-package->ecl-package sbcl-binary-types)) -(define-public sbcl-parse-js - (let ((commit "fbadc6029bec7039602abfc06c73bb52970998f6") +(define-public sbcl-binascii + (let ((commit "0fb0a9e5773148fd04d50efef08c1cc10f6fc487") (revision "1")) (package - (name "sbcl-parse-js") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-binascii") + (version (git-version "1.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "http://marijn.haverbeke.nl/git/parse-js") + (url "https://github.com/sharplispers/binascii") (commit commit))) - (file-name (git-file-name "cl-parse-js" version)) + (file-name (git-file-name "cl-binascii" version)) (sha256 - (base32 - "1wddrnr5kiya5s3gp4cdq6crbfy9fqcz7fr44p81502sj3bvdv39")))) + (base32 "000rcdl8qshr7n48zq9bzrc4lkjx4ylb3r3w9x9syhiwfla9j4b7")) + (modules '((guix build utils))) + (snippet + ;; Unbundle the RT test framework. + '(begin + (delete-file "tests/rt.lisp") + (substitute* "binascii.asd" + ((":depends-on \\(binascii\\)") + ":depends-on (binascii rt)") + (("\\(:file \"rt\"\\)") + "") + (("\\(:file \"tests\" :depends-on \\(\"rt\"\\)\\)") + "(:file \"tests\")")))))) (build-system asdf-build-system/sbcl) - (home-page "https://marijnhaverbeke.nl/parse-js/") - (synopsis "Parse JavaScript") - (description "Parse-js is a Common Lisp package for parsing -JavaScript (ECMAScript 3). It has basic support for ECMAScript 5.") - (license license:zlib)))) - -(define-public cl-parse-js - (sbcl-package->cl-source-package sbcl-parse-js)) - -(define-public ecl-parse-js - (sbcl-package->ecl-package sbcl-parse-js)) - -(define-public sbcl-parse-number - (package - (name "sbcl-parse-number") - (version "1.7") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/sharplispers/parse-number/") - (commit (string-append "v" version)))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "0sk06ib1bhqv9y39vwnnw44vmbc4b0kvqm37xxmkxd4dwchq82d7")))) - (build-system asdf-build-system/sbcl) - (home-page "https://www.cliki.net/PARSE-NUMBER") - (synopsis "Parse numbers") - (description "@code{parse-number} is a library of functions for parsing -strings into one of the standard Common Lisp number types without using the -reader. @code{parse-number} accepts an arbitrary string and attempts to parse -the string into one of the standard Common Lisp number types, if possible, or -else @code{parse-number} signals an error of type @code{invalid-number}.") - (license license:bsd-3))) - -(define-public cl-parse-number - (sbcl-package->cl-source-package sbcl-parse-number)) + (native-inputs + (list sbcl-rt)) + (home-page "https://github.com/sharplispers/binascii") + (synopsis "Common Lisp library of ASCII encoding schemes for binary data") + (description + "@code{binascii} is a Common Lisp library for converting binary data +to ASCII text of some kind. Such conversions are common in email protocols +(for encoding attachments to support old non-8-bit clean transports) or +encoding binary data in HTTP and XML applications. @code{binascii} supports +the encodings described in RFC 4648: base64, base32, base16, and variants. +It also supports base85, used in Adobe's PostScript and PDF document formats, +and a variant called ascii85, used by git for binary diff files.") + (license license:bsd-3)))) -(define-public ecl-parse-number - (sbcl-package->ecl-package sbcl-parse-number)) +(define-public cl-binascii + (sbcl-package->cl-source-package sbcl-binascii)) -(define-public sbcl-iterate - (package - (name "sbcl-iterate") - (version "1.5.3") - (source - (origin +(define-public sbcl-binding-arrows + ;; Fork of sbcl-arrows that does not have a new tag. + (let ((commit "46bcba8bb1ff27cd5caab3bda36f000d0489a4f2") + (revision "2")) + (package + (name "sbcl-binding-arrows") + (version (git-version "1.0.0" revision commit)) + (source + (origin (method git-fetch) (uri (git-reference - (url "https://gitlab.common-lisp.net/iterate/iterate.git") - (commit version))) - (file-name (git-file-name "cl-iterate" version)) + (url "https://github.com/phoe/binding-arrows") + (commit commit))) + (file-name (git-file-name "cl-binding-arrows" version)) (sha256 - (base32 "0l6l8fpgcpwpmi00jwmamxbspbqa8fil6dv11bf9gaxxbw41f8c2")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-rt)) - (home-page "https://common-lisp.net/project/iterate/") - (synopsis "Iteration construct for Common Lisp") - (description "@code{iterate} is an iteration construct for Common Lisp. -It is similar to the @code{CL:LOOP} macro, with these distinguishing marks: + (base32 "0kzybw5qlb49czh9v2lnxniz9jzqx306a6lnarfv59x48a7cch22")))) + (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-hu.dwim.stefil)) + (home-page "https://github.com/phoe/binding-arrows") + (synopsis "Threading macros based on binding anonymous variables") + (description + "This system implements binding threading macros -- a kind of threading +macros with different semantics than classical, Clojure core threading macros +or their extension, swiss-arrows. Two Common Lisp implementations of those are +@code{arrows} and @code{arrow-macros}. -@itemize -@item it is extensible, -@item it helps editors like Emacs indent iterate forms by having a more - lisp-like syntax, and -@item it isn't part of the ANSI standard for Common Lisp. -@end itemize\n") - (license license:expat))) +This system is a fork of @code{arrows} with changes in semantics that make it +impossible to merge back upstream.") + (license license:expat)))) -(define-public cl-iterate - (sbcl-package->cl-source-package sbcl-iterate)) +(define-public ecl-binding-arrows + (sbcl-package->ecl-package sbcl-binding-arrows)) -(define-public ecl-iterate - (sbcl-package->ecl-package sbcl-iterate)) +(define-public cl-binding-arrows + (sbcl-package->cl-source-package sbcl-binding-arrows)) -(define-public sbcl-charje.loop - (package - (name "sbcl-charje.loop") - (version "0.0.0") - (source - (origin +(define-public sbcl-binpack + (let ((commit "e67f56bb697bdeac81e28e1cca4a5d117a9cf125") + (revision "1")) + (package + (name "sbcl-binpack") + (version (git-version "0.0.1" revision commit)) + (source + (origin (method git-fetch) (uri (git-reference - (url "https://git.sr.ht/~charje/loop") - (commit (string-append "v" version)))) - (file-name (git-file-name "cl-charje.loop" version)) + (url "https://github.com/lispgames/binpack") + (commit commit))) + (file-name (git-file-name "binpack" version)) (sha256 - (base32 - "1x1hw5xmrx9xmfzga8y0yi6s27r7zc80rwl2z7l4d2h24ykscvd4")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-alexandria - sbcl-binding-arrows - sbcl-parse-declarations)) - (home-page "https://git.sr.ht/~charje/loop") - (synopsis "Loop abstraction for Common Lisp that is consistent for -different kinds of data") - (description "Loop is a joy to use and has a consistent interface unlike -other looping abstractions and ANSI list operations. You can define your own -iterators and aggregators that integrate tightly into other operations. All -operations are non-consing when possible.") - (license license:agpl3+))) + (base32 "1pcnsg60pqywd3k72m5pwimq01sm3jyvc1c3rbkij740r7grdxi1")))) + (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-parachute)) + (inputs + (list sbcl-alexandria)) + (home-page "https://github.com/lispgames/binpack") + (synopsis "Common Lisp rectangle packer for sprite/texture atlases") + (description + "This library features a rectangle packer for sprite and texture atlases.") + (license license:expat)))) -(define-public cl-charje.loop - (sbcl-package->cl-source-package sbcl-charje.loop)) +(define-public cl-binpack + (sbcl-package->cl-source-package sbcl-binpack)) -(define-public ecl-charje.loop - (sbcl-package->ecl-package sbcl-charje.loop)) +(define-public ecl-binpack + (sbcl-package->ecl-package sbcl-binpack)) -(define-public sbcl-cl-uglify-js - ;; There have been many bug fixes since the 2010 release. - (let ((commit "429c5e1d844e2f96b44db8fccc92d6e8e28afdd5") - (revision "1")) +(define-public sbcl-bit-smasher + ;; No release. + (let ((commit "c2dcb3b5ec0e485484be681fe17c4e81e58790d9")) (package - (name "sbcl-cl-uglify-js") - (version (git-version "0.1" revision commit)) + (name "sbcl-bit-smasher") + (version (git-version "1.0.2" "1" commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/mishoo/cl-uglify-js") + (url "https://github.com/thephoeron/bit-smasher/") (commit commit))) - (file-name (git-file-name "cl-uglify-js" version)) + (file-name (git-file-name name version)) (sha256 - (base32 - "0k39y3c93jgxpr7gwz7w0d8yknn1fdnxrjhd03057lvk5w8js27a")))) + (base32 "0wjmwn06fjpw0rlpaksf3ab727p8fnzj58z7jajl3m0wqd4ii74w")))) (build-system asdf-build-system/sbcl) (inputs - (list sbcl-parse-js sbcl-cl-ppcre sbcl-cl-ppcre-unicode - sbcl-parse-number sbcl-iterate)) - (home-page "https://github.com/mishoo/cl-uglify-js") - (synopsis "JavaScript compressor library for Common Lisp") - (description "This is a Common Lisp version of UglifyJS, a JavaScript -compressor. It works on data produced by @code{parse-js} to generate a -@dfn{minified} version of the code. Currently it can: - -@itemize -@item reduce variable names (usually to single letters) -@item join consecutive @code{var} statements -@item resolve simple binary expressions -@item group most consecutive statements using the @code{sequence} operator (comma) -@item remove unnecessary blocks -@item convert @code{IF} expressions in various ways that result in smaller code -@item remove some unreachable code -@end itemize\n") - (license license:zlib)))) - -(define-public cl-uglify-js - (sbcl-package->cl-source-package sbcl-cl-uglify-js)) - -(define-public ecl-cl-uglify-js - (sbcl-package->ecl-package sbcl-cl-uglify-js)) - -(define-public uglify-js - (package - (inherit sbcl-cl-uglify-js) - (name "uglify-js") - (build-system trivial-build-system) - (arguments - `(#:modules ((guix build utils)) - #:builder - (let* ((bin (string-append (assoc-ref %outputs "out") "/bin/")) - (script (string-append bin "uglify-js"))) - (use-modules (guix build utils)) - (mkdir-p bin) - (with-output-to-file script - (lambda _ - (format #t "#!~a/bin/sbcl --script - - (require :asdf) - (asdf:initialize-source-registry - #p\"~a/etc/common-lisp/source-registry.conf.d/\") - (asdf:initialize-output-translations - #p\"~a/etc/common-lisp/asdf-output-translations.conf.d/\")" - (assoc-ref %build-inputs "sbcl") - (assoc-ref %build-inputs "sbcl-cl-uglify-js") - (assoc-ref %build-inputs "sbcl-cl-uglify-js")) - ;; FIXME: cannot use progn here because otherwise it fails to - ;; find cl-uglify-js. - (for-each - write - '(;; Quiet, please! - (let ((*standard-output* (make-broadcast-stream)) - (*error-output* (make-broadcast-stream))) - (asdf:load-system :cl-uglify-js)) - (let ((file (cadr *posix-argv*))) - (if file - (format t "~a" - (cl-uglify-js:ast-gen-code - (cl-uglify-js:ast-mangle - (cl-uglify-js:ast-squeeze - (with-open-file (in file) - (parse-js:parse-js in)))) - :beautify nil)) - (progn - (format *error-output* - "Please provide a JavaScript file.~%") - (sb-ext:exit :code 1)))))))) - (chmod script #o755) - #t))) - (inputs - (list sbcl sbcl-cl-uglify-js)) - (synopsis "JavaScript compressor"))) - -(define-public sbcl-cl-strings - (let ((revision "1") - (commit "93ec4177fc51f403a9f1ef0a8933f36d917f2140")) - (package - (name "sbcl-cl-strings") - (version (git-version "0.0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/diogoalexandrefranco/cl-strings") - (commit commit))) - (sha256 - (base32 "1j8hs54fn0wsf5zfzhhgiva47n9hsmfa74iinahz6nmcs8iy75aj")) - (file-name (git-file-name "cl-strings" version)))) - (build-system asdf-build-system/sbcl) - (synopsis "Set of utilities to manipulate strings in Common Lisp") + `(("cl-base64" ,sbcl-cl-base64) + ("cl-base58" ,sbcl-cl-base58))) + (home-page "https://github.com/thephoeron/bit-smasher/") + (synopsis "Handle bit vectors, bit vector arithmetic, and type conversions") (description - "@command{cl-strings} is a small, portable, dependency-free set of -utilities that make it even easier to manipulate text in Common Lisp. It has -100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.") - (home-page "https://github.com/diogoalexandrefranco/cl-strings") + "Utility library for handling bit vectors, bit vector arithmetic, and +universal integer type conversions between bit-vectors, byte-vectors, octals, +decimals, and hexadecimal notation.") (license license:expat)))) -(define-public cl-strings - (sbcl-package->cl-source-package sbcl-cl-strings)) - -(define-public ecl-cl-strings - (sbcl-package->ecl-package sbcl-cl-strings)) - -(define-public sbcl-trivial-features - (package - (name "sbcl-trivial-features") - (version "1.0") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/trivial-features/trivial-features") - (commit (string-append "v" version)))) - (file-name (git-file-name "trivial-features" version)) - (sha256 - (base32 "0jsqah1znzqilxnw5vannb083ayk0d7phkackqzwwqkyg5hpn6pq")))) - (build-system asdf-build-system/sbcl) - (arguments - '(;; FIXME: Tests disabled because of a circular dependency between - ;; trivial-features and cffi. - #:tests? #f)) - ;; (native-inputs - ;; `(("cffi" ,sbcl-cffi))) - (home-page "https://cliki.net/trivial-features") - (synopsis "Ensures consistency of @code{*FEATURES*} in Common Lisp") - (description "Trivial-features ensures that @code{*FEATURES*} is -consistent across multiple Common Lisp implementations.") - (license license:expat))) - -(define-public cl-trivial-features - (sbcl-package->cl-source-package sbcl-trivial-features)) +(define-public cl-bit-smasher + (sbcl-package->cl-source-package sbcl-bit-smasher)) -(define-public ecl-trivial-features - (sbcl-package->ecl-package sbcl-trivial-features)) +(define-public ecl-bit-smasher + (sbcl-package->ecl-package sbcl-bit-smasher)) -(define-public sbcl-harmony - (let ((commit "0b57483cc0341936c201b620f82a8542c606991f") - (revision "0")) +(define-public sbcl-bknr-datastore + (let ((commit "c98d44f47cc88d19ff91ca3eefbd9719a8ace022") + (revision "1")) (package - (name "sbcl-harmony") - (version (git-version "2.0.0" revision commit)) + (name "sbcl-bknr-datastore") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/Shirakumo/harmony") + (url "https://github.com/hanshuebner/bknr-datastore") (commit commit))) - (file-name (git-file-name "cl-harmony" version)) + (file-name (git-file-name "bknr-datastore" version)) (sha256 - (base32 "0pqmfi3yi3gi7b7dyayrb621hp60rn7hasq0cl0fis3vg0fp5dja")))) + (base32 "1vi3w65fnczqvswkm381n6liqfrzjrg40y698qvj7skj28dm5vrm")))) (build-system asdf-build-system/sbcl) + (arguments + `(#:asd-systems + '("bknr.datastore" + "bknr.impex" + "bknr.indices" + "bknr.skip-list" + "bknr.utils" + "bknr.xml") + #:phases + (modify-phases %standard-phases + (add-after 'unpack 'enter-source-directory + (lambda _ + (chdir "src") + #t))))) + (native-inputs + `(("cl-store" ,sbcl-cl-store) + ("fiveam" ,sbcl-fiveam) + ("unit-test" ,sbcl-unit-test))) (inputs - (list sbcl-atomics - sbcl-bordeaux-threads - sbcl-cl-mixed - sbcl-stealth-mixin - sbcl-trivial-features)) - (home-page "https://shirakumo.github.io/harmony/") - (synopsis "Common Lisp sound server and sound processing library") + `(("alexandria" ,sbcl-alexandria) + ("bordeaux-threads" ,sbcl-bordeaux-threads) + ("closer-mop" ,sbcl-closer-mop) + ("cl-interpol" ,sbcl-cl-interpol) + ("cl-ppcre" ,sbcl-cl-ppcre) + ("cxml" ,sbcl-cxml) + ("flexi-streams" ,sbcl-flexi-streams) + ("md5" ,sbcl-md5) + ("trivial-utf-8" ,sbcl-trivial-utf-8) + ("yason" ,sbcl-yason))) + (home-page "https://github.com/hanshuebner/bknr-datastore") + (synopsis "In-memory database for Common Lisp") (description - "HARMONY is a library that provides you with audio processing tools as -well as an audio server to play back music, sfx, and so forth. It is most -suited for use in a game engine, but may feasibly also be used for more -advanced things such as a DAW") - (license license:zlib)))) + "BKNR.DATASTORE is an in-memory CLOS based database with transactions +for Common Lisp.") + (license license:bsd-0)))) -(define-public ecl-harmony - (sbcl-package->ecl-package sbcl-harmony)) +(define-public cl-bknr-datastore + (sbcl-package->cl-source-package sbcl-bknr-datastore)) -(define-public cl-harmony - (sbcl-package->cl-source-package sbcl-harmony)) +;; NOTE: (Sharlatan-20210429T191426+0100): +;; There is no port for ECL in upstream yet +;; (define-public ecl-bknr-datastore +;; (sbcl-package->ecl-package sbcl-bknr-datastore)) -(define-public sbcl-hu.dwim.asdf - (let ((commit "67cdf84390e530af4303cc4bc815fdf2a5e48f59")) +(define-public sbcl-blackbird + (let ((commit "d361f81c1411dec07f6c2dcb11c78f7aea9aaca8") + (revision "1")) (package - (name "sbcl-hu.dwim.asdf") - (version "20200724") + (name "sbcl-blackbird") + (version (git-version "0.5.2" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/hu-dwim/hu.dwim.asdf") + (url "https://github.com/orthecreedence/blackbird") (commit commit))) (file-name (git-file-name name version)) (sha256 (base32 - "0p81jalilkaqw832a12s35q0z6rrarxjasm1jy6h4fvyj9pf0zkx")))) + "0xfds5yaya64arzr7w1x38karyz11swzbhxx1afldpradj9dh19c")))) (build-system asdf-build-system/sbcl) - (home-page "https://hub.darcs.net/hu.dwim/hu.dwim.asdf") - (synopsis "Extensions to ASDF") - (description "Various ASDF extensions such as attached test and -documentation system, explicit development support, etc.") - (license license:public-domain)))) + (inputs + (list sbcl-vom)) + (native-inputs + (list sbcl-cl-async sbcl-fiveam)) + (synopsis "Promise implementation for Common Lisp") + (description + "This is a standalone promise implementation for Common Lisp. It is +the successor to the now-deprecated cl-async-future project.") + (home-page "https://orthecreedence.github.io/blackbird/") + (license license:expat)))) -(define-public cl-hu.dwim.asdf - (sbcl-package->cl-source-package sbcl-hu.dwim.asdf)) +(define-public cl-blackbird + (sbcl-package->cl-source-package sbcl-blackbird)) -(define-public ecl-hu.dwim.asdf - (sbcl-package->ecl-package sbcl-hu.dwim.asdf)) +(define-public ecl-blackbird + (sbcl-package->ecl-package sbcl-blackbird)) -(define-public sbcl-hu.dwim.graphviz - (let ((commit "31522ca8b9a04d535b7cec20ef24d8bf3b26d52b") - (revision "1")) +(define-public sbcl-bobbin + (let ((commit "b454e8241b24ceab674eeeae464c8082b1b6d8ce") + (revision "0")) (package - (name "sbcl-hu.dwim.graphviz") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-bobbin") + (version (git-version "1.0.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/hu-dwim/hu.dwim.graphviz") + (url "https://github.com/sjl/bobbin") (commit commit))) - (file-name (git-file-name "cl-hu.dwim.graphviz" version)) + (file-name (git-file-name "cl-bobbin" version)) (sha256 - (base32 "0cz5g7d6817ajypp876k9m65sxxlf42x4bg04ya73aqci5s1vjwy")))) + (base32 "02lw7w8cbvnxw5acbz405rb5lcqsf4fx7dvj5ldr0lhgbyv1mjnm")))) (build-system asdf-build-system/sbcl) - (arguments - (list #:phases - #~(modify-phases %standard-phases - (add-after 'unpack 'patch-graphviz-lib-path - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "source/package.lisp" - (("libgvc.so") - (search-input-file inputs "/lib/libgvc.so")))))))) (native-inputs - (list sbcl-hu.dwim.common sbcl-hu.dwim.stefil)) + (list sbcl-1am)) (inputs - (list graphviz sbcl-cffi sbcl-metabang-bind)) - (home-page "https://github.com/hu-dwim/hu.dwim.graphviz") - (synopsis "Graphviz layouting using CFFI bindings") + (list sbcl-split-sequence)) + (home-page "https://docs.stevelosh.com/bobbin/") + (synopsis "Simple (word) wrapping utilities for strings") (description - "This package provides CFFI bindings to the Graphviz library in Common -Lisp.") - (license license:public-domain)))) + "Bobbin is a simple word-wrapping library for strings in Common Lisp. +It aims to be simple, work nicely for the majority of cases, and degrade +gracefully for edge cases. It is not particularly concerned with speed — if +you need very high-performance word wrapping, Bobbin is not for you.") + (license license:expat)))) -(define-public cl-hu.dwim.graphviz - (sbcl-package->cl-source-package sbcl-hu.dwim.graphviz)) +(define-public cl-bobbin + (sbcl-package->cl-source-package sbcl-bobbin)) -(define-public ecl-hu.dwim.graphviz - (sbcl-package->ecl-package sbcl-hu.dwim.graphviz)) +(define-public ecl-bobbin + (sbcl-package->ecl-package sbcl-bobbin)) -(define-public sbcl-cl-dot - (let ((commit "73dfbb6e015a28ebed873266e4e8190e509b43de") +(define-public sbcl-bodge-blobs-support + (let ((commit "c5034ca5f4fc3a44dbadeba215a09afd59a404b0") + (revision "1")) + (package + (name "sbcl-bodge-blobs-support") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/borodust/bodge-blobs-support") + (commit commit))) + (file-name (git-file-name "bodge-blobs-support" version)) + (sha256 + (base32 "02nd1x6y1akp1ymv1y4z9ympwbnpd1drwi4f86xbjszxqff6jyj8")))) + (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-trivial-features)) + (inputs + (list sbcl-cffi sbcl-alexandria)) + (home-page "https://github.com/borodust/bodge-blobs-support") + (synopsis "Common Lisp utilities for blob packages") + (description + "This is a Common Lisp library for simplifying packaging and loading of +compiled foreign library collection.") + (license license:unlicense)))) + +(define-public cl-bodge-blobs-support + (sbcl-package->cl-source-package sbcl-bodge-blobs-support)) + +(define-public ecl-bodge-blobs-support + (sbcl-package->ecl-package sbcl-bodge-blobs-support)) + +(define-public sbcl-bodge-math + (let ((commit "9159b7faf88d440024c07110dbef2abddb20b9af") + (revision "1")) + (package + (name "sbcl-bodge-math") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/borodust/bodge-math") + (commit commit))) + (file-name (git-file-name "bodge-math" version)) + (sha256 + (base32 "0r3vnl9lywn4ksy34apcv6j825qp7l1naddawr14v4lwacndb80v")))) + (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-bodge-utilities sbcl-rtg-math)) + (home-page "https://github.com/borodust/bodge-math") + (synopsis "Common Lisp core math utilities of BODGE library collection") + (description + "This Common Lisp package contains the core math utilities of the +@emph{Bodge} library collection.") + (license license:expat)))) + +(define-public ecl-bodge-math + (sbcl-package->ecl-package sbcl-bodge-math)) + +(define-public cl-bodge-math + (sbcl-package->cl-source-package sbcl-bodge-math)) + +(define-public sbcl-bodge-queue + (let ((commit "948c9a501dcd412689952d09eb7453ec2722336a") (revision "0")) (package - (name "sbcl-cl-dot") - (version (git-version "0.9.0" revision commit)) + (name "sbcl-bodge-queue") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/michaelw/cl-dot") + (url "https://github.com/borodust/bodge-queue") (commit commit))) - (file-name (git-file-name "cl-dot" version)) + (file-name (git-file-name "bodge-queue" version)) (sha256 - (base32 "0mcvzqfcg5rzr8rz8aa2yr2jl3ifflaksvps08zj71hbhiacqpxa")))) + (base32 "148hjikqk8v2m30mj15xh89zni6szf9z3prav580qk9dqr8djjdr")))) (build-system asdf-build-system/sbcl) - (home-page "https://github.com/michaelw/cl-dot") - (synopsis "Generate Graphviz dot output from arbitrary Lisp data") - (description - "CL-DOT is a Common Lisp library for generating Graphviz dot output from -arbitrary Lisp data.") + (native-inputs + (list sbcl-fiveam)) + (home-page "https://github.com/borodust/bodge-queue") + (synopsis "Simple queue for Common Lisp") + (description "This Common Lisp library provides a simple FIFO +implementation with no external dependencies.") (license license:expat)))) -(define-public cl-dot - (sbcl-package->cl-source-package sbcl-cl-dot)) +(define-public cl-bodge-queue + (sbcl-package->cl-source-package sbcl-bodge-queue)) -(define-public ecl-cl-dot - (sbcl-package->ecl-package sbcl-cl-dot)) +(define-public ecl-bodge-queue + (sbcl-package->ecl-package sbcl-bodge-queue)) -(define-public sbcl-cl-graph - (let ((commit "c617de35390cb02db88bc5b5febffafdb8947ae8") - (revision "2")) +(define-public sbcl-bodge-utilities + (let ((commit "6304bac4abe06d53579e2c0fc4437d14ff077d9f") + (revision "1")) (package - (name "sbcl-cl-graph") - (version (git-version "0.10.2" revision commit)) + (name "sbcl-bodge-utilities") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/borodust/bodge-utilities") + (commit commit))) + (file-name (git-file-name "bodge-utilities" version)) + (sha256 + (base32 "1z1blj05q71vzh323qwyn9p3xs7v0mq2yhwfyzza5libp37wqm3c")))) + (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-alexandria + sbcl-cffi + sbcl-claw + sbcl-dissect + sbcl-local-time + sbcl-log4cl + sbcl-split-sequence + sbcl-static-vectors + sbcl-trivial-gray-streams)) + (home-page "https://github.com/borodust/bodge-utilities") + (synopsis "Common Lisp utilities library for CL-BODGE") + (description + "This Common Lisp library provides utilities for the @emph{Bodge} library +collection.") + (license license:expat)))) + +(define-public cl-bodge-utilities + (sbcl-package->cl-source-package sbcl-bodge-utilities)) + +(define-public ecl-bodge-utilities + (sbcl-package->ecl-package sbcl-bodge-utilities)) + +(define-public sbcl-boost-json + (let ((commit "eca166f5ff1f10bad14e00b9fd5bf9fcf3691a47") + (revision "0")) + (package + (name "sbcl-boost-json") + (version (git-version "1.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/hraban/cl-graph") + (url "https://github.com/cl-boost/json") (commit commit))) - (file-name (git-file-name "cl-graph" version)) + (file-name (git-file-name "cl-boost-json" version)) (sha256 - (base32 "0g1abkph9zb0m9zz6q2471ml9q9acdhwyapk8ra3bisqpwlxvpyf")))) + (base32 "12k0470899qsll2qixksxf2vrhjmskk3nzp1di9k04n1b29nrakd")))) (build-system asdf-build-system/sbcl) (arguments - ;; TODO: (Sharlatan-20221118T215839+0000): Tests failed - ;; - ;; https://github.com/gwkkwg/cl-graph/issues/17 - ;; - `(#:tests? #f - #:asd-systems '("cl-graph" "cl-graph+hu.dwim.graphviz"))) - (native-inputs - (list sbcl-lift sbcl-moptilities)) - (inputs - (list sbcl-cl-containers - sbcl-cl-mathstats - sbcl-dynamic-classes - sbcl-hu.dwim.graphviz - sbcl-metabang-bind - sbcl-metacopy - sbcl-metatilities-base)) - (home-page "https://github.com/gwkkwg/cl-graph") - (synopsis "Graph manipulation utilities for Common Lisp") + '(#:phases + (modify-phases %standard-phases + ;; See <https://github.com/cl-boost/json/pull/2>. + (add-after 'unpack 'fix-decode-symbol + (lambda _ + (substitute* '("decode.lisp" "encode.lisp") + (("formfeed") "page"))))))) + (home-page "https://github.com/cl-boost/json") + (synopsis "JSON encoding and decoding for Common Lisp") (description - "This package provides a Common Lisp library for manipulating graphs -and running graph algorithms.") - (license license:expat)))) + "BOOST-JSON is a simple JSON parsing library for Common Lisp.") + (license license:asl2.0)))) -;; NOTE: (Sharlatan-20221118T214734+0000): No ECL supoort -;; -;; ecl-cl-graph +(define-public cl-boost-json + (sbcl-package->cl-source-package sbcl-boost-json)) -(define-public cl-cl-graph - (sbcl-package->cl-source-package sbcl-cl-graph)) +(define-public ecl-boost-json + (sbcl-package->ecl-package sbcl-boost-json)) -(define-public sbcl-babel - ;; No release since 2014. - (let ((commit "627d6a60d0ffc82a3687b39ba8a99128031504d9") - (revision "3")) +(define-public sbcl-boost-lexer + (let ((commit "139ca9e9580f890698deec05061e495376b7735a") + (revision "0")) (package - (name "sbcl-babel") - (version (git-version "0.5.0" revision commit)) + (name "sbcl-boost-lexer") + (version (git-version "1.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/cl-babel/babel") + (url "https://github.com/cl-boost/lexer") (commit commit))) - (file-name (git-file-name "cl-babel" version)) + (file-name (git-file-name "cl-boost-lexer" version)) (sha256 - (base32 "1sndap9ykyyvrzlqm9smgqy49r3n67l926yg0hb7pm00plj0y380")))) + (base32 "01vsczb5cn62k2hkkn39xwh5fjn2x0b507n7afia98jnhhk3d5x4")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-hu.dwim.stefil)) (inputs - (list sbcl-alexandria sbcl-trivial-features)) - (home-page "https://common-lisp.net/project/babel/") - (synopsis "Charset encoding and decoding library") - (description "Babel is a charset encoding and decoding library, not unlike -GNU libiconv, but completely written in Common Lisp.") - (license (list license:bsd-2 license:expat))))) - -(define-public cl-babel - (sbcl-package->cl-source-package sbcl-babel)) - -(define-public ecl-babel - (sbcl-package->ecl-package sbcl-babel)) - -(define-public sbcl-cl-yacc - (package - (name "sbcl-cl-yacc") - (version "0.3") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/jech/cl-yacc") - (commit (string-append "cl-yacc-" version)))) - (sha256 - (base32 - "16946pzf8vvadnyfayvj8rbh4zjzw90h0azz2qk1mxrvhh5wklib")) - (file-name (string-append "cl-yacc-" version "-checkout")))) - (build-system asdf-build-system/sbcl) - (arguments - `(#:asd-systems '("yacc"))) - (synopsis "LALR(1) parser generator for Common Lisp, similar in spirit to Yacc") - (description - "CL-Yacc is a LALR(1) parser generator for Common Lisp, similar in spirit -to AT&T Yacc, Berkeley Yacc, GNU Bison, Zebu, lalr.cl or lalr.scm. - -CL-Yacc uses the algorithm due to Aho and Ullman, which is the one also used -by AT&T Yacc, Berkeley Yacc and Zebu. It does not use the faster algorithm due -to DeRemer and Pennello, which is used by Bison and lalr.scm (not lalr.cl).") - (home-page "https://www.irif.fr/~jch//software/cl-yacc/") - (license license:expat))) + (list sbcl-boost-re)) + (home-page "https://github.com/cl-boost/lexer") + (synopsis "String tokenizing for Common Lisp") + (description + "BOOST-LEXER is a tokenizer for Common Lisp that makes heavy use of +BOOST-RE.") + (license license:asl2.0)))) -(define-public cl-yacc - (sbcl-package->cl-source-package sbcl-cl-yacc)) +(define-public cl-boost-lexer + (sbcl-package->cl-source-package sbcl-boost-lexer)) -(define-public ecl-cl-yacc - (sbcl-package->ecl-package sbcl-cl-yacc)) +(define-public ecl-boost-lexer + (sbcl-package->ecl-package sbcl-boost-lexer)) -(define-public sbcl-eager-future2 - (let ((commit "54df8effd9d9eccac917509590286b5ac5f9cb30")) +(define-public sbcl-boost-parse + (let ((commit "c8f7e536b950752f3e35003e7ee0446e0fd51b50") + (revision "0")) (package - (name "sbcl-eager-future2") - (version (git-version "0.0.0" "1" commit)) + (name "sbcl-boost-parse") + (version (git-version "1.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://gitlab.common-lisp.net/vsedach/eager-future2.git") + (url "https://github.com/cl-boost/parse") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-boost-parse" version)) (sha256 - (base32 - "1qs1bv3m0ki8l5czhsflxcryh22r9d9g9a3a3b0cr0pl954q5rld")))) + (base32 "0djnp392n9wgpr9r2ycnwkglad5mn285yvr53jx3g7anm2p8r0vf")))) (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-bordeaux-threads sbcl-trivial-garbage)) - (synopsis "Futures promises synchronization mechanism for Common Lisp") + (home-page "https://github.com/cl-boost/parse") + (synopsis "Monadic parsing for Common Lisp") (description - "Eager Future2 is a Common Lisp library that provides composable -concurrency primitives that unify parallel and lazy evaluation, are integrated -with the Common Lisp condition system, and have automatic resource -management.") - (home-page "https://gitlab.common-lisp.net/vsedach/eager-future2") - (license license:lgpl3+)))) + "BOOST-PARSE is a simple token parsing library for Common Lisp.") + (license license:asl2.0)))) -(define-public cl-eager-future2 - (sbcl-package->cl-source-package sbcl-eager-future2)) +(define-public cl-boost-parse + (sbcl-package->cl-source-package sbcl-boost-parse)) -(define-public ecl-eager-future2 - (sbcl-package->ecl-package sbcl-eager-future2)) +(define-public ecl-boost-parse + (sbcl-package->ecl-package sbcl-boost-parse)) -(define-public sbcl-easy-routes - (let ((commit "7832f8bf3d07825b5eb967a2ef04da7c40c18248") +(define-public sbcl-boost-re + (let ((commit "d279fc58abf76d0c40aa6cde42e17a0591bc2c5d") (revision "0")) (package - (name "sbcl-easy-routes") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-boost-re") + (version (git-version "1.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/mmontone/easy-routes") + (url "https://github.com/cl-boost/re") (commit commit))) - (file-name (git-file-name "cl-easy-routes" version)) + (file-name (git-file-name "cl-boost-re" version)) (sha256 - (base32 "1banw54kz2llzb9h5sm47ckfc9l348m7qncm0npsy0w837rxkyzx")))) + (base32 "1h9c2rdhw6m1pm67gqbj46y2vb1kc3i1c9y3l4qhgfz14dbk80a2")))) (build-system asdf-build-system/sbcl) - (arguments - '(#:asd-systems '("easy-routes" - "easy-routes+djula" - "easy-routes+errors"))) - (native-inputs - (list sbcl-stefil)) (inputs - (list sbcl-djula - sbcl-hunchentoot - sbcl-hunchentoot-errors - sbcl-routes)) - (home-page "https://github.com/mmontone/easy-routes/") - (synopsis "Routes handling utility on top of Hunchentoot") + (list sbcl-boost-parse)) + (home-page "https://github.com/cl-boost/re") + (synopsis "Lua-style string pattern matching for Common Lisp") (description - "EASY-ROUTES is yet another routes handling system on top of -Hunchentoot. It's just glue code for Restas routing subsystem (CL-ROUTES). - -It supports: -@itemize -@item dispatch based on HTTP method -@item arguments extraction from the url path -@item decorators -@item URL generation from route names -@end itemize - -This package provides EASY-ROUTES, EASY-ROUTES+DJULA and EASY-ROUTES+ERRORS -systems.") - (license license:expat)))) + "BOOST-RE is a small, portable, lightweight, and quick, regular +expression library for Common Lisp. It is a non-recursive, backtracking VM.") + (license license:asl2.0)))) -(define-public cl-easy-routes - (sbcl-package->cl-source-package sbcl-easy-routes)) +(define-public cl-boost-re + (sbcl-package->cl-source-package sbcl-boost-re)) -(define-public ecl-easy-routes - (sbcl-package->ecl-package sbcl-easy-routes)) +(define-public ecl-boost-re + (sbcl-package->ecl-package sbcl-boost-re)) -(define-public sbcl-jpl-util - (let ((commit "0311ed374e19a49d43318064d729fe3abd9a3b62")) +(define-public sbcl-bordeaux-fft + (let ((commit "4a1f5600cae59bdabcb32de4ee2d7d73a9450d6e") + (revision "0")) (package - (name "sbcl-jpl-util") - (version "20151005") + (name "sbcl-bordeaux-fft") + (version (git-version "1.0.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - ;; Quicklisp uses this fork. - (url "https://github.com/hawkir/cl-jpl-util") + (url "https://github.com/ahefner/bordeaux-fft") (commit commit))) - (file-name - (git-file-name "jpl-util" version)) + (file-name (git-file-name name version)) (sha256 - (base32 - "0nc0rk9n8grkg3045xsw34whmcmddn2sfrxki4268g7kpgz0d2yz")))) + (base32 "0j584w6kq2k6r8lp2i14f9605rxhp3r15s33xs08iz1pndn6iwqf")))) (build-system asdf-build-system/sbcl) - (synopsis "Collection of Common Lisp utility functions and macros") + (home-page "http://vintage-digital.com/hefner/software/bordeaux-fft/") + (synopsis "Fast Fourier Transform for Common Lisp") (description - "@command{cl-jpl-util} is a collection of Common Lisp utility functions -and macros, primarily for software projects written in CL by the author.") - (home-page "https://www.thoughtcrime.us/software/cl-jpl-util/") - (license license:isc)))) + "The Bordeaux-FFT library provides a reasonably efficient implementation +of the Fast Fourier Transform and its inverse for complex-valued inputs, in +portable Common Lisp.") + (license license:gpl2+)))) -(define-public cl-jpl-util - (sbcl-package->cl-source-package sbcl-jpl-util)) +(define-public cl-bordeaux-fft + (sbcl-package->cl-source-package sbcl-bordeaux-fft)) -(define-public ecl-jpl-util - (sbcl-package->ecl-package sbcl-jpl-util)) +(define-public ecl-bordeaux-fft + (sbcl-package->ecl-package sbcl-bordeaux-fft)) -(define-public sbcl-piping - (let ((commit "c7a4163c00dea7e72bf6ad33d6abac0d5826a656") - (revision "1")) +(define-public sbcl-bordeaux-threads + (package + (name "sbcl-bordeaux-threads") + (version "0.9.3") + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/sionescu/bordeaux-threads") + (commit (string-append "v" version)))) + (sha256 + (base32 "0pp3w5hsph47sqagr4j2pbg3ddb29jx93zg8kvxsp2c4flp0qz0f")) + (file-name (git-file-name "cl-bordeaux-threads" version)))) + (inputs (list sbcl-alexandria + sbcl-global-vars + sbcl-trivial-features + sbcl-trivial-garbage)) + (native-inputs (list sbcl-fiveam)) + (build-system asdf-build-system/sbcl) + (arguments + (list + #:phases + #~(modify-phases %standard-phases + (add-after 'unpack 'adjust-test-sleep + (lambda _ + ;; 0.001 is too short for some slower machines. + (substitute* '("test/tests-v1.lisp" + "test/tests-v2.lisp") + (("sleep 0\\.001") "sleep 0.002"))))))) + (synopsis "Portable shared-state concurrency library for Common Lisp") + (description "BORDEAUX-THREADS is a proposed standard for a minimal +MP/Threading interface. It is similar to the CLIM-SYS threading and lock +support.") + (home-page "https://common-lisp.net/project/bordeaux-threads/") + (license license:x11))) + +(define-public cl-bordeaux-threads + (sbcl-package->cl-source-package sbcl-bordeaux-threads)) + +(define-public ecl-bordeaux-threads + (sbcl-package->ecl-package sbcl-bordeaux-threads)) + +(define-public sbcl-bst + (let ((commit "8545aed0d504df2829ad139566feeabe22305388") + (revision "0")) (package - (name "sbcl-piping") - (version (git-version "2.0.0" revision commit)) + (name "sbcl-bst") + (version (git-version "2.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/Shinmera/piping/") + (url "https://codeberg.org/glv/bst") (commit commit))) - (file-name (git-file-name "piping" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "0in84qnfkynm36d4n4d6v87vprpi27xrydnga462wfhplji6klv5")))) + (base32 "18ig7rvxcra69437g0i8sxyv7c5dg26jqnx1rc2f9pxmihdprgk8")))) (build-system asdf-build-system/sbcl) - (home-page "https://shinmera.github.io/piping/") - (synopsis "Library to enable simple message pipelines") + (native-inputs + (list sbcl-alexandria sbcl-fiveam)) + (synopsis "Binary search tree for Common Lisp") (description - "This is a Common Lisp library to enable simple message pipelines.") - (license license:zlib)))) + "BST is a Common Lisp library for working with binary search trees that +can contain any kind of values.") + (home-page "https://codeberg.org/glv/bst") + (license license:gpl3)))) -(define-public ecl-piping - (sbcl-package->ecl-package sbcl-piping)) +(define-public cl-bst + (sbcl-package->cl-source-package sbcl-bst)) -(define-public cl-piping - (sbcl-package->cl-source-package sbcl-piping)) +(define-public ecl-bst + (sbcl-package->ecl-package sbcl-bst)) -(define-public sbcl-bobbin - (let ((commit "b454e8241b24ceab674eeeae464c8082b1b6d8ce") +(define-public sbcl-bubble-operator-upwards + (let ((commit "846275a318b960de81b62caecb1e31930f70aef6") (revision "0")) (package - (name "sbcl-bobbin") - (version (git-version "1.0.1" revision commit)) + (name "sbcl-bubble-operator-upwards") + (version (git-version "1.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/sjl/bobbin") + (url "https://github.com/Hexstream/bubble-operator-upwards") (commit commit))) - (file-name (git-file-name "cl-bobbin" version)) + (file-name (git-file-name "cl-bubble-operator-upwards" version)) (sha256 - (base32 "02lw7w8cbvnxw5acbz405rb5lcqsf4fx7dvj5ldr0lhgbyv1mjnm")))) + (base32 "0ybsy29ms3yrxgr7f2146lr6z4vm070dvdyzvwwxjh4dgm9na7bi")))) (build-system asdf-build-system/sbcl) (native-inputs - (list sbcl-1am)) - (inputs - (list sbcl-split-sequence)) - (home-page "https://docs.stevelosh.com/bobbin/") - (synopsis "Simple (word) wrapping utilities for strings") + (list sbcl-parachute)) + (home-page "https://www.hexstreamsoft.com/libraries/bubble-operator-upwards/") + (synopsis "Function that bubbles an operator upwards in a form") (description - "Bobbin is a simple word-wrapping library for strings in Common Lisp. -It aims to be simple, work nicely for the majority of cases, and degrade -gracefully for edge cases. It is not particularly concerned with speed — if -you need very high-performance word wrapping, Bobbin is not for you.") - (license license:expat)))) + "@code{bubble-operator-upwards} is a function that bubbles an operator +upwards in a form, demultiplexing all alternative branches by way of +cartesian product.") + (license license:unlicense)))) -(define-public cl-bobbin - (sbcl-package->cl-source-package sbcl-bobbin)) +(define-public cl-bubble-operator-upwards + (sbcl-package->cl-source-package sbcl-bubble-operator-upwards)) -(define-public ecl-bobbin - (sbcl-package->ecl-package sbcl-bobbin)) +(define-public ecl-bubble-operator-upwards + (sbcl-package->ecl-package sbcl-bubble-operator-upwards)) -(define-public sbcl-cl-pcg - (let ((commit "8263d85ab0ca17fb05637a4430c2d564456bce8f") - (revision "1")) +(define-public sbcl-burgled-batteries3 + (let ((commit "f65f454d13bb6c40e17e9ec62e41eb5069e09760") + (revision "2")) (package - (name "sbcl-cl-pcg") - (version (git-version "1.0.0" revision commit)) + (name "sbcl-burgled-batteries3") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/sjl/cl-pcg") + (url "https://github.com/snmsts/burgled-batteries3") (commit commit))) - (file-name (git-file-name "cl-pcg" version)) + (file-name (git-file-name "cl-burgled-batteries3" version)) (sha256 - (base32 "0s57wvvlvshp1gcp9i9d3qcmqhswnxps3i0y7wbb0v8i1a3p46m4")))) + (base32 + "1nzn7jawrfajyzwfnzrg2cmn9xxadcqh4szbpg0jggkhdkdzz4wa")) + (patches + (search-patches "sbcl-burgled-batteries3-fix-signals.patch")))) (build-system asdf-build-system/sbcl) + (arguments + `(#:tests? #f + #:modules (((guix build python-build-system) #:select (python-version)) + ,@%asdf-build-system-modules) + #:imported-modules ((guix build python-build-system) + ,@%asdf-build-system-modules) + #:phases + (modify-phases (@ (guix build asdf-build-system) %standard-phases) + (add-after 'unpack 'set-*cpython-include-dir*-var + (lambda* (#:key inputs #:allow-other-keys) + (let ((python (assoc-ref inputs "python"))) + (setenv "BB_PYTHON3_INCLUDE_DIR" + (string-append python "/include/python" + (python-version python))) + (setenv "BB_PYTHON3_DYLIB" + (string-append python "/lib/libpython3.so")) + #t))) + (add-after 'unpack 'adjust-for-python-3.10 + (lambda _ + ;; These methods are no longer part of the public API. + (substitute* "ffi-interface.lisp" + ((".*PyEval_ReInitThreads.*") "") + ((".*\"PyErr_Warn\".*") "") + ((".*\"PyFloat_ClearFreeList\".*") "") + ((".*\"PyParser_SimpleParseString\".*") "") + ((".*\"PyParser_SimpleParseStringFlags\".*") "") + ((".*\"PyParser_SimpleParseStringFlagsFilename\".*") "") + ((".*\"PyParser_SimpleParseFile\".*") "") + ((".*\"PyParser_SimpleParseFileFlags\".*") "") + ((".*\"PyLong_FromUnicode\".*") ""))))))) (native-inputs - (list sbcl-1am)) - (home-page "https://github.com/sjl/cl-pcg") - (synopsis "Permuted congruential generators in Common Lisp") + (list sbcl-cl-fad sbcl-lift sbcl-cl-quickcheck)) + (inputs + (list python + sbcl-alexandria + sbcl-cffi + sbcl-parse-declarations + sbcl-trivial-garbage)) + (synopsis "Bridge between Python and Lisp (FFI bindings, etc.)") (description - "This is a bare-bones Permuted Congruential Generator implementation in -pure Common Lisp.") + "This package provides a shim between Python3 (specifically, the +CPython implementation of Python) and Common Lisp.") + (home-page "https://github.com/snmsts/burgled-batteries3") (license license:expat)))) -(define-public ecl-cl-pcg - (let ((pkg (sbcl-package->ecl-package sbcl-cl-pcg))) - (package - (inherit pkg) - (arguments - (substitute-keyword-arguments (package-arguments pkg) - ;; Tests are failing on ECL with: - ;; PCG.TEST::TEST-REWINDAn error occurred during initialization: - ;; 40502229875678917802724098623316930025 is not of type - ;; (INTEGER 0 2305843009213693951) - ((#:tests? _ #f) #f)))))) +(define-public cl-burgled-batteries3 + (sbcl-package->cl-source-package sbcl-burgled-batteries3)) -(define-public cl-pcg - (sbcl-package->cl-source-package sbcl-cl-pcg)) +(define-public ecl-burgled-batteries3 + (sbcl-package->ecl-package sbcl-burgled-batteries3)) -(define-public sbcl-seedable-rng - (let ((commit "aa1a1564b6e07e2698df37c7a98348c4f762cb15") +(define-public sbcl-cache-while + (let ((commit "38e9ffbdb2c894670c366c1e5802ffcc8cfd43a7") (revision "1")) (package - (name "sbcl-seedable-rng") + (name "sbcl-cache-while") (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://git.mfiano.net/mfiano/seedable-rng") + (url "https://github.com/charje/cache-while") (commit commit))) - (file-name (git-file-name "seedable-rng" version)) + (file-name (git-file-name "cache-while" version)) (sha256 - (base32 "1ldpsbp3qrfzvknclsxj3sdyms1jf9ad20dvh4w0kw3zgahn2nr5")))) + (base32 "1qil68rfn5irmkb0jk1f6g1zy80wgc3skl8cr4rfgh7ywgm5izx3")))) (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-cl-pcg sbcl-golden-utils sbcl-ironclad)) - (home-page "https://git.mfiano.net/mfiano/seedable-rng") - (synopsis "Common Lisp random number generator") + (home-page "https://github.com/charje/cache-while") + (synopsis "Temporary / one-time caching macro for Common Lisp") (description - "SEEDABLE-RNG provides a convenient means of generating random numbers -that are seedable with deterministic results across hardware and Common Lisp -implementations.") - (license license:expat)))) - -(define-public ecl-seedable-rng - (sbcl-package->ecl-package sbcl-seedable-rng)) - -(define-public cl-seedable-rng - (sbcl-package->cl-source-package sbcl-seedable-rng)) - -(define-public sbcl-jpl-queues - (package - (name "sbcl-jpl-queues") - (version "0.1") - (source - (origin - (method url-fetch) - (uri (string-append - "http://www.thoughtcrime.us/software/jpl-queues/jpl-queues-" - version - ".tar.gz")) - (sha256 - (base32 - "1wvvv7j117h9a42qaj1g4fh4mji28xqs7s60rn6d11gk9jl76h96")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("jpl-util" ,sbcl-jpl-util) - ("bordeaux-threads" ,sbcl-bordeaux-threads))) - (arguments - ;; Tests seem to be broken. - `(#:tests? #f)) - (synopsis "Common Lisp library implementing a few different kinds of queues") - (description - "A Common Lisp library implementing a few different kinds of queues: - -@itemize -@item Bounded and unbounded FIFO queues. -@item Lossy bounded FIFO queues that drop elements when full. -@item Unbounded random-order queues that use less memory than unbounded FIFO queues. -@end itemize - -Additionally, a synchronization wrapper is provided to make any queue -conforming to the @command{jpl-queues} API thread-safe for lightweight -multithreading applications. (See Calispel for a more sophisticated CL -multithreaded message-passing library with timeouts and alternation among -several blockable channels.)") - (home-page "https://www.thoughtcrime.us/software/jpl-queues/") - (license license:isc))) + "This is a Common Lisp macro for defining temporary caches that +invalidate based on expressions evaluating to different values.") + (license license:llgpl)))) -(define-public cl-jpl-queues - (sbcl-package->cl-source-package sbcl-jpl-queues)) +(define-public cl-cache-while + (sbcl-package->cl-source-package sbcl-cache-while)) -(define-public ecl-jpl-queues - (sbcl-package->ecl-package sbcl-jpl-queues)) +(define-public ecl-cache-while + (sbcl-package->ecl-package sbcl-cache-while)) (define-public sbcl-calispel (let ((commit "e9f2f9c1af97f4d7bb4c8ac25fb2a8f3e8fada7a")) @@ -3405,1894 +2639,1489 @@ Lisp.") (define-public ecl-calm (sbcl-package->ecl-package sbcl-calm)) -(define-public sbcl-esrap - (let ((commit "d806138342a6b27327649fd5f36e0fe2e0966867") - (revision "4")) +(define-public sbcl-cambl + (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636") + (revision "1")) (package - (name "sbcl-esrap") - (version (git-version "0.18" revision commit)) + (name "sbcl-cambl") + (version (git-version "4.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/scymtym/esrap") + (url "https://github.com/jwiegley/cambl") (commit commit))) - (file-name (git-file-name "cl-esrap" version)) + (file-name (git-file-name "cambl" version)) (sha256 - (base32 "0gs0mfamldhaihnlk0qxg2q4bl8bamq68dif9js9fkl8apg3iykl")))) + (base32 "103mry04j2k9vznsxm7wcvccgxkil92cdrv52miwcmxl8daa4jiz")))) (build-system asdf-build-system/sbcl) (native-inputs - (list sbcl-fiveam)) + (list sbcl-xlunit)) (inputs - (list sbcl-alexandria sbcl-trivial-with-current-source-form)) - (synopsis "Common Lisp packrat parser") + `(("alexandria" ,sbcl-alexandria) + ("cl-containers" ,sbcl-cl-containers) + ("local-time" ,sbcl-local-time) + ("periods" ,sbcl-periods))) + (synopsis "Commoditized amounts and balances for Common Lisp") (description - "This is a packrat parser for Common Lisp. -In addition to regular Packrat / Parsing Grammar / TDPL features ESRAP supports: - -@itemize -@item dynamic redefinition of nonterminals -@item inline grammars -@item semantic predicates -@item introspective facilities (describing grammars, tracing, setting breaks) -@item left-recursive grammars -@item functions as terminals -@item accurate, customizable parse error reports -@end itemize\n") - (home-page "https://scymtym.github.io/esrap/") - (license license:expat)))) + "CAMBL is a Common Lisp library providing a convenient facility for +working with commoditized values. It does not allow compound units (and so is +not suited for scientific operations) but does work rather nicely for the +purpose of financial calculations.") + (home-page "https://github.com/jwiegley/cambl") + (license license:bsd-3)))) -(define-public cl-esrap - (sbcl-package->cl-source-package sbcl-esrap)) +(define-public cl-cambl + (sbcl-package->cl-source-package sbcl-cambl)) -(define-public ecl-esrap - (sbcl-package->ecl-package sbcl-esrap)) +(define-public ecl-cambl + (sbcl-package->ecl-package sbcl-cambl)) -(define-public sbcl-split-sequence +(define-public sbcl-canonicalized-initargs (package - (name "sbcl-split-sequence") - (version "2.0.1") + (name "sbcl-canonicalized-initargs") + (version "2.0") (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/sharplispers/split-sequence") + (url "https://github.com/Hexstream/canonicalized-initargs") (commit (string-append "v" version)))) + (file-name (git-file-name "cl-canonicalized-initargs" version)) (sha256 - (base32 - "172k7iv775kwism6304p6z7mqpjvipl57nq1bgvmbk445943fmhq")) - (file-name (git-file-name "split-sequence" version)))) + (base32 "0jmmjw86x9mmlfla4kdmdqf1fjrj0p2fmv1lc4k555mcf67mj2fq")))) (build-system asdf-build-system/sbcl) (native-inputs - (list sbcl-fiveam)) - (synopsis "Member of the Common Lisp Utilities family of programs") - (description - "Splits sequence into a list of subsequences delimited by objects -satisfying the test.") - (home-page "https://cliki.net/split-sequence") - (license license:expat))) - -(define-public cl-split-sequence - (sbcl-package->cl-source-package sbcl-split-sequence)) - -(define-public ecl-split-sequence - (sbcl-package->ecl-package sbcl-split-sequence)) - -(define-public sbcl-html-encode - (package - (name "sbcl-html-encode") - (version "1.2") - (source - (origin - (method url-fetch) - (uri (string-append - "http://beta.quicklisp.org/archive/html-encode/2010-10-06/html-encode-" - version ".tgz")) - (sha256 - (base32 - "06mf8wn95yf5swhmzk4vp0xr4ylfl33dgfknkabbkd8n6jns8gcf")))) - (build-system asdf-build-system/sbcl) - (synopsis "Common Lisp library for encoding text in various web-savvy encodings") + (list sbcl-parachute)) + (inputs + (list sbcl-cesdi + sbcl-closer-mop + sbcl-compatible-metaclasses + sbcl-enhanced-defclass + sbcl-enhanced-typep)) + (home-page + "https://www.hexstreamsoft.com/libraries/canonicalized-initargs/") + (synopsis "Standard way to canonicalize slot values") (description - "A library for encoding text in various web-savvy encodings.") - (home-page "https://quickdocs.org/html-encode/") - (license license:expat))) + "This package provides a standard way to canonicalize slot values.") + (license license:unlicense))) -(define-public cl-html-encode - (sbcl-package->cl-source-package sbcl-html-encode)) +(define-public cl-canonicalized-initargs + (sbcl-package->cl-source-package sbcl-canonicalized-initargs)) -(define-public ecl-html-encode - (sbcl-package->ecl-package sbcl-html-encode)) +(define-public ecl-canonicalized-initargs + (sbcl-package->ecl-package sbcl-canonicalized-initargs)) -(define-public sbcl-colorize - (let ((commit "ea676b584e0899cec82f21a9e6871172fe3c0eb5")) +(define-public sbcl-caveman + (let ((commit "35cd8bc6c322f9d88498405fc26168a1fb42ae1c") ; No release since 2012 + (revision "2")) (package - (name "sbcl-colorize") - (version (git-version "0.0.0" "1" commit)) + (name "sbcl-caveman") + (version (git-version "2.4.0" revision commit)) + (home-page "https://8arrow.org/caveman/") (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/kingcons/colorize") + (url "https://github.com/fukamachi/caveman/") (commit commit))) + (file-name (git-file-name "cl-caveman" version)) (sha256 - (base32 - "1pdg4kiaczmr3ivffhirp7m3lbr1q27rn7dhaay0vwghmi31zcw9")) - (file-name (git-file-name "colorize" version)))) + (base32 "1wvjm9m1fnapg0r9imhhcwgnhhqkkccnj3c0iw9yg1f72d7zhm2w")))) (build-system asdf-build-system/sbcl) (inputs - (list sbcl-alexandria sbcl-split-sequence sbcl-html-encode)) - (synopsis "Common Lisp for syntax highlighting") - (description - "@command{colorize} is a Lisp library for syntax highlighting -supporting the following languages: Common Lisp, Emacs Lisp, Scheme, Clojure, -C, C++, Java, Python, Erlang, Haskell, Objective-C, Diff, Webkit.") - (home-page "https://github.com/kingcons/colorize") - ;; TODO: Missing license? - (license license:expat)))) + `(("ningle" ,cl-ningle) + ("lack" ,sbcl-lack) + ("cl-project" ,sbcl-cl-project) + ("dbi" ,sbcl-dbi) + ("sxql" ,sbcl-sxql) + ("cl-syntax" ,sbcl-cl-syntax) + ("myway" ,sbcl-myway) + ("quri" ,sbcl-quri))) + (native-inputs + `(("usocket" ,sbcl-usocket) + ("dexador" ,sbcl-dexador) + ("lack" ,sbcl-lack) + ("trivial-types" ,sbcl-trivial-types) + ("prove" ,sbcl-prove))) + (arguments + `(#:asd-systems '("caveman2" + "caveman2-db" + "caveman2-test" + "caveman-middleware-dbimanager") + ;; TODO: Tests fail with: + ;; writing /gnu/store/...-sbcl-caveman-2.4.0-1.faa5f7e/share/common-lisp/sbcl-source/caveman2/v2/t/tmp/myapp573/tests/myapp573.lisp + ;; While evaluating the form starting at line 38, column 0 + ;; of #P"/tmp/guix-build-sbcl-caveman-2.4.0-1.faa5f7e.drv-0/source/v2/t/caveman.lisp": + ;; Unhandled ASDF/FIND-COMPONENT:MISSING-COMPONENT in thread #<SB-THREAD:THREAD "main thread" RUNNING + ;; {10009F8083}>: + ;; Component "myapp573" not found + ;; + ;; The above myapp573 component name is randomly generated by + ;; gensym on each test run. `(asdf:load-system *app-name*)` tries + ;; to load this component and fails. + ;; TODO: Ask fukamachi how to go around this. + #:tests? #f)) + (synopsis "Lightweight web application framework in Common Lisp") + (description "Caveman is intended to be a collection of common parts for +web applications. Caveman2 has three design goals: -(define-public cl-colorize - (sbcl-package->cl-source-package sbcl-colorize)) +@itemize +@item Be extensible. +@item Be practical. +@item Don't force anything. +@end itemize\n") + (license license:llgpl)))) -(define-public ecl-colorize - (sbcl-package->ecl-package sbcl-colorize)) +(define-public cl-caveman + (package + (inherit + (sbcl-package->cl-source-package sbcl-caveman)) + (propagated-inputs + `(("ningle" ,cl-ningle))))) -(define-public sbcl-3bmd - (let ((commit "e68b2d442f29b4534c1c8e2f2cdf7583643a2fc5") - (revision "4")) +(define-public ecl-caveman + (sbcl-package->ecl-package sbcl-caveman)) + +(define-public sbcl-cells + (let ((commit "e8542b17fddd6340c1e237ce482a52327c8ead8e")) (package - (name "sbcl-3bmd") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-cells") + (version (git-version "3.0" "1" commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/3b/3bmd") + (url "https://github.com/kennytilton/cells") (commit commit))) + (file-name (git-file-name "cl-cells" version)) (sha256 - (base32 "12xqih1gnwsn1baqm7bq3kxss73phn06gvd0v1h1vwsjd1xgpq3g")) - (file-name (git-file-name "cl-3bmd" version)))) + (base32 "0rkzvwq38lwb1045w54kw020pb9i63hxiawwhqkf8k1inhak3fdk")))) (build-system asdf-build-system/sbcl) - (arguments - `(#:asd-systems - '("3bmd" - "3bmd-ext-definition-lists" - "3bmd-ext-math" - "3bmd-ext-tables" - "3bmd-ext-wiki-links" - "3bmd-youtube" - "3bmd-ext-code-blocks") - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-python3-path - (lambda _ - (substitute* "code-blocks.lisp" - (("python3") (which "python3")))))))) - (native-inputs - (list sbcl-fiasco)) (inputs - (list python - python-pygments - sbcl-alexandria - sbcl-colorize - sbcl-split-sequence - sbcl-esrap)) - (home-page "https://github.com/3b/3bmd") - (synopsis "Markdown processor in Command Lisp using esrap parser") + (list sbcl-utils-kt)) + (arguments + ;; Tests fail with #<TYPE-ERROR expected-type: STREAM datum: NIL>. + '(#:tests? #f)) + (home-page "https://github.com/kennytilton/cells") + (synopsis "Common Lisp implementation of the dataflow programming paradigm") (description - "This is a Common Lisp Markdown to HTML converter, using @command{esrap} -for parsing, and grammar based on @command{peg-markdown}.") - (license license:expat)))) + "Cells is a mature, stable extension to CLOS allowing one to create +classes whose instances can have slot values determined by instance-specific +formulas.") + (license license:llgpl)))) -(define-public cl-3bmd - (sbcl-package->cl-source-package sbcl-3bmd)) +(define-public cl-cells + (sbcl-package->cl-source-package sbcl-cells)) -(define-public ecl-3bmd - (sbcl-package->ecl-package sbcl-3bmd)) +(define-public ecl-cells + (sbcl-package->ecl-package sbcl-cells)) -(define-public sbcl-cl-fad - ;; No release since 2019 - (let ((commit "3f4d32d3aa1093966046d001411a852eb8f4b535") - (revision "1")) +(define-public sbcl-cephes + (let ((commit "d87146fa38c8425ffb5fe425eee5eb3e818bacd4") + (revision "0")) (package - (name "sbcl-cl-fad") - (version (git-version "0.7.6" revision commit)) + (name "sbcl-cephes") + (version (git-version "1.2" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/edicl/cl-fad/") + (url "https://github.com/Lisp-Stat/cephes.cl") (commit commit))) + (file-name (git-file-name "cl-cephes" version)) (sha256 - (base32 "0a1xqldrq170lflnns3xp6swpnvsvllf5vq0h7sz8jqh4riqlny6")) - (file-name (git-file-name "cl-fad" version)))) + (base32 "09adls1lwwzwm1jmvhf11arwlsy5w0bi2rmniahas824mysv77lr")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-cl-ppcre sbcl-unit-test)) (inputs - (list sbcl-alexandria sbcl-bordeaux-threads)) - (synopsis "Portable pathname library for Common Lisp") + (list sbcl-cffi)) + (arguments + (list #:phases + #~(modify-phases %standard-phases + ;; ECL has issues making the shared library automatically, + ;; so we make it explicitly. + (add-before 'build 'build-shared-library + (lambda _ + (with-directory-excursion + (string-append #$output "/share/common-lisp/" + (%lisp-type) "/cephes/scipy-cephes") + (invoke "make") + ;; Remove temporary object files. + (for-each delete-file (find-files "." "\\.o$")))))))) + (home-page "https://lisp-stat.github.io/cephes.cl/") + (synopsis "Common Lisp wrapper for the Cephes Mathematical Library") (description - "CL-FAD (for \"Files and Directories\") is a thin layer atop Common -Lisp's standard pathname functions. It is intended to provide some -unification between current CL implementations on Windows, OS X, Linux, and -Unix. Most of the code was written by Peter Seibel for his book Practical -Common Lisp.") - (home-page "https://edicl.github.io/cl-fad/") - (license license:bsd-2)))) + "This package provides a common lisp CFFI wrapper for the SciPy version +of Cephes special functions.") + (license license:ms-pl)))) -(define-public cl-fad - (sbcl-package->cl-source-package sbcl-cl-fad)) +(define-public cl-cephes + (sbcl-package->cl-source-package sbcl-cephes)) -(define-public ecl-cl-fad - (sbcl-package->ecl-package sbcl-cl-fad)) +(define-public ecl-cephes + (sbcl-package->ecl-package sbcl-cephes)) -(define-public sbcl-fn - (let ((commit "8d8587d03a7b5e26b306fc90018e385d9e5acc2c") +(define-public sbcl-cepl + (let ((commit "d1a10b6c8f4cedc07493bf06aef3a56c7b6f8d5b") (revision "1")) (package - (name "sbcl-fn") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/cbaggers/fn") - (commit commit))) - (file-name (git-file-name "fn" version)) - (sha256 - (base32 "0yyp9z6iwx476whz0n1rpjznjyqqhlylhzwpgg5xx92lxmskl752")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-named-readtables)) - (home-page "https://github.com/cbaggers/fn") - (synopsis "Macros for lambda brevity") - (description - "This is a Common Lisp library providing lambda shorthand macros aiming -to be used in cases where the word @emph{lambda} and the arguments are longer -than the body of the lambda.") - (license license:public-domain)))) - -(define-public ecl-fn - (sbcl-package->ecl-package sbcl-fn)) - -(define-public cl-fn - (sbcl-package->cl-source-package sbcl-fn)) + (name "sbcl-cepl") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/cbaggers/cepl") + (commit commit))) + (file-name (git-file-name "cepl" version)) + (sha256 + (base32 "0izbw2advqm3wailj3dpq6zqfrfirwn14pw5qmqh8i71r51xwmm2")))) + (build-system asdf-build-system/sbcl) + (inputs + `(("alexandria" ,sbcl-alexandria) + ("bordeaux-threads" ,sbcl-bordeaux-threads) + ("cffi" ,sbcl-cffi) + ("cl-opengl" ,sbcl-cl-opengl) + ("cl-ppcre" ,sbcl-cl-ppcre) + ("documentation-utils" ,sbcl-documentation-utils) + ("float-features" ,sbcl-float-features) + ("ieee-floats" ,sbcl-ieee-floats) + ("split-sequence" ,sbcl-split-sequence) + ("varjo" ,sbcl-varjo))) + (propagated-inputs + (list sbcl-quickproject)) + (home-page "https://github.com/cbaggers/cepl") + (synopsis "Development playground to work with OpenGL") + (description + "CEPL (Code Evaluate Play Loop ) is a lispy and REPL-friendly Common Lisp +library for working with OpenGL. -(define-public sbcl-nibbles - ;; No tagged release since 2018. - (let ((commit "a46a67736e07b548cdd7485cb36834f7942313f1") - (revision "3")) - (package - (name "sbcl-nibbles") - (version (git-version "0.14" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/sharplispers/nibbles/") - (commit commit))) - (file-name (git-file-name "cl-nibbles" version)) - (sha256 - (base32 "12qjich11hp31dhbvbsixyjbddmr6faaajigrivgbxy9kw6d279j")))) - (build-system asdf-build-system/sbcl) - (native-inputs - ;; Tests only. - (list sbcl-rt)) - (synopsis - "Common Lisp library for accessing octet-addressed blocks of data") - (description - "When dealing with network protocols and file formats, it's common to -have to read or write 16-, 32-, or 64-bit datatypes in signed or unsigned -flavors. Common Lisp sort of supports this by specifying :element-type for -streams, but that facility is underspecified and there's nothing similar for -read/write from octet vectors. What most people wind up doing is rolling their -own small facility for their particular needs and calling it a day. +Its definition of success is making the user feel that GPU programming has +always been part of the languages standard. -This library attempts to be comprehensive and centralize such -facilities. Functions to read 16-, 32-, and 64-bit quantities from octet -vectors in signed or unsigned flavors are provided; these functions are also -SETFable. Since it's sometimes desirable to read/write directly from streams, -functions for doing so are also provided. On some implementations, -reading/writing IEEE singles/doubles (i.e. single-float and double-float) will -also be supported.") - (home-page "https://github.com/sharplispers/nibbles") - (license license:bsd-3)))) +The usual approach to using CEPL is to start it at the beginning of your Lisp +session and leave it open for the duration of your work. You can then treat the +window it creates as just another output for your graphics, analogous to how +@code{*standard-output*} is treated for text.") + (license license:bsd-2)))) -(define-public cl-nibbles - (sbcl-package->cl-source-package sbcl-nibbles)) +(define-public cl-cepl + (sbcl-package->cl-source-package sbcl-cepl)) -(define-public ecl-nibbles - (sbcl-package->ecl-package sbcl-nibbles)) +(define-public ecl-cepl + (sbcl-package->ecl-package sbcl-cepl)) -(define-public sbcl-ironclad +(define-public sbcl-cesdi (package - (name "sbcl-ironclad") - (version "0.60") + (name "sbcl-cesdi") + (version "1.0.1") (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/sharplispers/ironclad/") - (commit (string-append "v" version)))) + (url "https://github.com/Hexstream/cesdi") + (commit version))) + (file-name (git-file-name "cl-cesdi" version)) (sha256 - (base32 "122ldxiddkscb3li5wjrppr7vyn77znyjfgs8pbflrskzyxlabdd")) - (file-name (git-file-name "cl-ironclad" version)))) + (base32 "02f2pz5rw79ljkkx1ywh8nkpjj4g3z3s1lyvzqb8krbnx11wl0q9")))) (build-system asdf-build-system/sbcl) (native-inputs - ;; Tests only. - (list sbcl-rt)) + (list sbcl-parachute)) (inputs - (list sbcl-bordeaux-threads sbcl-flexi-streams)) - (synopsis "Cryptographic toolkit written in Common Lisp") + (list sbcl-closer-mop)) + (home-page "https://www.hexstreamsoft.com/libraries/cesdi/") + (synopsis "Ergonomic initialization of effective slot definition objects") (description - "Ironclad is a cryptography library written entirely in Common Lisp. -It includes support for several popular ciphers, digests, MACs and public key -cryptography algorithms. For several implementations that support Gray -streams, support is included for convenient stream wrappers.") - (home-page "https://github.com/sharplispers/ironclad") - (license license:bsd-3))) - -(define-public cl-ironclad - (sbcl-package->cl-source-package sbcl-ironclad)) - -(define-public ecl-ironclad - (sbcl-package->ecl-package sbcl-ironclad)) - -(define-public sbcl-named-readtables - (let ((commit "d5ff162ce02035ec7de1acc9721385f325e928c0") - (revision "4")) - (package - (name "sbcl-named-readtables") - (version (git-version "0.9" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/melisgl/named-readtables") - (commit commit))) - (sha256 - (base32 "0gfgxywzbmavy0kpnxav11vz10qfzxwwrpgqaak9sgzg17g8x5yv")) - (file-name (git-file-name "cl-named-readtables" version)))) - (build-system asdf-build-system/sbcl) - ;; (native-inputs (list sbcl-try)) - ;; Tests disabled because of a circular dependency issue: - ;; try -> named-readtables -> mgl-pax -> try - (arguments - (list #:tests? #f)) - (home-page "https://github.com/melisgl/named-readtables/") - (synopsis "Library that creates a namespace for named readtables") - (description - "Named readtables is a library that creates a namespace for named -readtables, which is akin to package namespacing in Common Lisp.") - (license license:bsd-3)))) - -(define-public cl-named-readtables - (sbcl-package->cl-source-package sbcl-named-readtables)) - -(define-public ecl-named-readtables - (sbcl-package->ecl-package sbcl-named-readtables)) - -(define-public sbcl-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 - (list sbcl-parse-number)) - (home-page "https://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-cl-ini - (let ((commit "e630acb405022a7ae11969bf908669fee1191ab7") - (revision "0")) - (package - (name "sbcl-cl-ini") - (version (git-version "0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/compufox/cl-ini") - (commit commit))) - (file-name (git-file-name "sbcl-cl-ini" version)) - (sha256 - (base32 - "12vy3gspqn0wmkyz5id1xrgv1scgb16m7pkvmbmi19vlpj2iyq7p")))) - (build-system asdf-build-system/sbcl) - (native-inputs (list sbcl-prove)) - (inputs (list sbcl-cl-str)) - (home-page "https://github.com/compufox/cl-ini") - (synopsis "INI file parser for Common Lisp") - (description - "Parse INI formatted files into a Common Lisp list structure.") - (license license:expat)))) + "This package provides a @code{compute-effective-slot-definition-initargs} +generic function that allows for more ergonomic initialization of effective slot +definition objects.") + (license license:unlicense))) -(define-public cl-ini - (sbcl-package->cl-source-package sbcl-cl-ini)) +(define-public cl-cesdi + (sbcl-package->cl-source-package sbcl-cesdi)) -(define-public ecl-cl-ini - (sbcl-package->ecl-package sbcl-cl-ini)) +(define-public ecl-cesdi + (sbcl-package->ecl-package sbcl-cesdi)) -(define-public sbcl-pythonic-string-reader - (let ((commit "47a70ba1e32362e03dad6ef8e6f36180b560f86a")) +(define-public sbcl-cf + (let ((commit "fbc025b6f274687ee9acc8d07496d44999ac428e") + (revision "2")) (package - (name "sbcl-pythonic-string-reader") - (version (git-version "0.0.0" "1" commit)) + (name "sbcl-cf") + (version (git-version "1.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/smithzvk/pythonic-string-reader/") + (url "https://codeberg.org/glv/cl-cf") (commit commit))) + (file-name (git-file-name "cl-cf" version)) (sha256 - (base32 "1b5iryqw8xsh36swckmz8rrngmc39k92si33fgy5pml3n9l5rq3j")) - (file-name (git-file-name "pythonic-string-reader" version)))) + (base32 "182laa57j9qs567g75qwf8vh4xb0d22lr94x84r32dy28mrwi5ig")))) (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-named-readtables)) - (home-page "https://github.com/smithzvk/pythonic-string-reader") - (synopsis "Read table modification inspired by Python's three quote strings") - (description "This piece of code sets up some reader macros that make it -simpler to input string literals which contain backslashes and double quotes -This is very useful for writing complicated docstrings and, as it turns out, -writing code that contains string literals that contain code themselves.") - (license license:bsd-3)))) - -(define-public cl-pythonic-string-reader - (sbcl-package->cl-source-package sbcl-pythonic-string-reader)) - -(define-public ecl-pythonic-string-reader - (sbcl-package->ecl-package sbcl-pythonic-string-reader)) - -(define-public sbcl-slime-swank - ;; Update together with emacs-slime. - (package - (name "sbcl-slime-swank") - (version "2.29.1") - (source - (origin - (file-name (git-file-name "cl-slime-swank" version)) - (method git-fetch) - (uri (git-reference - (url "https://github.com/slime/slime/") - (commit (string-append "v" version)))) - (sha256 - (base32 "1fcasqsdfwsphkfx1vd3r5mr89vgvzb9g2dbw82mc9lijg1mr1ki")) - (modules '((guix build utils))) - (snippet - ;; The doc folder drags `gawk' into the closure. Doc is already - ;; provided by emacs-slime. - `(begin - (delete-file-recursively "doc") - #t)))) - (build-system asdf-build-system/sbcl) - (arguments - '(#:asd-systems '("swank" "swank/exts") - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'set-fasl-directory - (lambda* (#:key outputs #:allow-other-keys) - (substitute* "swank-loader.lisp" - (("\\(probe-file fasl\\)" all) - ;; Do not try to delete Guix store files. - (string-append - all "\n" - " (not (equal (subseq (pathname-directory fasl) 1 3)" - " '(\"gnu\" \"store\"))) ; XXX: GUIX PATCH")))))))) - (home-page "https://github.com/slime/slime") - (synopsis "Common Lisp Swank server") - (description - "This is only useful if you want to start a Swank server in a Lisp -processes that doesn't run under Emacs. Lisp processes created by -@command{M-x slime} automatically start the server.") - (license (list license:gpl2+ license:public-domain)))) + (native-inputs (list sbcl-fiveam)) + (synopsis "Continued fractions library") + (description "CF is a Common Lisp library for doing computations using +continued fractions.") + (home-page "https://codeberg.org/glv/cl-cf") + (license license:gpl3+)))) -(define-public cl-slime-swank - (sbcl-package->cl-source-package sbcl-slime-swank)) +(define-public cl-cf + (sbcl-package->cl-source-package sbcl-cf)) -(define-public ecl-slime-swank - (sbcl-package->ecl-package sbcl-slime-swank)) +(define-public ecl-cf + (sbcl-package->ecl-package sbcl-cf)) -(define-public sbcl-mgl-pax - (let ((commit "6782eb041c152721972420dfafa192692d16b7ce") +(define-public sbcl-cffi + (let ((commit "33970351e71bb5f12ba56fc40270089e948ae112") (revision "1")) (package - (name "sbcl-mgl-pax") - (version (git-version "0.3.0" revision commit)) + (name "sbcl-cffi") + (version (git-version "0.24.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/melisgl/mgl-pax") + (url "https://github.com/cffi/cffi") (commit commit))) + (file-name (git-file-name "cl-cffi" version)) (sha256 - (base32 "0fjbzc2fn17m80lfsc8121sa0bk7fg42fqlwhm01sk1fj4s48pma")) - (file-name (git-file-name "cl-mgl-pax" version)))) + (base32 "1h7cw15f08gm6m4yz8hk7qkfwp7mwwnykjc5py6dhjakv0wh1g37")))) (build-system asdf-build-system/sbcl) - ;; (native-inputs - ;; (list sbcl-try)) (inputs - (list sbcl-3bmd + (list libffi sbcl-alexandria - sbcl-colorize - sbcl-md5 - sbcl-named-readtables - sbcl-pythonic-string-reader - sbcl-slime-swank - sbcl-trivial-utf-8)) + sbcl-babel + sbcl-trivial-features)) + (native-inputs + (list pkg-config + sbcl-bordeaux-threads + sbcl-rt)) (arguments - `(#:asd-systems '("mgl-pax" - "mgl-pax/navigate" - "mgl-pax/document" - "mgl-pax/transcribe") - ;; Tests disabled because of a circular dependency - ;; try -> mgl-pax -> try - #:tests? #f)) - (synopsis "Exploratory programming environment and documentation generator") - (description - "PAX provides an extremely poor man's Explorable Programming -environment. Narrative primarily lives in so called sections that mix markdown -docstrings with references to functions, variables, etc, all of which should -probably have their own docstrings. - -The primary focus is on making code easily explorable by using SLIME's -@command{M-.} (@command{slime-edit-definition}). See how to enable some -fanciness in Emacs Integration. Generating documentation from sections and all -the referenced items in Markdown or HTML format is also implemented. - -With the simplistic tools provided, one may accomplish similar effects as with -Literate Programming, but documentation is generated from code, not vice versa -and there is no support for chunking yet. Code is first, code must look -pretty, documentation is code.") - (home-page "https://melisgl.github.io/mgl-pax/") + (list #:phases + #~(modify-phases %standard-phases + (add-after 'unpack 'fix-paths + (lambda* (#:key inputs #:allow-other-keys) + (substitute* "libffi/libffi.lisp" + (("libffi.so.8" all) + (search-input-file inputs (string-append "/lib/" all)))) + (substitute* "toolchain/c-toolchain.lisp" + (("\"cc\"") + (format #f "~S" (which "gcc")))))) + (add-after 'build 'install-headers + (lambda _ + (install-file "grovel/common.h" + (string-append #$output + "/include/grovel"))))) + #:asd-systems ''("cffi" + "cffi-libffi" + "cffi-uffi-compat"))) + (home-page "https://common-lisp.net/project/cffi/") + (synopsis "Common Foreign Function Interface for Common Lisp") + (description "The Common Foreign Function Interface (CFFI) +purports to be a portable foreign function interface for Common Lisp. +The CFFI library is composed of a Lisp-implementation-specific backend +in the CFFI-SYS package, and a portable frontend in the CFFI +package.") (license license:expat)))) -(define-public cl-mgl-pax - (sbcl-package->cl-source-package sbcl-mgl-pax)) +(define-public cl-cffi + (sbcl-package->cl-source-package sbcl-cffi)) -(define-public ecl-mgl-pax - (sbcl-package->ecl-package sbcl-mgl-pax)) +(define-public ecl-cffi + (sbcl-package->ecl-package sbcl-cffi)) -(define-public sbcl-40ants-doc - (let ((commit "7725ff67a380e9ebfc6155e14d91e650f256711b") + +(define-public sbcl-cffi-c-ref + (let ((commit "8123cbb6034c5f7921a0766107cfb8c4e8efd5ce") (revision "0")) (package - (name "sbcl-40ants-doc") - (version (git-version "0.1.0" revision commit)) + (name "sbcl-cffi-c-ref") + (version (git-version "1.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/40ants/doc") + (url "https://github.com/borodust/cffi-c-ref") (commit commit))) (sha256 - (base32 "1v6gnhrk02vsixmprzk4wvvj7vh11vp5waxyih0qz2ih8d38r5pg")) - (file-name (git-file-name "cl-40ants-doc" version)))) + (base32 "1a3pp6xcisabqir3rp1gvvjfdxcvpm8yr35p38nri9azsinmmc7z")) + (file-name (git-file-name "cffi-c-ref" version)))) (build-system asdf-build-system/sbcl) - (arguments - ;; TODO: Add remaining dependencies of 40ants-doc-full and - ;; 40ants-doc-test missing from Guix. - '(#:asd-systems '("40ants-doc" - ;;"40ants-doc-full" - ) - #:tests? #f)) - ;;(native-inputs - ;; (list sbcl-rove)) (inputs - (list sbcl-named-readtables - sbcl-pythonic-string-reader - ;; For 40ants-doc-full: - ;;sbcl-3bmd - ;;sbcl-alexandria - ;;sbcl-babel - ;;sbcl-cl-cookie - ;;sbcl-cl-fad - ;;sbcl-cl-ppcre - ;;sbcl-common-doc ; Missing from Guix - ;;sbcl-common-html ; Missing from Guix - ;;sbcl-commondoc-markdown ; Missing from Guix - ;;sbcl-dexador - ;;sbcl-docs-builder ; Missing from Guix - ;;sbcl-fare-utils - ;;sbcl-jonathan - ;;sbcl-lass - ;;sbcl-local-time - ;;sbcl-log4cl - ;;sbcl-slime-swank - ;;sbcl-slynk - ;;sbcl-spinneret - ;;sbcl-stem ; Missing from Guix; also, license is unconfirmed - ;;sbcl-str - ;;sbcl-tmpdir ; Missing from Guix - ;;sbcl-trivial-extract ; Missing from Guix - ;;sbcl-xml-emitter - )) - (home-page "https://40ants.com/doc/") - (synopsis "Exploratory programming environment and documentation generator") + (list sbcl-alexandria sbcl-cffi)) + (synopsis "Streamlined access to foreign memory") (description - "@code{40ants-doc} provides a rudimentary explorable programming -environment. The narrative primarily lives in so-called sections that mix -Markdown docstrings with references to functions, variables, etc., all of -which should probably have their own docstrings. - -The primary focus is on making code easily explorable by using SLIME's -@kbd{M-.} (@code{slime-edit-definition}). Generating documentation in -Markdown or HTML format from sections and all the referenced items is also -implemented. - -With the simplistic tools provided, one may obtain results similar to literate -programming, but documentation is generated from code, not the other way -around, and there is no support for chunking. Code comes first, code must -look pretty, documentation is code. - -@code{40ants-doc} is a fork of MGL-PAX with fewer dependencies (only -@code{named-readtables} and @code{pythonic-string-reader}) for the core -system, and additional features in the full system.") + "This Common Lisp library provides macros to access foreign memory.") + (home-page "https://github.com/borodust/cffi-c-ref") (license license:expat)))) -(define-public cl-40ants-doc - (sbcl-package->cl-source-package sbcl-40ants-doc)) +(define-public cl-cffi-c-ref + (sbcl-package->cl-source-package sbcl-cffi-c-ref)) -(define-public ecl-40ants-doc - (sbcl-package->ecl-package sbcl-40ants-doc)) +(define-public ecl-cffi-c-ref + (sbcl-package->ecl-package sbcl-cffi-c-ref)) -(define-public sbcl-mssql - (let ((commit "045602a19a32254108f2b75871049293f49731eb") +(define-public sbcl-chanl + (let ((commit "56e90a126c78b39bb621a01585e8d3b985238e8c") (revision "1")) (package - (name "sbcl-mssql") - (version (git-version "0.0.3" revision commit)) + (name "sbcl-chanl") + (version (git-version "0.4.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/archimag/cl-mssql") + (url "https://github.com/zkat/chanl") (commit commit))) - (file-name (git-file-name "cl-mssql" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "09i50adppgc1ybm3ka9vbindhwa2x29f9n3n0jkrryymdhb8zknm")))) + (base32 + "0b1cf6c12qx5cy1fw2z42jgh566rp3l8nv5qf0qqc569s7bgmrh4")))) (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-fiveam)) (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)))) + (list sbcl-bordeaux-threads)) + (synopsis "Portable channel-based concurrency for Common Lisp") + (description "Common Lisp library for channel-based concurrency. In +a nutshell, you create various threads sequentially executing tasks you need +done, and use channel objects to communicate and synchronize the state of these +threads.") + (home-page "https://github.com/zkat/chanl") + (license (list license:expat license:bsd-3))))) -(define-public ecl-mssql - (sbcl-package->ecl-package sbcl-mssql)) +(define-public cl-chanl + (sbcl-package->cl-source-package sbcl-chanl)) -(define-public cl-mssql - (sbcl-package->cl-source-package sbcl-mssql)) +(define-public ecl-chanl + (sbcl-package->ecl-package sbcl-chanl)) -(define-public sbcl-anaphora +(define-public sbcl-charje.documentation (package - (name "sbcl-anaphora") - (version "0.9.8") + (name "sbcl-charje.documentation") + (version "0.0.0") (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/tokenrove/anaphora") - (commit version))) + (url "https://git.sr.ht/~charje/documentation") + (commit (string-append "v" version)))) (sha256 - (base32 "1ds5ab0rzkrhfl29xpvmvyxmkdyj9mi19p330pz603lx95njjc0b")) - (file-name (git-file-name "cl-anaphora" version)))) + (base32 + "149r9qdz5dyxsamhf5miaa9njr7kn7nc0ic448k133rs3nnwagqc")) + (file-name (git-file-name "cl-charje.documentation" version)))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-rt)) - (synopsis "The anaphoric macro collection from Hell") - (description - "Anaphora is the anaphoric macro collection from Hell: it includes many -new fiends in addition to old friends like @command{aif} and -@command{awhen}.") - (home-page "https://github.com/tokenrove/anaphora") - (license license:public-domain))) - -(define-public cl-anaphora - (sbcl-package->cl-source-package sbcl-anaphora)) - -(define-public ecl-anaphora - (sbcl-package->ecl-package sbcl-anaphora)) - -(define-public sbcl-let-plus - (let ((commit "455e657e077235829b197f7ccafd596fcda69e30") - (revision "2")) - (package - (name "sbcl-let-plus") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/sharplispers/let-plus") - (commit commit))) - (sha256 - (base32 "00c0nq6l4zb692rzsc9aliqzj3avrssfyz4bhxzl7f1jsz3m29jb")) - (file-name (git-file-name "cl-let-plus" version)))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-alexandria sbcl-anaphora)) - (native-inputs - (list sbcl-lift)) - (synopsis "Destructuring extension of let*") - (description - "This library implements the let+ macro, which is a dectructuring -extension of let*. It features: - -@itemize -@item Clean, consistent syntax and small implementation (less than 300 LOC, -not counting tests) -@item Placeholder macros allow editor hints and syntax highlighting -@item @command{&ign} for ignored values (in forms where that makes sense) -@item Very easy to extend -@end itemize\n") - (home-page "https://github.com/sharplispers/let-plus") - (license license:boost1.0)))) - -(define-public cl-let-plus - (sbcl-package->cl-source-package sbcl-let-plus)) - -(define-public ecl-let-plus - (sbcl-package->ecl-package sbcl-let-plus)) + (inputs + (list sbcl-alexandria)) + (home-page "https://git.sr.ht/~charje/documentation") + (synopsis "Docstring parsing library for Common Lisp") + (description "Charje.documentation can used to parse Common Lisp +docstrings the charje way, or it can be used to create custom docstring +parsers. Docstring parsers are composed using mixin classes and +initialization methods.") + (license license:agpl3+))) -(define-public sbcl-cl-cairo2 - (let ((commit "41ae45aac86553c46f4bb460f80e1fb620930f5b") - (revision "1")) - (package - (name "sbcl-cl-cairo2") - (version (git-version "0.6" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/rpav/cl-cairo2") - (commit commit))) - (file-name (git-file-name "cl-cairo2" version)) - (sha256 - (base32 "0cpfgyxw6pz7y033dlya8c4vjmkpw127zdq3a9xclp9q8jbdlb7q")))) - (build-system asdf-build-system/sbcl) - (arguments - `(#:asd-systems '(;; "cl-cairo2-gtk2" ; cl-gtk2 is not packed and quite old. - ;; "cl-cairo2-quartz" ; Failing when enabled. - ;; "cl-cairo2-xlib" ; cl-xcb-xlib is not packed yet and quite old. - ;; "cl-cairo2-xcb" - "cl-cairo2") - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "src/load-libraries.lisp" - (("libcairo.so.2") - (search-input-file inputs "/lib/libcairo.so.2")))))))) - (inputs - (list cairo - sbcl-cffi - sbcl-cl-colors - sbcl-cl-freetype2 - sbcl-cl-utilities - sbcl-metabang-bind - sbcl-trivial-features - sbcl-trivial-garbage)) - (home-page "https://github.com/rpav/cl-cairo2") - (synopsis "Cairo bindings for Common Lisp") - (description - "This package provides CFFI bindings for Common Lisp to the Cairo -C library.") - (license license:boost1.0)))) +(define-public cl-charje.documentation + (sbcl-package->cl-source-package sbcl-charje.documentation)) -(define-public ecl-cl-cairo2 - (sbcl-package->ecl-package sbcl-cl-cairo2)) +(define-public ecl-charje.documentation + (sbcl-package->ecl-package sbcl-charje.documentation)) -(define-public cl-cairo2 - (sbcl-package->cl-source-package sbcl-cl-cairo2)) +(define-public sbcl-charje.loop + (package + (name "sbcl-charje.loop") + (version "0.0.0") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://git.sr.ht/~charje/loop") + (commit (string-append "v" version)))) + (file-name (git-file-name "cl-charje.loop" version)) + (sha256 + (base32 + "1x1hw5xmrx9xmfzga8y0yi6s27r7zc80rwl2z7l4d2h24ykscvd4")))) + (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-alexandria + sbcl-binding-arrows + sbcl-parse-declarations)) + (home-page "https://git.sr.ht/~charje/loop") + (synopsis "Loop abstraction for Common Lisp that is consistent for +different kinds of data") + (description "Loop is a joy to use and has a consistent interface unlike +other looping abstractions and ANSI list operations. You can define your own +iterators and aggregators that integrate tightly into other operations. All +operations are non-consing when possible.") + (license license:agpl3+))) -(define-public sbcl-cl-colors - (let ((commit "827410584553f5c717eec6182343b7605f707f75")) - (package - (name "sbcl-cl-colors") - (version (git-version "0.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/tpapp/cl-colors") - (commit commit))) - (sha256 - (base32 - "0l446lday4hybsm9bq3jli97fvv8jb1d33abg79vbylpwjmf3y9a")) - (file-name (git-file-name "cl-colors" version)))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-alexandria sbcl-let-plus)) - (synopsis "Simple color library for Common Lisp") - (description - "This is a very simple color library for Common Lisp, providing +(define-public cl-charje.loop + (sbcl-package->cl-source-package sbcl-charje.loop)) -@itemize -@item Types for representing colors in HSV and RGB spaces. -@item Simple conversion functions between the above types (and also -hexadecimal representation for RGB). -@item Some predefined colors (currently X11 color names – of course the -library does not depend on X11).Because color in your terminal is nice. -@end itemize +(define-public ecl-charje.loop + (sbcl-package->ecl-package sbcl-charje.loop)) -This library is no longer supported by its author.") - (home-page "https://github.com/tpapp/cl-colors") - (license license:boost1.0)))) +(define-public sbcl-chemboy + (package + (name "sbcl-chemboy") + (version "0.3") + (source + (origin + (method url-fetch) + (uri (string-append + "https://common-lisp.net/project/chemboy/chemboy-" + version ".tar.gz")) + (sha256 + (base32 "0lr134l16mjcgdj3fm2yff4chlfbihn1sji7q80y7lnr176zgs7d")))) + (build-system asdf-build-system/sbcl) + (inputs + `(("chemical-compounds" ,sbcl-chemical-compounds) + ("periodic-table" ,sbcl-periodic-table))) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'fix-files + (lambda _ + ;; Fix incorrect version number. + (substitute* "chemboy.asd" + ((":version \"0.2\"") + (string-append ":version \"" ,version "\""))) + ;; Remove incorrect declaration of string type. + (substitute* "query-parsing.lisp" + (("\\(declare \\(simple-base-string string\\)") + "(declare")) + ;; Fix incorrect function calls. + (substitute* "conversions.lisp" + (("\\(pprint-compound element s\\)") + "(pprint-compound element :stream s)") + (("\\(pprint-compound parsed-compound s\\)") + "(pprint-compound parsed-compound :stream s)"))))))) + (home-page "https://common-lisp.net/project/chemboy/") + (synopsis "Common Lisp program for doing basic chemistry calculations") + (description + "Chemboy is a Common Lisp program for doing basic chemistry calculations. +This package provides the text-based interface for Chemboy.") + (license license:llgpl))) -(define-public cl-colors - (sbcl-package->cl-source-package sbcl-cl-colors)) +(define-public cl-chemboy + (sbcl-package->cl-source-package sbcl-chemboy)) -(define-public ecl-cl-colors - (sbcl-package->ecl-package sbcl-cl-colors)) +(define-public ecl-chemboy + (sbcl-package->ecl-package sbcl-chemboy)) -(define-public sbcl-format-colors - (let ((commit "fecb1d8c6e7a07ff9f10a7a4eb4c3bd629d4969f") - (revision "0")) - (package - (name "sbcl-format-colors") - (version (git-version "0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/vindarel/format-colors") - (commit commit))) - (sha256 - (base32 "084ydjhic2dq0gb7wfm6plnjq3l7485hb3yhxl03mm64a6sr3fxv")) - (file-name (git-file-name "cl-format-colors" version)))) - (build-system asdf-build-system/sbcl) - (inputs (list sbcl-cl-ansi-text)) - (synopsis "Custom format functions for colorful output") - (description "This package provides simple format directives to - print in colors.") - (home-page "https://github.com/vindarel/format-colors") - (license license:llgpl)))) +(define-public sbcl-chemical-compounds + (package + (name "sbcl-chemical-compounds") + (version "1.0.2") + (source + (origin + (method url-fetch) + (uri (string-append + "https://common-lisp.net/project/chemboy/chemical-compounds-" + version ".tar.gz")) + (sha256 + (base32 "12fd8a6ay5qlsq4givzgh9d55mbg4ci2vvmymig6pjl2ms64v0pf")))) + (build-system asdf-build-system/sbcl) + (inputs + `(("periodic-table" ,sbcl-periodic-table))) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'fix-files + (lambda _ + ;; Fix incorrect version number. + (substitute* "chemical-compounds.asd" + ((":version \"1.0.1\"") + (string-append ":version \"" ,version "\""))) + ;; Remove incorrect declaration of string type. + (substitute* "parsing.lisp" + (("\\(declare \\(simple-base-string string\\)") + "(declare"))))))) + (home-page "https://common-lisp.net/project/chemboy/") + (synopsis "Chemical formula parser and pretty-printer for Common Lisp") + (description + "It can sometimes be useful to be able to parse chemical compounds in a +user-friendly syntax into easy-to-manipulate s-expressions. You also want to +be able to go in reverse. You could probably write your own parser — or you +could just install the chemical-compounds package.") + (license license:llgpl))) -(define-public cl-format-colors - (sbcl-package->cl-source-package sbcl-format-colors)) +(define-public cl-chemical-compounds + (sbcl-package->cl-source-package sbcl-chemical-compounds)) -(define-public ecl-format-colors - (sbcl-package->ecl-package sbcl-format-colors)) +(define-public ecl-chemical-compounds + (sbcl-package->ecl-package sbcl-chemical-compounds)) -(define-public sbcl-cl-ansi-text - (let ((commit "8b129d83c7511b54cdd9d4123825a2d06349b25c")) +(define-public sbcl-chipz + (let ((version "0.8") + (commit "82a17d39c78d91f6ea63a03aca8f9aa6069a5e11") + (revision "2")) (package - (name "sbcl-cl-ansi-text") - (version (git-version "2.0.1" "1" commit)) + (name "sbcl-chipz") + (version (git-version version revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/pnathan/cl-ansi-text") + (url "https://github.com/sharplispers/chipz") (commit commit))) + (file-name (git-file-name "cl-chipz" version)) (sha256 - (base32 - "0nk7ajqfa937w1iy3zy86jjbw8yffm05cqs4wxkgl97v6kmmya14")) - (file-name (git-file-name "cl-ansi-text" version)))) + (base32 "1n4f22i9j8iapjd6yx1z348rggcybvg9h794kx9libjgz4bs371h")))) (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-alexandria sbcl-cl-colors2)) (native-inputs - (list sbcl-fiveam)) - (synopsis "ANSI terminal color implementation for Common Lisp") + (list sbcl-flexi-streams)) + (home-page "http://method-combination.net/lisp/chipz/") + (synopsis + "Common Lisp library for decompressing deflate, zlib, gzip, and bzip2 +data") (description - "@command{cl-ansi-text} provides utilities which enable printing to an -ANSI terminal with colored text. It provides the macro @command{with-color} -which causes everything printed in the body to be displayed with the provided -color. It further provides functions which will print the argument with the -named color.") - (home-page "https://github.com/pnathan/cl-ansi-text") - (license license:llgpl)))) + "DEFLATE data, defined in RFC1951, forms the core of popular +compression formats such as zlib (RFC 1950) and gzip (RFC 1952). As such, +Chipz also provides for decompressing data in those formats as well. BZIP2 is +the format used by the popular compression tool bzip2.") + ;; The author describes it as "MIT-like" + (license license:expat)))) -(define-public cl-ansi-text - (sbcl-package->cl-source-package sbcl-cl-ansi-text)) +(define-public cl-chipz + (sbcl-package->cl-source-package sbcl-chipz)) -(define-public ecl-cl-ansi-text - (sbcl-package->ecl-package sbcl-cl-ansi-text)) +(define-public ecl-chipz + (sbcl-package->ecl-package sbcl-chipz)) -(define-public sbcl-proc-parse - (let ((commit "ac3636834d561bdc2686c956dbd82494537285fd")) +(define-public sbcl-chirp + (let ((commit "01c79fa41939688216d1f86d0766a687becb0654") + (revision "1")) (package - (name "sbcl-proc-parse") - (version (git-version "0.0.0" "1" commit)) + (name "sbcl-chirp") + (version (git-version "0.2.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/fukamachi/proc-parse") + (url "https://github.com/Shinmera/chirp") (commit commit))) + (file-name (git-file-name "chirp" version)) (sha256 - (base32 - "06rnl0h4cx6xv2wj3jczmmcxqn2703inmmvg1s4npbghmijsybfh")) - (file-name (git-file-name "proc-parse" version)))) + (base32 "10xlz1vwdv3jv48kmpndpnrg6672m0r5vsjgm2pksfl8bc05j2m0")))) (build-system asdf-build-system/sbcl) + (arguments + `(#:asd-systems '("chirp-core" "chirp-dexador" "chirp-drakma" "chirp"))) (inputs `(("alexandria" ,sbcl-alexandria) - ("babel" ,sbcl-babel))) - (native-inputs - (list sbcl-prove)) - (arguments - '(#:asd-systems '("proc-parse-test" - "proc-parse"))) - (synopsis "Procedural vector parser") + ("babel" ,sbcl-babel) + ("cl-base64" ,sbcl-cl-base64) + ("cl-ppcre" ,sbcl-cl-ppcre) + ("dexador" ,sbcl-dexador) + ("drakma" ,sbcl-drakma) + ("flexi-streams" ,sbcl-flexi-streams) + ("ironclad" ,sbcl-ironclad) + ("local-time" ,sbcl-local-time) + ("split-sequence" ,sbcl-split-sequence) + ("uuid" ,sbcl-uuid) + ("yason" ,sbcl-yason))) + (home-page "https://shinmera.github.io/chirp/") + (synopsis "Twitter client library for Common Lisp") (description - "This is a string/octets parser library for Common Lisp with speed and -readability in mind. Unlike other libraries, the code is not a -pattern-matching-like, but a char-by-char procedural parser.") - (home-page "https://github.com/fukamachi/proc-parse") - (license license:bsd-2)))) + "This package provides a Common Lisp Twitter client featuring full API +coverage.") + (license license:zlib)))) -(define-public cl-proc-parse - (sbcl-package->cl-source-package sbcl-proc-parse)) +(define-public cl-chirp + (sbcl-package->cl-source-package sbcl-chirp)) -(define-public ecl-proc-parse - (sbcl-package->ecl-package sbcl-proc-parse)) +(define-public ecl-chirp + (sbcl-package->ecl-package sbcl-chirp)) -(define-public sbcl-parse-float - (let ((commit "3074765101e41222b6b624a66aaf1e6416379f9c") - (revision "2")) +(define-public sbcl-chlorophyll + (let ((commit "f2a50ad36d2fb11823c0e5a8da08a0de89c5c35f") + (revision "1")) (package - (name "sbcl-parse-float") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-chlorophyll") + (version (git-version "0.0.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/soemraws/parse-float") + (url "https://github.com/gorozhin/chlorophyll") (commit commit))) + (file-name (git-file-name "cl-chlorophyll" version)) (sha256 - (base32 "0jd2spawc3v8vzqf8ky4cngl45jm65fhkrdf20mf6dcbn3mzpkmr")) - (file-name (git-file-name "proc-parse" version)))) - (build-system asdf-build-system/sbcl) - (arguments - ;; FIXME: https://github.com/soemraws/parse-float/issues/12 - `(#:asd-systems '("parse-float" "parse-float-tests"))) - (native-inputs - (list 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.") - (license license:public-domain)))) - -(define-public cl-parse-float - (sbcl-package->cl-source-package sbcl-parse-float)) - -(define-public ecl-parse-float - (sbcl-package->ecl-package sbcl-parse-float)) - -(define-public sbcl-cl-string-match - (let ((revision "1") - (changeset "5048480a61243e6f1b02884012c8f25cdbee6d97")) - (package - (name "sbcl-cl-string-match") - (version (git-version "0" revision changeset)) - (source - (origin - (method hg-fetch) - (uri (hg-reference - (url "https://github.com/vityok/cl-string-match") - (changeset changeset))) - (sha256 - (base32 - "01wn5qx562w43ssy92xlfgv79w7p0nv0wbl76mpmba131n9ziq2y")) - (file-name (git-file-name "cl-string-match" version)))) + (base32 "1hgl8sjsmyqx4gs77q4p94b63zgpxk1wi9w9niki8j0213dr1s3y")))) (build-system asdf-build-system/sbcl) - (inputs - `(("alexandria" ,sbcl-alexandria) - ("babel" ,sbcl-babel) - ("iterate" ,sbcl-iterate) - ("jpl-queues" ,sbcl-jpl-queues) - ("jpl-util" ,sbcl-jpl-util) - ("mgl-pax" ,sbcl-mgl-pax) - ("parse-float" ,sbcl-parse-float) - ("proc-parse" ,sbcl-proc-parse) - ("yacc" ,sbcl-cl-yacc))) - ;; TODO: Tests are not evaluated properly. - (native-inputs - ;; For testing: - (list sbcl-lisp-unit)) - (arguments - `(#:tests? #f - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-dependency - (lambda _ - (substitute* "cl-string-match.asd" - ((":mgl-pax") - ":mgl-pax/document"))))))) - (synopsis "Set of utilities to manipulate strings in Common Lisp") + (native-inputs (list sbcl-fiveam)) + (inputs (list sbcl-alexandria)) + (home-page "https://github.com/gorozhin/chlorophyll") + (synopsis "ANSI escape code library for Common Lisp") (description - "@command{cl-strings} is a small, portable, dependency-free set of -utilities that make it even easier to manipulate text in Common Lisp. It has -100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.") - (home-page "https://github.com/vityok/cl-string-match") - (license license:bsd-3)))) + "This package provides a Common Lisp system CHLOROPHYLL which +implements an ANSI escape code functionality.") + (license license:expat)))) -(define-public cl-string-match - (sbcl-package->cl-source-package sbcl-cl-string-match)) +(define-public cl-chlorophyll + (sbcl-package->cl-source-package sbcl-chlorophyll)) -(define-public ecl-cl-string-match - (sbcl-package->ecl-package sbcl-cl-string-match)) +(define-public ecl-chlorophyll + (sbcl-package->ecl-package sbcl-chlorophyll)) -(define-public sbcl-cl-punch +(define-public sbcl-chronicity (package - (name "sbcl-cl-punch") - (version "0.2") + (name "sbcl-chronicity") + (version "0.4.1") (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/windymelt/cl-punch") + (url "https://github.com/chaitanyagupta/chronicity") (commit (string-append "v" version)))) - (file-name (git-file-name "cl-punch" version)) + (file-name (git-file-name "chronicity" version)) (sha256 - (base32 "1vmbaz9y9lq4wvi8mfbyif8vc9yfk2i0qd3ysbzl152wx32dbzs3")))) + (base32 "0rzrl9is2v1aqbm0sym0qx3blnpd0bl13dkkmll6mb3983k2mkax")))) (build-system asdf-build-system/sbcl) (native-inputs - (list sbcl-prove)) + (list sbcl-lisp-unit)) (inputs - (list sbcl-cl-syntax)) - (home-page "https://github.com/windymelt/cl-punch") - (synopsis "Anonymous lambda literal in Common Lisp, respecting Scala") + (list sbcl-cl-interpol sbcl-cl-ppcre sbcl-local-time)) + (home-page "https://github.com/chaitanyagupta/chronicity") + (synopsis "Natural language date and time parser for Common Lisp") (description - "CL-PUNCH is a Scala-like anonymous lambda literal.") - (license license:expat ))) - -(define-public cl-punch - (sbcl-package->cl-source-package sbcl-cl-punch)) - -(define-public ecl-cl-punch - (sbcl-package->ecl-package sbcl-cl-punch)) - -(define-public sbcl-puri - (let ((commit "4bbab89d9ccbb26346899d1f496c97604fec567b") - (revision "2")) - (package - (name "sbcl-puri") - (version (git-version "1.5.7" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "http://git.kpe.io/puri.git") - (commit commit))) - (file-name (git-file-name "puri" version)) - (sha256 - (base32 "0gq2rsr0aihs0z20v4zqvmdl4szq53b52rh97pvnmwrlbn4mapmd")) - (modules '((guix build utils))) - (snippet - ;; The useless bundled debian folder drags `make' into the closure. - `(begin - (delete-file-recursively "debian") - #t)))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-ptester)) - (home-page "http://puri.kpe.io/") - (synopsis "Portable URI Library") - (description - "This is a portable Universal Resource Identifier library for Common -Lisp programs. It parses URI according to the RFC 2396 specification.") - (license license:llgpl)))) - -(define-public cl-puri - (sbcl-package->cl-source-package sbcl-puri)) + "CHRONICITY is Common Lisp natural language date and time parser inspired +by Ruby's @code{Chronic}.") + (license license:bsd-3))) -(define-public ecl-puri - (sbcl-package->ecl-package sbcl-puri)) +(define-public ecl-chronicity + (sbcl-package->ecl-package sbcl-chronicity)) -(define-public sbcl-qmynd - (let ((commit "7e56daf73f0ed5f49a931c01af75fb874bcf3445") - (revision "1")) - (package - (name "sbcl-qmynd") - (version (git-version "1.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/qitab/qmynd") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "06gw5wxcpdclb6a5i5k9lbmdlyqsp182czrm9bm1cpklzbj0ihrl")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-asdf-finalizers - sbcl-babel - sbcl-chipz - sbcl-cl+ssl - sbcl-flexi-streams - sbcl-ironclad - sbcl-salza2 - sbcl-trivial-gray-streams - sbcl-usocket)) - (home-page "https://github.com/qitab/qmynd") - (synopsis "QITAB MySQL Native Driver for Common Lisp") - (description "QMyND, the QITAB MySQL Native Driver, is a MySQL client -library that directly talks to a MySQL server in its native network protocol. +(define-public cl-chronicity + (sbcl-package->cl-source-package sbcl-chronicity)) -It's a part of QITAB umbrella project.") - (license license:expat)))) +(define-public sbcl-chunga + (package + (name "sbcl-chunga") + (version "1.1.7") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/edicl/chunga") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0jzn3nyb3f22gm983rfk99smqs3mhb9ivjmasvhq9qla5cl9pyhd")))) + (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-trivial-gray-streams)) + (home-page "https://edicl.github.io/chunga/") + (synopsis "Portable chunked streams for Common Lisp") + (description + "Chunga implements streams capable of chunked encoding on demand as +defined in RFC 2616.") + (license license:bsd-2))) -(define-public ecl-qmynd - (sbcl-package->ecl-package sbcl-qmynd)) +(define-public cl-chunga + (sbcl-package->cl-source-package sbcl-chunga)) -(define-public cl-qmynd - (sbcl-package->cl-source-package sbcl-qmynd)) +(define-public ecl-chunga + (sbcl-package->ecl-package sbcl-chunga)) -(define-public sbcl-queues - (let ((commit "47d4da65e9ea20953b74aeeab7e89a831b66bc94")) +(define-public sbcl-ciel + (let ((commit "6cc1cef5e37e9f495c8163271a5de48de99f348a") + (revision "0")) (package - (name "sbcl-queues") - (version (git-version "0.0.0" "1" commit)) + (name "sbcl-ciel") + (version (git-version "0.1.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/oconnore/queues") + (url "https://github.com/ciel-lang/CIEL") (commit commit))) - (file-name (git-file-name "queues" version)) + (file-name (git-file-name "ciel" version)) (sha256 - (base32 - "0wdhfnzi4v6d97pggzj2aw55si94w4327br94jrmyvwf351wqjvv")))) + (base32 "1bwafbbsppxqvijf43dii55mpzrklh6faj2m5dhajg2f2m8qckgi")))) (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-fiveam)) (inputs - `(("bordeaux-threads" ,sbcl-bordeaux-threads))) - (arguments - '(#:asd-systems '("queues" - "queues.simple-queue" - "queues.simple-cqueue" - "queues.priority-queue" - "queues.priority-cqueue"))) - (home-page "https://github.com/oconnore/queues") - (synopsis "Common Lisp queue library") + (list sbcl-access + sbcl-alexandria + sbcl-arrow-macros + sbcl-bordeaux-threads + sbcl-cl-ansi-text + sbcl-cl-ansi-text + sbcl-cl-cron + sbcl-cl-csv + sbcl-cl-json-pointer + sbcl-cl-ppcre + sbcl-cl-punch + sbcl-cl-reexport + sbcl-cl-str + sbcl-clesh + sbcl-clingon + sbcl-closer-mop + sbcl-cmd + sbcl-dbi + sbcl-defstar + sbcl-deploy + sbcl-dexador + sbcl-dissect + sbcl-easy-routes + sbcl-file-notify + sbcl-fn + sbcl-for + sbcl-fset + sbcl-generic-cl + sbcl-hunchentoot + sbcl-local-time + sbcl-log4cl + sbcl-lparallel + sbcl-lquery + sbcl-metabang-bind + sbcl-modf + sbcl-named-readtables + sbcl-nodgui + sbcl-parse-float + sbcl-parse-number + sbcl-printv + sbcl-pythonic-string-reader + sbcl-quicksearch + sbcl-quri + sbcl-repl-utilities + sbcl-serapeum + sbcl-shasht + sbcl-shlex + sbcl-spinneret + sbcl-sxql + sbcl-trivia + sbcl-trivial-arguments + sbcl-trivial-do + sbcl-trivial-monitored-thread + sbcl-trivial-package-local-nicknames + sbcl-trivial-types + sbcl-vgplot + sbcl-which)) + (home-page "http://ciel-lang.org/") + (synopsis "CIEL Is an Extended Lisp") (description - "This is a simple queue library for Common Lisp with features such as -non-consing thread safe queues and fibonacci priority queues.") + "CIEL is a ready-to-use collection of libraries providing: a binary, to +run CIEL scripts; a simple full-featured REPL for the terminal; a Lisp library +and a core image .") (license license:expat)))) -(define-public cl-queues - (sbcl-package->cl-source-package sbcl-queues)) +(define-public cl-ciel + (sbcl-package->cl-source-package sbcl-ciel)) -(define-public ecl-queues - (sbcl-package->ecl-package sbcl-queues)) +(define-public ecl-ciel + (sbcl-package->ecl-package sbcl-ciel)) -(define-public sbcl-glsl-packing - (let ((commit "03628159468a8e5b7f2a1d5e78b77053e136794a") +(define-public sbcl-circular-streams + (let ((commit "e770bade1919c5e8533dd2078c93c3d3bbeb38df") (revision "1")) (package - (name "sbcl-glsl-packing") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/3b/glsl-packing/") - (commit commit))) - (file-name (git-file-name "glsl-packing" version)) - (sha256 - (base32 "0k2f1771wd9kdrcasldy1r00k5bdgi9fd07in52zmjggc0i7dd80")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-alexandria)) - (home-page "https://github.com/3b/glsl-packing/") - (synopsis "Common Lisp utilities to calculate OpenGL layouts") - (description - "This is a Common Lisp library to calculate std140 or std430 layouts for -a glsl UBO/SSBO.") - (license license:expat)))) + (name "sbcl-circular-streams") + (version (git-version "0.1.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/fukamachi/circular-streams") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1wpw6d5cciyqcf92f7mvihak52pd5s47kk4qq6f0r2z2as68p5rs")))) + (build-system asdf-build-system/sbcl) + (arguments + ;; The tests depend on cl-test-more which is now prove. Prove + ;; tests aren't working for some reason. + `(#:tests? #f)) + (inputs + (list sbcl-fast-io sbcl-trivial-gray-streams)) + (home-page "https://github.com/fukamachi/circular-streams") + (synopsis "Circularly readable streams for Common Lisp") + (description + "Circular-Streams allows you to read streams circularly by wrapping real +streams. Once you reach end-of-file of a stream, it's file position will be +reset to 0 and you're able to read it again.") + (license license:llgpl)))) -(define-public ecl-glsl-packing - (sbcl-package->ecl-package sbcl-glsl-packing)) +(define-public cl-circular-streams + (sbcl-package->cl-source-package sbcl-circular-streams)) -(define-public cl-glsl-packing - (sbcl-package->cl-source-package sbcl-glsl-packing)) +(define-public ecl-circular-streams + (sbcl-package->ecl-package sbcl-circular-streams)) -(define-public sbcl-glsl-spec - (let ((commit "f04476f7da89355ae6856b33283c60ba95c6555d") +(define-public sbcl-cl-abnf + ;; There are no releases + (let ((commit "ba1fbb104dedbdaddb1ef93d2e4da711bd96cd70") (revision "1")) (package - (name "sbcl-glsl-spec") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/cbaggers/glsl-spec") - (commit commit))) - (file-name (git-file-name "glsl-spec" version)) - (sha256 - (base32 "01ipspr22fgfj3w8wq2y81lzrjc4vpfiwnr3dqhjlpzzra46am8c")))) - (build-system asdf-build-system/sbcl) - (arguments - `(#:asd-systems '("glsl-spec" "glsl-symbols" "glsl-docs"))) - (home-page "https://github.com/cbaggers/glsl-spec") - (synopsis "Common Lisp GLSL specification as a datastructure") - (description - "This package contains the specification of all functions and variables -from GLSL as data.") - (license license:unlicense)))) + (name "sbcl-cl-abnf") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/dimitri/cl-abnf") + (commit commit))) + (file-name (git-file-name "cl-abnf" version)) + (sha256 + (base32 "0f09nsndxa90acm71zd4qdnp40v705a4sqm04mnv9x76h6dlggmz")))) + (build-system asdf-build-system/sbcl) + (inputs + `(("cl-ppcre" ,sbcl-cl-ppcre) + ("esrap" ,sbcl-esrap))) + (arguments + `(#:asd-systems '("abnf"))) + (home-page "https://github.com/dimitri/cl-abnf") + (synopsis "ABNF parser generator for Common Lisp") + (description "This Common Lisp library implements a parser generator for +the ABNF grammar format as described in RFC2234. The generated parser is a +regular expression scanner provided by the cl-ppcre lib, which means that we +can't parse recursive grammar definition. One such definition is the ABNF +definition as given by the RFC. Fortunately, as you have this lib, you most +probably don't need to generate another parser to handle that particular ABNF +grammar.") + (license license:expat)))) -(define-public ecl-glsl-spec - (sbcl-package->ecl-package sbcl-glsl-spec)) +(define-public cl-abnf + (sbcl-package->cl-source-package sbcl-cl-abnf)) -(define-public cl-glsl-spec - (sbcl-package->cl-source-package sbcl-glsl-spec)) +(define-public ecl-cl-abnf + (sbcl-package->ecl-package sbcl-cl-abnf)) -(define-public sbcl-rtg-math - (let ((commit "29fc5b3d0028a4a11a82355ecc8cca62662c69e0") - (revision "1")) +(define-public sbcl-cl-algebraic-data-type + (let ((commit "b2568428193a512d141d6b615772d50ceb5f9bca")) (package - (name "sbcl-rtg-math") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-cl-algebraic-data-type") + (version (git-version "1.2.0" "1" commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/cbaggers/rtg-math") + (url "https://github.com/stylewarning/cl-algebraic-data-type") (commit commit))) - (file-name (git-file-name "rtg-math" version)) + (file-name (git-file-name "cl-algebraic-data-type" version)) (sha256 - (base32 "0bhxxnv7ldkkb18zdxyz2rj2a3iawzq2kcp7cn5i91iby7n0082x")))) + (base32 "1lnqxcv8pd5z8n0g5p2l0dbljx9pqiv18hxl0vhsh7ldhkrjv2jx")))) (build-system asdf-build-system/sbcl) (inputs - (list sbcl-alexandria sbcl-documentation-utils sbcl-glsl-spec)) - (home-page "https://github.com/cbaggers/rtg-math") - (synopsis "Common Lisp library of game-related math functions") + (list sbcl-alexandria + sbcl-global-vars)) + (arguments + '(#:tests? #f)) ; No tests. + (home-page "https://github.com/stylewarning/cl-algebraic-data-type") + (synopsis "Common Lisp library for algebraic data types") (description - "RTG-MATH provides a selection of the math routines most commonly needed -for making realtime graphics in Lisp.") - (license license:bsd-2)))) + "CL-ALGEBRAIC-DATA-TYPE, or ADT, is a library for defining algebraic +data types in a similar spirit to Haskell or Standard ML, as well as for +operating on them.") + (license license:bsd-3)))) -(define-public ecl-rtg-math - (sbcl-package->ecl-package sbcl-rtg-math)) +(define-public cl-algebraic-data-type + (sbcl-package->cl-source-package sbcl-cl-algebraic-data-type)) -(define-public cl-rtg-math - (sbcl-package->cl-source-package sbcl-rtg-math)) +(define-public ecl-algebraic-data-type + (sbcl-package->ecl-package sbcl-cl-algebraic-data-type)) -(define-public sbcl-varjo - (let ((commit "9e77f30220053155d2ef8870ceba157f75e538d4") - (revision "1")) +(define-public sbcl-cl-all + (let ((commit "4ce1ea9d9f33c0dd6212044e7952a0c854757ace") + (revision "0")) (package - (name "sbcl-varjo") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-cl-all") + (version (git-version "1.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/cbaggers/varjo") + (url "https://github.com/Shinmera/cl-all") (commit commit))) - (file-name (git-file-name "varjo" version)) + (file-name (git-file-name "cl-all" version)) (sha256 - (base32 "1p9x1wj576x5d31yvls9r1avkjkyhri7kyxbjfkg9z93a1w18j9z")))) + (base32 "0n4sjarj373zpxn78m32rmhxnsnr8qahdslrd9vrkkwjpzar2bwp")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-fiveam)) - (inputs - (list sbcl-alexandria - sbcl-cl-ppcre - sbcl-documentation-utils - sbcl-fn - sbcl-glsl-spec - sbcl-named-readtables - sbcl-parse-float - sbcl-vas-string-metrics)) - (home-page "https://github.com/cbaggers/varjo") - (synopsis "Lisp to GLSL Language Translator") - (description - "Varjo is a Lisp to GLSL compiler. Vari is the dialect of lisp Varjo -compiles. It aims to be as close to Common Lisp as possible, but naturally it -is statically typed so there are differences.") - (license license:bsd-2)))) - -(define-public ecl-varjo - (sbcl-package->ecl-package sbcl-varjo)) + (outputs '("out" "bin")) + (arguments + (list + #:phases + #~(modify-phases %standard-phases + (add-after 'create-asdf-configuration 'build-program + (lambda* (#:key outputs #:allow-other-keys) + (build-program + (string-append (assoc-ref outputs "bin") "/bin/cl-all") + outputs + #:entry-program '((cl-all:toplevel arguments)) + #:compress? #t)))))) + (home-page "https://github.com/Shinmera/cl-all") + (synopsis "Evaluate Common Lisp expressions in multiple implementations") + (description "@samp{cl-all} is a library and script for evaluating Common +Lisp expressions in multiple implementations.") + (license license:zlib)))) -(define-public cl-varjo - (sbcl-package->cl-source-package sbcl-varjo)) +(define-public cl-all + (sbcl-package->cl-source-package sbcl-cl-all)) -(define-public sbcl-cffi - (let ((commit "33970351e71bb5f12ba56fc40270089e948ae112") - (revision "1")) +(define-public sbcl-cl-ana + (let ((commit "848185eed1ed65bab3a124870c122f761ce0d87e") + (revision "2")) (package - (name "sbcl-cffi") - (version (git-version "0.24.1" revision commit)) + (name "sbcl-cl-ana") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/cffi/cffi") + (url "https://github.com/ghollisjr/cl-ana") (commit commit))) - (file-name (git-file-name "cl-cffi" version)) + (file-name (git-file-name "cl-ana" version)) (sha256 - (base32 "1h7cw15f08gm6m4yz8hk7qkfwp7mwwnykjc5py6dhjakv0wh1g37")))) + (base32 "026agqsxq3pg2k9jmy2wysil2z0yn5rykzzhr8rqxsspdwz51z1y")))) (build-system asdf-build-system/sbcl) + (native-inputs + (list openmpi ;; for hdf-cffi + pkg-config + sbcl-cl-fad)) (inputs - (list libffi + (list gsl + hdf5-parallel-openmpi + libffi + sbcl-antik + sbcl-cffi + sbcl-cl-csv + sbcl-closer-mop + sbcl-external-program + sbcl-gsll + sbcl-iterate sbcl-alexandria - sbcl-babel - sbcl-trivial-features)) - (native-inputs - (list pkg-config - sbcl-bordeaux-threads - sbcl-rt)) + sbcl-split-sequence)) + (propagated-inputs + (list gnuplot)) ;; for gnuplot-interface (arguments (list #:phases #~(modify-phases %standard-phases (add-after 'unpack 'fix-paths (lambda* (#:key inputs #:allow-other-keys) - (substitute* "libffi/libffi.lisp" - (("libffi.so.8" all) - (search-input-file inputs (string-append "/lib/" all)))) - (substitute* "toolchain/c-toolchain.lisp" - (("\"cc\"") - (format #f "~S" (which "gcc")))))) - (add-after 'build 'install-headers + (substitute* "hdf-cffi/src/library.lisp" + (("libhdf5.so") + (search-input-file inputs "/lib/libhdf5.so"))) + (substitute* (list "gsl-cffi/gsl-cffi.lisp" + "spline/spline.lisp") + (("libgsl.so") + (search-input-file inputs "/lib/libgsl.so"))))) + (add-after 'fix-paths 'fix-newer-hdf5-compatibility (lambda _ - (install-file "grovel/common.h" - (string-append #$output - "/include/grovel"))))) - #:asd-systems ''("cffi" - "cffi-libffi" - "cffi-uffi-compat"))) - (home-page "https://common-lisp.net/project/cffi/") - (synopsis "Common Foreign Function Interface for Common Lisp") - (description "The Common Foreign Function Interface (CFFI) -purports to be a portable foreign function interface for Common Lisp. -The CFFI library is composed of a Lisp-implementation-specific backend -in the CFFI-SYS package, and a portable frontend in the CFFI -package.") - (license license:expat)))) - -(define-public cl-cffi - (sbcl-package->cl-source-package sbcl-cffi)) + (substitute* (list "hdf-cffi/src/h5-grovel.lisp" + "hdf-cffi/src/h5a-grovel.lisp" + "hdf-cffi/src/h5d-grovel.lisp" + "hdf-cffi/src/h5f-grovel.lisp" + "hdf-cffi/src/h5g-grovel.lisp" + "hdf-cffi/src/h5i-grovel.lisp" + "hdf-cffi/src/h5l-grovel.lisp" + "hdf-cffi/src/h5o-grovel.lisp" + "hdf-cffi/src/h5p-grovel.lisp" + "hdf-cffi/src/h5pl-grovel.lisp" + "hdf-cffi/src/h5r-grovel.lisp" + "hdf-cffi/src/h5s-grovel.lisp" + "hdf-cffi/src/h5t-grovel.lisp" + "hdf-cffi/src/h5z-grovel.lisp") + (("_H5private_H") + "H5private_H"))))))) + (synopsis "Common Lisp data analysis library") + (description + "CL-ANA is a data analysis library in Common Lisp providing tabular and +binned data analysis along with nonlinear least squares fitting and +visualization.") + (home-page "https://github.com/ghollisjr/cl-ana") + (license license:gpl3)))) -(define-public ecl-cffi - (sbcl-package->ecl-package sbcl-cffi)) +(define-public cl-ana + (sbcl-package->cl-source-package sbcl-cl-ana)) -(define-public sbcl-cffi-c-ref - (let ((commit "8123cbb6034c5f7921a0766107cfb8c4e8efd5ce") - (revision "0")) +(define-public sbcl-cl-annot + (let ((commit "c99e69c15d935eabc671b483349a406e0da9518d") + (revision "1")) (package - (name "sbcl-cffi-c-ref") - (version (git-version "1.0" revision commit)) + (name "sbcl-cl-annot") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/borodust/cffi-c-ref") + (url "https://github.com/m2ym/cl-annot") (commit commit))) + (file-name (git-file-name name version)) (sha256 - (base32 "1a3pp6xcisabqir3rp1gvvjfdxcvpm8yr35p38nri9azsinmmc7z")) - (file-name (git-file-name "cffi-c-ref" version)))) + (base32 "1wq1gs9jjd5m6iwrv06c2d7i5dvqsfjcljgbspfbc93cg5xahk4n")))) (build-system asdf-build-system/sbcl) (inputs - (list sbcl-alexandria sbcl-cffi)) - (synopsis "Streamlined access to foreign memory") + (list sbcl-alexandria)) + (home-page "https://github.com/m2ym/cl-annot") + (synopsis "Python-like Annotation Syntax for Common Lisp") (description - "This Common Lisp library provides macros to access foreign memory.") - (home-page "https://github.com/borodust/cffi-c-ref") - (license license:expat)))) + "@code{cl-annot} is an general annotation library for Common Lisp.") + (license license:llgpl)))) -(define-public cl-cffi-c-ref - (sbcl-package->cl-source-package sbcl-cffi-c-ref)) +(define-public cl-annot + (sbcl-package->cl-source-package sbcl-cl-annot)) -(define-public ecl-cffi-c-ref - (sbcl-package->ecl-package sbcl-cffi-c-ref)) +(define-public ecl-cl-annot + (sbcl-package->ecl-package sbcl-cl-annot)) -(define-public sbcl-ffa - (let ((commit "b7012f51c4c37d1e759ff9cf78cea178504d8e07") - (revision "1")) +(define-public sbcl-cl-ansi-text + (let ((commit "8b129d83c7511b54cdd9d4123825a2d06349b25c")) (package - (name "sbcl-ffa") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-cl-ansi-text") + (version (git-version "2.0.1" "1" commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/tpapp/ffa") + (url "https://github.com/pnathan/cl-ansi-text") (commit commit))) - (file-name (git-file-name "cl-ffa" version)) (sha256 - (base32 "0l7kqcjp3sn1129hpwq6zhjqc0ydx9gc53z7k13i38x3z1asap7a")))) + (base32 + "0nk7ajqfa937w1iy3zy86jjbw8yffm05cqs4wxkgl97v6kmmya14")) + (file-name (git-file-name "cl-ansi-text" version)))) (build-system asdf-build-system/sbcl) (inputs - (list sbcl-cffi sbcl-cl-utilities sbcl-iterate sbcl-metabang-bind)) - (synopsis "Foreign friendly arrays for Common Lisp") + (list sbcl-alexandria sbcl-cl-colors2)) + (native-inputs + (list sbcl-fiveam)) + (synopsis "ANSI terminal color implementation for Common Lisp") (description - "This package provides a macro that allows foreign functions to access -the contents of the array at a given pointer, using the best available method -given the Common Lisp implementation.") - (home-page "https://cliki.net/ffa") + "@command{cl-ansi-text} provides utilities which enable printing to an +ANSI terminal with colored text. It provides the macro @command{with-color} +which causes everything printed in the body to be displayed with the provided +color. It further provides functions which will print the argument with the +named color.") + (home-page "https://github.com/pnathan/cl-ansi-text") (license license:llgpl)))) -(define-public cl-ffa - (sbcl-package->cl-source-package sbcl-ffa)) - -(define-public ecl-ffa - (sbcl-package->ecl-package sbcl-ffa)) - -(define-public sbcl-cl-sqlite - (package - (name "sbcl-cl-sqlite") - (version "0.2.1") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/dmitryvk/cl-sqlite") - (commit version))) - (file-name (git-file-name "cl-sqlite" version)) - (sha256 - (base32 - "08iv7b4m0hh7qx2cvq4f510nrgdld0vicnvmqsh9w0fgrcgmyg4k")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("iterate" ,sbcl-iterate) - ("cffi" ,sbcl-cffi) - ("sqlite" ,sqlite))) - (native-inputs - `(("fiveam" ,sbcl-fiveam) - ("bordeaux-threads" ,sbcl-bordeaux-threads))) - (arguments - `(#:asd-systems '("sqlite") - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "sqlite-ffi.lisp" - (("libsqlite3" all) (string-append - (assoc-ref inputs "sqlite")"/lib/" all)))))))) - (home-page "https://common-lisp.net/project/cl-sqlite/") - (synopsis "Common Lisp binding for SQLite") - (description - "The @command{cl-sqlite} package is an interface to the SQLite embedded -relational database engine.") - (license license:public-domain))) - -(define-public cl-sqlite - (sbcl-package->cl-source-package sbcl-cl-sqlite)) +(define-public cl-ansi-text + (sbcl-package->cl-source-package sbcl-cl-ansi-text)) -(define-public ecl-cl-sqlite - (sbcl-package->ecl-package sbcl-cl-sqlite)) +(define-public ecl-cl-ansi-text + (sbcl-package->ecl-package sbcl-cl-ansi-text)) -(define-public sbcl-cl-raylib - (let ((commit "985ceebef4cb56c651cddc23bd71812f2be38c2d") - (revision "0")) +(define-public sbcl-cl-ascii-table + (let ((commit "d9f5e774a56fad1b416e4dadb8f8a5b0e84094e2") + (revision "1")) (package - (name "sbcl-cl-raylib") - (version (git-version "0.0.1" revision commit)) + (name "sbcl-cl-ascii-table") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/longlene/cl-raylib") + (url "https://github.com/telephil/cl-ascii-table") (commit commit))) - (file-name (git-file-name "cl-raylib" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "1kighj35g6dn426mhr2ppz3gm49v1q4n42ydn619pclrqwyrnc2z")))) + (base32 "125fdif9sgl7k0ngjhxv0wjas2q27d075025hvj2rx1b1x948z4s")))) (build-system asdf-build-system/sbcl) - (arguments - `(#:tests? #f ; no tests https://github.com/longlene/cl-raylib/issues/40 - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "src/library.lisp" - (("libraylib\\.so") - (search-input-file inputs "/lib/libraylib.so")))))))) - (inputs - (list raylib - sbcl-3d-matrices - sbcl-3d-vectors - sbcl-alexandria - sbcl-cffi)) - (home-page "https://github.com/longlene/cl-raylib") - (synopsis "Common Lisp bindings to raylib") - (description "This package provides Common Lisp CFFI bindings to the -Raylib game development library.") + (synopsis "Library to make ascii-art tables") + (description + "This is a Common Lisp library to present tabular data in ascii-art +tables.") + (home-page "https://github.com/telephil/cl-ascii-table") (license license:expat)))) -(define-public cl-raylib - (sbcl-package->cl-source-package sbcl-cl-raylib)) +(define-public cl-ascii-table + (sbcl-package->cl-source-package sbcl-cl-ascii-table)) -(define-public ecl-cl-raylib - (sbcl-package->ecl-package sbcl-cl-raylib)) +(define-public ecl-cl-ascii-table + (sbcl-package->ecl-package sbcl-cl-ascii-table)) -(define-public sbcl-cl-redis - (let ((commit "7d592417421cf7cd1cffa96043b457af0490df7d") - (revision "0")) +(define-public sbcl-cl-async + (let ((commit "f6423e44404a44434d803605e0d2e17199158e28") + (revision "1")) (package - (name "sbcl-cl-redis") - (version (git-version "2.3.8" revision commit)) + (name "sbcl-cl-async") + (version (git-version "0.6.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/vseloved/cl-redis") + (url "https://github.com/orthecreedence/cl-async") (commit commit))) - (file-name (git-file-name "cl-redis" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "0x5ahxb5cx37biyn3cjycshhm1rr9p5cf1a9l5hd1n1xjxm2f8vi")))) + (base32 + "11xi9dxb8mjgwzrkj88i0xkgk26z9w9ddxzbv6xsvfc1d4x5cf4x")))) (build-system asdf-build-system/sbcl) - (arguments - '(#:phases - (modify-phases %standard-phases - (add-before 'check 'start-redis - (lambda _ - (system "redis-server --port 6379 &")))))) - (native-inputs - `(("bordeaux-threads" ,sbcl-bordeaux-threads) - ("flexi-streams" ,sbcl-flexi-streams) - ("redis" ,redis) - ("should-test" ,sbcl-should-test))) (inputs `(("babel" ,sbcl-babel) + ("bordeaux-threads" ,sbcl-bordeaux-threads) + ("cffi" ,sbcl-cffi) + ("cl-libuv" ,sbcl-cl-libuv) ("cl-ppcre" ,sbcl-cl-ppcre) - ("flexi-streams" ,sbcl-flexi-streams) - ("rutils" ,sbcl-rutils) - ("usocket" ,sbcl-usocket))) - (home-page "https://github.com/vseloved/cl-redis") - (synopsis "Common Lisp client for Redis") - (description "This is a Common Lisp wrapper for interacting with the -Redis data structure store.") + ("fast-io" ,sbcl-fast-io) + ("openssl" ,openssl) + ("static-vectors" ,sbcl-static-vectors) + ("trivial-features" ,sbcl-trivial-features) + ("trivial-gray-streams" ,sbcl-trivial-gray-streams) + ("vom" ,sbcl-vom))) + (arguments + `(#:asd-systems '("cl-async" + "cl-async-repl" + "cl-async-ssl") + #:phases + (modify-phases %standard-phases + (add-after 'unpack 'fix-paths + (lambda* (#:key inputs #:allow-other-keys) + (substitute* "src/ssl/package.lisp" + (("libcrypto\\.so") + (search-input-file inputs "/lib/libcrypto.so")) + (("libssl\\.so") + (search-input-file inputs "/lib/libssl.so")))))))) + (synopsis "Asynchronous operations for Common Lisp") + (description + "Cl-async is a library for general purpose, non-blocking programming in +Common Lisp. It uses the libuv library as backend.") + (home-page "https://orthecreedence.github.io/cl-async/") (license license:expat)))) -(define-public cl-redis - (sbcl-package->cl-source-package sbcl-cl-redis)) +(define-public cl-async + (sbcl-package->cl-source-package sbcl-cl-async)) -(define-public ecl-cl-redis - (let ((pkg (sbcl-package->ecl-package sbcl-cl-redis))) - (package - (inherit pkg) - (arguments - (substitute-keyword-arguments (package-arguments pkg) - ;; Tests are failing on ECL with: - ;; Test L-COMMANDS: An error occurred during initialization: - ;; Protocol not found: "tcp". - ((#:tests? _ #f) #f)))))) +(define-public ecl-cl-async + (sbcl-package->ecl-package sbcl-cl-async)) -(define-public sbcl-parenscript - ;; Source archives are overwritten on every release, we use the Git repo instead. - (let ((commit "7a1ac46353cecd144fc91915ba9f122aafcf4766")) +(define-public sbcl-cl-async-future + (let ((commit "ee36c22a69a9516407458d2ed8b475f1fc473959") + (revision "1")) (package - (name "sbcl-parenscript") - (version (git-version "2.7.1" "1" commit)) + (name "sbcl-cl-async-future") + (version (git-version "0.4.4.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://gitlab.common-lisp.net/parenscript/parenscript") + (url "https://github.com/orthecreedence/cl-async-future") (commit commit))) - (file-name (git-file-name "parenscript" version)) + (file-name (git-file-name name version)) (sha256 (base32 - "0c22lqarrpbq82dg1sb3y6mp6w2faczp34ymzhnmff88yfq1xzsf")))) + "0z0sc7qlzzxk99f4l26zp6rai9kv0kj0f599sxai5s44p17zbbvh")))) (build-system asdf-build-system/sbcl) (inputs - (list sbcl-cl-ppcre sbcl-anaphora sbcl-named-readtables)) - (home-page "https://common-lisp.net/project/parenscript/") - (synopsis "Translator from a subset of Common Lisp to JavaScript") + (list sbcl-blackbird)) + (native-inputs + (list sbcl-cl-async sbcl-eos)) + (synopsis "Futures implementation for Common Lisp") (description - "Parenscript is a translator from an extended subset of Common Lisp to -JavaScript. Parenscript code can run almost identically on both the -browser (as JavaScript) and server (as Common Lisp). - -Parenscript code is treated the same way as Common Lisp code, making the full -power of Lisp macros available for JavaScript. This provides a web -development environment that is unmatched in its ability to reduce code -duplication and provide advanced meta-programming facilities to web -developers. - -At the same time, Parenscript is different from almost all other \"language -X\" to JavaScript translators in that it imposes almost no overhead: - -@itemize -@item No run-time dependencies: Any piece of Parenscript code is runnable -as-is. There are no JavaScript files to include. -@item Native types: Parenscript works entirely with native JavaScript data -types. There are no new types introduced, and object prototypes are not -touched. -@item Native calling convention: Any JavaScript code can be called without the -need for bindings. Likewise, Parenscript can be used to make efficient, -self-contained JavaScript libraries. -@item Readable code: Parenscript generates concise, formatted, idiomatic -JavaScript code. Identifier names are preserved. This enables seamless -debugging in tools like Firebug. -@item Efficiency: Parenscript introduces minimal overhead for advanced Common -Lisp features. The generated code is almost as fast as hand-written -JavaScript. -@end itemize\n") - (license license:bsd-3)))) - -(define-public cl-parenscript - (sbcl-package->cl-source-package sbcl-parenscript)) - -(define-public ecl-parenscript - (sbcl-package->ecl-package sbcl-parenscript)) - -(define-public sbcl-cl-json - (package - (name "sbcl-cl-json") - (version "0.6.0") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/sharplispers/cl-json") - (commit (string-append "v" version)))) - (file-name (git-file-name "cl-json" version)) - (sha256 - (base32 "12vakz47d1i7pywgb9cm2364fzykidc9m7l7b6n9lx0gn2qx9ar5")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-fiveam)) - (home-page "https://github.com/sharplispers/cl-json") - (synopsis "JSON encoder and decoder for Common-Lisp") - (description "@command{cl-json} provides an encoder of Lisp objects -to JSON format and a corresponding decoder of JSON data to Lisp -objects. Both the encoder and the decoder are highly customizable; at the -same time, the default settings ensure a very simple mode of operation, -similar to that provided by @command{yason} or @command{st-json}.") - (license license:expat))) + "This is futures implementation for Common Lisp. It plugs in nicely +to cl-async.") + (home-page "https://orthecreedence.github.io/cl-async/future") + (license license:expat)))) -(define-public cl-json - (sbcl-package->cl-source-package sbcl-cl-json)) +(define-public cl-async-future + (sbcl-package->cl-source-package sbcl-cl-async-future)) -(define-public ecl-cl-json - (sbcl-package->ecl-package sbcl-cl-json)) +(define-public ecl-cl-async-future + (sbcl-package->ecl-package sbcl-cl-async-future)) -(define-public sbcl-cl-json-pointer - (let ((commit "f6760e2a02972783f96b92a15f801e14a6828e0c") - (revision "0")) +(define-public sbcl-cl-autowrap + (let ((revision "2") + (commit "a5d71ebd7c21b87f449db1e16ab815750d7c0ea4")) + ;; no taged branches (package - (name "sbcl-cl-json-pointer") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-cl-autowrap") + (version (git-version "1.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/y2q-actionman/cl-json-pointer") + (url "https://github.com/rpav/cl-autowrap") (commit commit))) - (file-name (git-file-name "cl-json-pointer" version)) + (file-name (git-file-name "cl-autowrap" version)) (sha256 - (base32 "0b7a755wc2ghsd1pv7d32877b21h4nssp41xs017anbmj55czb2h")))) + (base32 "0795c817m1c41cz3ywzzg83z4pgkxdg6si553pay9mdgjvmrwmaw")))) (build-system asdf-build-system/sbcl) (arguments - ;; FIXME: Component "cl-json-pointer/test" not found. - `(#:tests? #f - #:asd-systems '("cl-json-pointer" "cl-json-pointer/synonyms"))) + `(#:asd-systems '("cl-plus-c" "cl-autowrap"))) (inputs - (list sbcl-alexandria - sbcl-boost-json - sbcl-cl-json - sbcl-closer-mop - sbcl-st-json)) - (home-page "https://github.com/y2q-actionman/cl-json-pointer") - (synopsis "JSON Pointer processor for Common Lisp") - (description " -This package provides a JSON -Pointer (@url{https://tools.ietf.org/html/rfc6901,RFC6901}) implementation for -Common Lisp. This libary aims to be independent from any JSON libraries (as much -as possible).") - (license license:expat)))) + `(("alexandria" ,sbcl-alexandria) + ("cffi" ,sbcl-cffi) + ("cl-json" ,sbcl-cl-json) + ("cl-ppcre" ,sbcl-cl-ppcre) + ("defpackage-plus" ,sbcl-defpackage-plus) + ("trivial-features" ,sbcl-trivial-features))) + (home-page "https://github.com/rpav/cl-autowrap") + (synopsis "FFI wrapper generator for Common Lisp") + (description "This is a c2ffi-based wrapper generator for Common Lisp.") + (license license:bsd-2)))) -(define-public cl-json-pointer - (sbcl-package->cl-source-package sbcl-cl-json-pointer)) +(define-public cl-autowrap + (sbcl-package->cl-source-package sbcl-cl-autowrap)) -(define-public ecl-cl-json-pointer - (sbcl-package->ecl-package sbcl-cl-json-pointer)) +(define-public ecl-cl-autowrap + (sbcl-package->ecl-package sbcl-cl-autowrap)) -(define-public sbcl-unix-opts - (let ((commit "0e61f34b2ecf62288437810d4abb31e572048b04") +(define-public sbcl-cl-base32 + (let ((commit "8cdee06fab397f7b0a19583b57e7f0c98405be85") (revision "1")) (package - (name "sbcl-unix-opts") - (version (git-version "0.1.7" revision commit)) + (name "sbcl-cl-base32") + (version (git-version "0.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/libre-man/unix-opts") + (url "https://github.com/hargettp/cl-base32") (commit commit))) - (file-name (git-file-name "unix-opts" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "16mcqpzwrz808p9n3wwl99ckg3hg7yihw08y1i4l7c92aldbkasq")))) + (base32 "17jrng8jb05d64ggyd11hp308c2fl5drvf9g175blgrkkl8l4mf8")))) (build-system asdf-build-system/sbcl) - (home-page "https://github.com/hankhero/cl-json") - (synopsis "Unix-style command line options parser") + (native-inputs + (list sbcl-lisp-unit)) + (synopsis "Common Lisp library for base32 encoding and decoding") (description - "This is a minimalistic parser of command line options. The main -advantage of the library is the ability to concisely define command line -options once and then use this definition for parsing and extraction of -command line arguments, as well as printing description of command line -options (you get --help for free). This way you don't need to repeat -yourself. Also, @command{unix-opts} doesn't depend on anything and -precisely controls the behavior of the parser via Common Lisp restarts.") + "This package provides functions for base32 encoding and decoding as +defined in RFC4648.") + (home-page "https://github.com/hargettp/cl-base32") (license license:expat)))) -(define-public cl-unix-opts - (sbcl-package->cl-source-package sbcl-unix-opts)) +(define-public cl-base32 + (sbcl-package->cl-source-package sbcl-cl-base32)) -(define-public ecl-unix-opts - (sbcl-package->ecl-package sbcl-unix-opts)) +(define-public ecl-cl-base32 + (sbcl-package->ecl-package sbcl-cl-base32)) -(define-public sbcl-trivial-garbage - (let ((commit "3474f6414b73d4e3aa2d5c53080f4247a34f6380") - (revision "0")) +(define-public sbcl-cl-base58 + (let ((commit "f446835b4104896e0eed6a61d2ceb4ad22f589d8") + (revision "1")) (package - (name "sbcl-trivial-garbage") - (version (git-version "0.21" revision commit)) + (name "sbcl-cl-base58") + (version (git-version "0.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/trivial-garbage/trivial-garbage") + (url "https://github.com/eudoxia0/cl-base58/") (commit commit))) - (file-name (git-file-name "cl-trivial-garbage" version)) + (file-name (git-file-name "cl-base58" version)) (sha256 - (base32 "0rfwxvwg0kpcaa0hsi035yrkfdfks4bq8d9azmrww2f0rmv9g6sd")))) + (base32 "01wiiyz1jzxx3zhxi2hpq5n8hv28g1mn0adk793vwjzh4v5bi5zz")))) (build-system asdf-build-system/sbcl) + (arguments + '(#:asd-systems '("cl-base58-test" "cl-base58") + #:phases + (modify-phases %standard-phases + (add-after 'unpack 'fix-tests + (lambda _ + (substitute* "cl-base58-test.asd" + (("cl-test-more") + "prove")) + #t))))) (native-inputs - (list sbcl-rt)) - (home-page "https://common-lisp.net/project/trivial-garbage/") - (synopsis "Portable GC-related APIs for Common Lisp") - (description "@command{trivial-garbage} provides a portable API to -finalizers, weak hash-tables and weak pointers on all major implementations of -the Common Lisp programming language.") - (license license:public-domain)))) - -(define-public cl-trivial-garbage - (sbcl-package->cl-source-package sbcl-trivial-garbage)) - -(define-public ecl-trivial-garbage - (sbcl-package->ecl-package sbcl-trivial-garbage)) - -(define-public sbcl-ucons - (let ((commit "d976810ef2b12a2caaf55bd0f258272e9b79f3be") - (revision "0")) - (package - (name "sbcl-ucons") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/marcoheisig/ucons") - (commit commit))) - (file-name (git-file-name "cl-ucons" version)) - (sha256 - (base32 "17aj47pdjiywnf33hl46p27za2q0pq5ar3fpqxaqskggxrfxmijl")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-alexandria - sbcl-atomics - sbcl-bordeaux-threads - sbcl-named-readtables - sbcl-trivia)) - (home-page "https://github.com/marcoheisig/ucons") - (synopsis "Unique conses for Common Lisp") - (description "UCONS is a Common Lisp library providing unique conses. -Unique conses are different from regular conses in that, in addition to their -@code{car} and @code{cdr}, they maintain a table of past users. Also, the -@code{cdr} of each ucons is restricted to other uconses or @code{nil}. -Uconses are meant for those situations where even reusing regular conses (to -avoid consing) is too computationally expensive.") + (list sbcl-prove)) + (home-page "https://github.com/eudoxia0/cl-base58") + (synopsis "Implementation of base58 for Common Lisp") + (description + "This library implements the @code{base58} encoding algorithm. It's +basically @code{base64} but with a smaller alphabet (58, as in the name) that +doesn't include similar looking characters, among other things. See +@url{https://github.com/bitcoin/bitcoin/blob/master/src/base58.h} for a full +reference.") (license license:expat)))) -(define-public cl-ucons - (sbcl-package->cl-source-package sbcl-ucons)) +(define-public cl-base58 + (sbcl-package->cl-source-package sbcl-cl-base58)) -(define-public ecl-ucons - (sbcl-package->ecl-package sbcl-ucons)) +(define-public ecl-cl-base58 + (sbcl-package->ecl-package sbcl-cl-base58)) -(define-public sbcl-clobber - (let ((commit "212721c24a8bb792714314ba52dfe818641f2e98") - (revision "0")) +(define-public sbcl-cl-base64 + (let ((commit "577683b18fd880b82274d99fc96a18a710e3987a")) (package - (name "sbcl-clobber") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-cl-base64") + (version (git-version "3.3.4" "1" commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/robert-strandh/Clobber") + (url "http://git.kpe.io/cl-base64.git/") (commit commit))) - (file-name (git-file-name "cl-clobber" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "0pqzfn2wqbzzwlwc3l84iv3i3wa9zfgnh14mq67h9qkib8wjzx3n")))) + (base32 "12jj54h0fs6n237cvnp8v6hn0imfksammq22ys6pi0gwz2w47rbj")) + (modules '((guix build utils))) + (snippet + ;; The useless bundled debian folder drags `make' into the closure. + `(begin + (delete-file-recursively "debian") + #t)))) (build-system asdf-build-system/sbcl) - (home-page "https://github.com/robert-strandh/Clobber") - (synopsis "Common Lisp Library for transaction-oriented databases") + (native-inputs ; For tests. + (list sbcl-ptester sbcl-kmrcl)) + (home-page "http://files.kpe.io/cl-base64/") + (synopsis + "Common Lisp package to encode and decode base64 with URI support") (description - "CLOBBER is an alternative to so-called @emph{object prevalence}, and in -particular to @code{cl-prevalence}. Clobber is both simpler, more flexible, and -more robust than systems based on object prevalence.") - (license license:bsd-2)))) + "This package provides highly optimized base64 encoding and decoding. +Besides conversion to and from strings, integer conversions are supported. +Encoding with Uniform Resource Identifiers is supported by using a modified +encoding table that uses only URI-compatible characters.") + (license license:bsd-3)))) -(define-public cl-clobber - (sbcl-package->cl-source-package sbcl-clobber)) +(define-public cl-base64 + (sbcl-package->cl-source-package sbcl-cl-base64)) -(define-public ecl-clobber - (sbcl-package->ecl-package sbcl-clobber)) +(define-public ecl-cl-base64 + (sbcl-package->ecl-package sbcl-cl-base64)) -(define-public sbcl-closer-mop - (let ((commit "7b86f2add029208ebc74ec6a41c2ccfd3c382dbc") - (revision "3")) +(define-public sbcl-cl-cairo2 + (let ((commit "41ae45aac86553c46f4bb460f80e1fb620930f5b") + (revision "1")) (package - (name "sbcl-closer-mop") - (version (git-version "1.0.0" revision commit)) + (name "sbcl-cl-cairo2") + (version (git-version "0.6" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/pcostanza/closer-mop") + (url "https://github.com/rpav/cl-cairo2") (commit commit))) + (file-name (git-file-name "cl-cairo2" version)) (sha256 - (base32 "1fzxdpq873rpagmj3h9bgv7n95h4p03pnxrklbxp06sxb26xyi16")) - (file-name (git-file-name "cl-closer-mop" version )))) + (base32 "0cpfgyxw6pz7y033dlya8c4vjmkpw127zdq3a9xclp9q8jbdlb7q")))) (build-system asdf-build-system/sbcl) - (home-page "https://github.com/pcostanza/closer-mop") - (synopsis "Rectifies absent or incorrect CLOS MOP features") - (description "Closer to MOP is a compatibility layer that rectifies many -of the absent or incorrect CLOS MOP features across a broad range of Common -Lisp implementations.") - (license license:expat)))) + (arguments + `(#:asd-systems '(;; "cl-cairo2-gtk2" ; cl-gtk2 is not packed and quite old. + ;; "cl-cairo2-quartz" ; Failing when enabled. + ;; "cl-cairo2-xlib" ; cl-xcb-xlib is not packed yet and quite old. + ;; "cl-cairo2-xcb" + "cl-cairo2") + #:phases + (modify-phases %standard-phases + (add-after 'unpack 'fix-paths + (lambda* (#:key inputs #:allow-other-keys) + (substitute* "src/load-libraries.lisp" + (("libcairo.so.2") + (search-input-file inputs "/lib/libcairo.so.2")))))))) + (inputs + (list cairo + sbcl-cffi + sbcl-cl-colors + sbcl-cl-freetype2 + sbcl-cl-utilities + sbcl-metabang-bind + sbcl-trivial-features + sbcl-trivial-garbage)) + (home-page "https://github.com/rpav/cl-cairo2") + (synopsis "Cairo bindings for Common Lisp") + (description + "This package provides CFFI bindings for Common Lisp to the Cairo +C library.") + (license license:boost1.0)))) -(define-public cl-closer-mop - (sbcl-package->cl-source-package sbcl-closer-mop)) +(define-public cl-cairo2 + (sbcl-package->cl-source-package sbcl-cl-cairo2)) -(define-public ecl-closer-mop - (sbcl-package->ecl-package sbcl-closer-mop)) +(define-public ecl-cl-cairo2 + (sbcl-package->ecl-package sbcl-cl-cairo2)) (define-public sbcl-cl-cffi-gtk (let ((commit "1700fe672c65455c1fc33061ec92a3df84287ec7") @@ -5374,2232 +4203,915 @@ is a library for creating graphical user interfaces.") (define-public ecl-cl-cffi-gtk (sbcl-package->ecl-package sbcl-cl-cffi-gtk)) -(define-public sbcl-cl-webkit - (package - (name "sbcl-cl-webkit") - (version "3.5.10") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/joachifm/cl-webkit") - (commit version))) - (file-name (git-file-name "cl-webkit" version)) - (sha256 - (base32 - "0bn8idvbi58kg0g76lanvjzkgnkcy41yn9vbp7f80q9fa7w892rq")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("cffi" ,sbcl-cffi) - ("cl-cffi-gtk" ,sbcl-cl-cffi-gtk) - ("webkitgtk" ,webkitgtk-for-gtk3))) - (native-inputs - `(;; Tests seem to need Xorg. - ;; ("xorg-server" ,xorg-server-for-tests) - ("calispel" ,sbcl-calispel) - ("fiveam" ,sbcl-fiveam) - ("float-features" ,sbcl-float-features))) - (arguments - `(#:asd-systems '("cl-webkit2") - #:tests? #f ; TODO: Tests hang, why? - #:phases - (modify-phases %standard-phases - ;; The following phase is needed for tests: - ;; (add-before 'check 'start-xorg-server - ;; (lambda* (#:key inputs #:allow-other-keys) - ;; ;; The test suite requires a running X server. - ;; (system (string-append (assoc-ref inputs "xorg-server") - ;; "/bin/Xvfb :1 &")) - ;; (setenv "DISPLAY" ":1") - ;; #t)) - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "webkit2/webkit2.init.lisp" - (("libwebkit2gtk" all) - (string-append - (assoc-ref inputs "webkitgtk") "/lib/" all)))))))) - (home-page "https://github.com/joachifm/cl-webkit") - (synopsis "Binding to WebKitGTK+ for Common Lisp") - (description - "@command{cl-webkit} is a binding to WebKitGTK+ for Common Lisp, -currently targeting WebKit version 2. The WebKitGTK+ library adds web -browsing capabilities to an application, leveraging the full power of the -WebKit browsing engine.") - (license license:expat))) - -(define-public cl-webkit - (sbcl-package->cl-source-package sbcl-cl-webkit)) - -(define-public ecl-cl-webkit - (sbcl-package->ecl-package sbcl-cl-webkit)) - -(define-public sbcl-lparallel - (let ((commit "80fc2952a074776abd343d6b5d3ab157f0e1df7a") +(define-public sbcl-cl-change-case + (let ((commit "45c70b601125889689e0c1c37d7e727a3a0af022") (revision "1")) (package - (name "sbcl-lparallel") - (version (git-version "2.8.4" revision commit)) + (name "sbcl-cl-change-case") + (version (git-version "0.2.0" revision commit)) + (home-page "https://github.com/rudolfochrist/cl-change-case") (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/sharplispers/lparallel/") + (url home-page) (commit commit))) - (file-name (git-file-name "cl-lparallel" version)) + (file-name (git-file-name "cl-change-case" version)) (sha256 - (base32 "0nv2dx8cl25g68icqhw95yr5mygm86lcjzmzijql51na1p60g6y9")))) + (base32 "0qmk341zzcsbf8sq0w9ix3r080zg4ri6vzxym63lhdjfzwz3y8if")))) (build-system asdf-build-system/sbcl) (inputs - (list sbcl-alexandria - sbcl-bordeaux-threads - sbcl-trivial-garbage)) - (arguments - `(#:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-dependency - ;; lparallel loads a SBCL specific system in its asd file. This is - ;; not carried over into the fasl which is generated. In order for - ;; it to be carried over, it needs to be listed as a dependency. - (lambda _ - (substitute* "lparallel.asd" - ((":depends-on \\(:alexandria" all) - (string-append all " #+sbcl :sb-cltl2")))))))) - (home-page "https://lparallel.org/") - (synopsis "Parallelism for Common Lisp") - (description - "@command{lparallel} is a library for parallel programming in Common -Lisp, featuring: - -@itemize -@item a simple model of task submission with receiving queue, -@item constructs for expressing fine-grained parallelism, -@item asynchronous condition handling across thread boundaries, -@item parallel versions of map, reduce, sort, remove, and many others, -@item promises, futures, and delayed evaluation constructs, -@item computation trees for parallelizing interconnected tasks, -@item bounded and unbounded FIFO queues, -@item high and low priority tasks, -@item task killing by category, -@item integrated timeouts. -@end itemize\n") - (license license:expat)))) - -(define-public cl-lparallel - (sbcl-package->cl-source-package sbcl-lparallel)) - -(define-public ecl-lparallel - (sbcl-package->ecl-package sbcl-lparallel)) - -(define-public sbcl-cl-markup - (let ((commit "e0eb7debf4bdff98d1f49d0f811321a6a637b390")) - (package - (name "sbcl-cl-markup") - (version (git-version "0.1" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/arielnetworks/cl-markup/") - (commit commit))) - (file-name (git-file-name "cl-markup" version)) - (sha256 - (base32 - "10l6k45971dl13fkdmva7zc6i453lmq9j4xax2ci6pjzlc6xjhp7")))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/arielnetworks/cl-markup/") - (synopsis "Markup generation library for Common Lisp") + (list sbcl-cl-ppcre sbcl-cl-ppcre-unicode)) + (native-inputs + (list sbcl-fiveam)) + (synopsis + "Convert Common Lisp strings between camelCase, PascalCase and more") (description - "A modern markup generation library for Common Lisp that features: - -@itemize -@item Fast (even faster through compiling the code) -@item Safety -@item Support for multiple document types (markup, xml, html, html5, xhtml) -@item Output with doctype -@item Direct output to stream -@end itemize\n") - (license license:lgpl3+)))) + "@code{cl-change-case} is a library to convert strings between +camelCase, PascalCase, snake_case, param-case, CONSTANT_CASE and more.") + (license license:llgpl)))) -(define-public cl-markup - (sbcl-package->cl-source-package sbcl-cl-markup)) +(define-public cl-change-case + (sbcl-package->cl-source-package sbcl-cl-change-case)) -(define-public ecl-cl-markup - (sbcl-package->ecl-package sbcl-cl-markup)) +(define-public ecl-cl-change-case + (sbcl-package->ecl-package sbcl-cl-change-case)) -;;; The following package is renamed from "markup" to "markup-reader" in order -;;; not to conflict with the "cl-markup" package. -(define-public sbcl-markup-reader - (let ((commit "d2d4d7b073554f47c24223a9304452966608702e") +(define-public sbcl-cl-charms + (let ((commit "64aba59d89f85bc5c9402e445873965338a66a02") (revision "1")) (package - (name "sbcl-markup-reader") - (version (git-version "0.0.1" revision commit)) + (name "sbcl-cl-charms") + (version (git-version "0.2.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/moderninterpreters/markup") + (url "https://github.com/HiTECNOLOGYs/cl-charms") (commit commit))) - (file-name (git-file-name "markup-reader" version)) + (file-name (git-file-name "cl-charms" version)) (sha256 - (base32 "0i3v938j8zpzkd6p9j8gadp5zndjcdxhswj1qgsp592v6497rpzj")))) + (base32 "1jczaypa9dhxr34yyhsxb6lrdnircjx8am4iqkc3shfpjn32q323")))) (build-system asdf-build-system/sbcl) - (arguments - '(#:asd-systems '("markup"))) - (native-inputs - (list sbcl-fiveam)) (inputs `(("alexandria" ,sbcl-alexandria) - ("cl-str" ,sbcl-cl-str) - ("named-readtables" ,sbcl-named-readtables) - ("trivial-gray-streams" ,sbcl-trivial-gray-streams))) - (home-page "https://github.com/moderninterpreters/markup") - (synopsis "Reader-macro to read HTML tags inside of Common Lisp code") + ("cffi" ,sbcl-cffi) + ("ncurses" ,ncurses))) + (arguments + '(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'fix-paths + (lambda* (#:key inputs #:allow-other-keys) + (substitute* "src/low-level/curses-bindings.lisp" + (("libncursesw.so") + (string-append (assoc-ref inputs "ncurses") + "/lib/libncursesw.so")))))))) + (home-page "https://github.com/HiTECNOLOGYs/cl-charms") + (synopsis "Interface to libcurses in Common Lisp") (description - "Markup allows the use of HTML syntax with in Common Lisp code. -This has the advantage of being able to copy HTML snippets and have them -instantly be functional, less double quotes than a s-expression approach, -and designers will be able to understand the embedded HTML.") - (license license:asl2.0)))) - -(define-public ecl-markup-reader - (sbcl-package->ecl-package sbcl-markup-reader)) - -(define-public cl-markup-reader - (sbcl-package->cl-source-package sbcl-markup-reader)) - -(define-public sbcl-xml-emitter - (package - (name "sbcl-xml-emitter") - (version "1.1.0") - (source (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/VitoVan/xml-emitter") - (commit version))) - (file-name (git-file-name "cl-xml-emitter" version)) - (sha256 - (base32 - "1w9yx8gc4imimvjqkhq8yzpg3kjrp2y37rjix5c1lnz4s7bxvhk9")))) - (build-system asdf-build-system/sbcl) - (native-inputs (list sbcl-1am)) - (inputs (list sbcl-cl-utilities)) - (synopsis "Common lisp library for emitting XML output") - (description - "This package provides functions to emit XML, with some complexity for -handling indentation. It can be used to produce all sorts of useful XML -output; it has an RSS 2.0 emitter built in, so you can make RSS feeds -trivially.") - (home-page "https://www.cliki.net/xml-emitter") - (license license:expat))) + "@code{cl-charms} is an interface to libcurses in Common Lisp. It +provides both a raw, low-level interface to libcurses via CFFI, and a more +higher-level lispier interface.") + (license license:expat)))) -(define-public cl-xml-emitter - (sbcl-package->cl-source-package sbcl-xml-emitter)) +(define-public cl-charms + (sbcl-package->cl-source-package sbcl-cl-charms)) -(define-public ecl-xml-emitter - (sbcl-package->ecl-package sbcl-xml-emitter)) +(define-public ecl-cl-charms + (sbcl-package->ecl-package sbcl-cl-charms)) -(define-public sbcl-kdlcl - (let ((commit "dd4a48a3473c3c8fb34d4a37f87d6a1776c5875c") +(define-public sbcl-cl-collider + (let ((commit "a46908896982868955b29bfb3a5337a0af489b0b") (revision "0")) (package - (name "sbcl-kdlcl") - (version (git-version "1.0" revision commit)) - (source + (name "sbcl-cl-collider") + (version (git-version "2018.7.15" revision commit)) + (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/chee/kdlcl") + (url "https://github.com/byulparan/cl-collider") (commit commit))) - (file-name (git-file-name "cl-kdlcl" version)) + (file-name (git-file-name "cl-collider" version)) (sha256 - (base32 "0bqqxkd6s420ld2hmhvbbvpzss0m2kimmxaqhz7j1ksmq86bvvmj")))) - (build-system asdf-build-system/sbcl) - (arguments `(#:asd-systems '("kdl"))) - (inputs (list sbcl-esrap sbcl-parse-number)) - (home-page "https://github.com/chee/kdlcl/") - (synopsis "KDL reader/printer for Common Lisp") - (description "This package provides a KDL reader/writer for - Common Lisp.") - (license license:expat-0)))) - -(define-public cl-kdlcl - (sbcl-package->cl-source-package sbcl-kdlcl)) - -(define-public ecl-kdlcl - (sbcl-package->ecl-package sbcl-kdlcl)) - -(define-public sbcl-cl-mustache - (package - (name "sbcl-cl-mustache") - (version "0.12.1") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/kanru/cl-mustache") - (commit (string-append "v" version)))) - (file-name (git-file-name "cl-mustache" version)) - (sha256 - (base32 "149xbb6wxq1napliwm9cv729hwcgfnjli6y8hingfixz7f10lhks")))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/kanru/cl-mustache") - (synopsis "Common Lisp Mustache template renderer") - (description "This is a Common Lisp implementation for the Mustache -template system. More details on the standard are available at -@url{https://mustache.github.io}.") - (license license:expat))) + (base32 "10wvjbwvbgr0b57hpfxycg90yjmb29pirygr1sxrdaqxll328sz1")))) + (build-system asdf-build-system/sbcl) + (arguments + (list #:phases + #~(modify-phases %standard-phases + (add-after 'unpack 'patch-executables-and-paths + (lambda* (#:key inputs #:allow-other-keys) + (substitute* "server.lisp" + (("/usr/local/lib/SuperCollider/plugins") + (search-input-directory + inputs "/lib/SuperCollider/plugins")) + (("/usr/local/share/SuperCollider/Extensions") + (search-input-directory + inputs "/share/SuperCollider/Extensions")) + (("which scsynth") + (string-append + "which " + (search-input-file inputs "/bin/scsynth"))) + (("jack_connect") + (search-input-file inputs "/bin/jack_connect")))))))) + (inputs + (list jack-1 + supercollider + sbcl-alexandria + sbcl-bordeaux-threads + sbcl-cffi + sbcl-cl-ppcre + sbcl-flexi-streams + sbcl-ieee-floats ; sc-osc dependencies. + sbcl-named-readtables + sbcl-osc + sbcl-pileup + sbcl-simple-inferiors ; For ecl. + sbcl-split-sequence + sbcl-usocket)) + (synopsis "SuperCollider client for CommonLisp") + (description "This package provides a SuperCollider client for +Common Lisp.") + (home-page "https://github.com/byulparan/cl-collider/") + (license license:public-domain)))) -(define-public cl-mustache - (sbcl-package->cl-source-package sbcl-cl-mustache)) +(define-public cl-collider + (sbcl-package->cl-source-package sbcl-cl-collider)) -(define-public ecl-cl-mustache - (sbcl-package->ecl-package sbcl-cl-mustache)) +(define-public ecl-cl-collider + (sbcl-package->ecl-package sbcl-cl-collider)) -(define-public sbcl-cl-css - (let ((commit "8fe654c8f0cf95b300718101cce4feb517f78e2f")) +(define-public sbcl-cl-colors + (let ((commit "827410584553f5c717eec6182343b7605f707f75")) (package - (name "sbcl-cl-css") - (version (git-version "0.1" "1" commit)) + (name "sbcl-cl-colors") + (version (git-version "0.0.0" "1" commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/inaimathi/cl-css/") + (url "https://github.com/tpapp/cl-colors") (commit commit))) - (file-name (git-file-name "cl-css" version)) (sha256 (base32 - "1lc42zi2sw11fl2589sc19nr5sd2p0wy7wgvgwaggxa5f3ajhsmd")))) + "0l446lday4hybsm9bq3jli97fvv8jb1d33abg79vbylpwjmf3y9a")) + (file-name (git-file-name "cl-colors" version)))) (build-system asdf-build-system/sbcl) - (home-page "https://github.com/inaimathi/cl-css/") - (synopsis "Non-validating, inline CSS generator for Common Lisp") + (inputs + (list sbcl-alexandria sbcl-let-plus)) + (synopsis "Simple color library for Common Lisp") (description - "This is a dead-simple, non validating, inline CSS generator for Common -Lisp. Its goals are axiomatic syntax, simple implementation to support -portability, and boilerplate reduction in CSS.") - (license license:expat)))) - -(define-public cl-css - (sbcl-package->cl-source-package sbcl-cl-css)) + "This is a very simple color library for Common Lisp, providing -(define-public ecl-cl-css - (sbcl-package->ecl-package sbcl-cl-css)) +@itemize +@item Types for representing colors in HSV and RGB spaces. +@item Simple conversion functions between the above types (and also +hexadecimal representation for RGB). +@item Some predefined colors (currently X11 color names – of course the +library does not depend on X11).Because color in your terminal is nice. +@end itemize -(define-public sbcl-portable-threads - (let ((commit "aa26bf38338a6b068bf8bfb3375d8d8c3b0a28df")) - (package - (name "sbcl-portable-threads") - (version (git-version "2.3" "2" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/binghe/portable-threads/") - (commit commit))) - (file-name (git-file-name "portable-threads" version)) - (sha256 - (base32 "058ksi07vfdmhrf5mdlc833s82m1rcqfja2266520m3r8bzs8bvs")))) - (build-system asdf-build-system/sbcl) - (arguments - `(;; Tests seem broken. - #:tests? #f)) - (home-page "https://github.com/binghe/portable-threads") - (synopsis "Portable threads API for Common Lisp") - (description - "Portable Threads (and Scheduled and Periodic Functions) API for Common -Lisp (from GBBopen project).") - (license license:asl2.0)))) +This library is no longer supported by its author.") + (home-page "https://github.com/tpapp/cl-colors") + (license license:boost1.0)))) -(define-public cl-portable-threads - (sbcl-package->cl-source-package sbcl-portable-threads)) +(define-public cl-colors + (sbcl-package->cl-source-package sbcl-cl-colors)) -(define-public ecl-portable-threads - (sbcl-package->ecl-package sbcl-portable-threads)) +(define-public ecl-cl-colors + (sbcl-package->ecl-package sbcl-cl-colors)) -(define-public sbcl-usocket +(define-public sbcl-cl-colors2 (package - (name "sbcl-usocket") - (version "0.8.6") + (name "sbcl-cl-colors2") + (version "0.6.0") (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/usocket/usocket/") + (url "https://codeberg.org/cage/cl-colors2") (commit (string-append "v" version)))) - (file-name (git-file-name "cl-usocket" version)) + (file-name (git-file-name "cl-colors2" version)) (sha256 - (base32 "0by8hhg6gijdbq5vjykd374rmvqyikp4synpyk0wjcl7rk3r0vgn")))) + (base32 "0vnvlq9xixs04768q7hapsi16cjp3ych6mypvs6chihd5dal4cnd")))) (build-system asdf-build-system/sbcl) (native-inputs - (list sbcl-rt)) + (list sbcl-clunit2)) (inputs - (list sbcl-bordeaux-threads sbcl-split-sequence)) - (arguments - `(#:tests? #f ; FIXME: Tests need network access? - #:asd-systems '("usocket" - "usocket-server"))) - (home-page "https://common-lisp.net/project/usocket/") - (synopsis "Universal socket library for Common Lisp") - (description - "This library strives to provide a portable TCP/IP and UDP/IP socket -interface for as many Common Lisp implementations as possible, while keeping -the abstraction and portability layer as thin as possible.") - (license license:expat))) - -(define-public cl-usocket - (sbcl-package->cl-source-package sbcl-usocket)) - -(define-public ecl-usocket - (sbcl-package->ecl-package sbcl-usocket)) - -(define-public sbcl-trivial-sockets - (package - (name "sbcl-trivial-sockets") - (version "0.4") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/usocket/trivial-sockets/") - (commit (string-append "v" version)))) - (file-name (git-file-name "cl-trivial-sockets" version)) - (sha256 - (base32 "0xj9x5z3psxqap9c29qz1xswx5fiqxyzd35kmbw2g6z08cgb7nd0")))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/usocket/trivial-sockets") - (synopsis "Simple socket library for Common Lisp") - (description - "This library is a portable socket interface that allows CL programs to -open connected (client) stream sockets to network services.") - (license license:expat))) - -(define-public cl-trivial-sockets - (sbcl-package->cl-source-package sbcl-trivial-sockets)) - -(define-public sbcl-s-xml - (package - (name "sbcl-s-xml") - (version "3") - (source - (origin - (method url-fetch) - (uri "https://common-lisp.net/project/s-xml/s-xml.tgz") - (sha256 - (base32 - "061qcr0dzshsa38s5ma4ay924cwak2nq9gy59dw6v9p0qb58nzjf")))) - (build-system asdf-build-system/sbcl) - (home-page "https://common-lisp.net/project/s-xml/") - (synopsis "Simple XML parser implemented in Common Lisp") + (list sbcl-alexandria sbcl-cl-ppcre sbcl-parse-number)) + (synopsis "Color library for Common Lisp") (description - "S-XML is a simple XML parser implemented in Common Lisp. This XML -parser implementation has the following features: - -@itemize -@item It works (handling many common XML usages). -@item It is very small (the core is about 700 lines of code, including -comments and whitespace). -@item It has a core API that is simple, efficient and pure functional, much -like that from SSAX (see also http://ssax.sourceforge.net). -@item It supports different DOM models: an XSML-based one, an LXML-based one -and a classic xml-element struct based one. -@item It is reasonably time and space efficient (internally avoiding garbage -generatation as much as possible). -@item It does support CDATA. -@item It should support the same character sets as your Common Lisp -implementation. -@item It does support XML name spaces. -@end itemize - -This XML parser implementation has the following limitations: + "This is a very simple color library for Common Lisp, providing: @itemize -@item It does not support any special tags (like processing instructions). -@item It is not validating, even skips DTD's all together. +@item Types for representing colors in HSV, HSL, and RGB spaces. +@item Simple conversion functions between the above types. +@item Function printing colors to HEX, RGB, RGBA, and HSL. +@item Predefined colors from X11, SVG, and GDK. @end itemize\n") - (license license:lgpl3+))) - -(define-public cl-s-xml - (sbcl-package->cl-source-package sbcl-s-xml)) - -(define-public ecl-s-xml - (sbcl-package->ecl-package sbcl-s-xml)) - -(define-public sbcl-s-xml-rpc - (package - (name "sbcl-s-xml-rpc") - (version "7") - (source - (origin - (method url-fetch) - (uri "https://common-lisp.net/project/s-xml-rpc/s-xml-rpc.tgz") - (sha256 - (base32 - "02z7k163d51v0pzk8mn1xb6h5s6x64gjqkslhwm3a5x26k2gfs11")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-s-xml)) - (home-page "https://common-lisp.net/project/s-xml-rpc/") - (synopsis "Implementation of XML-RPC in Common Lisp for both client and server") - (description - "S-XML-RPC is an implementation of XML-RPC in Common Lisp for both -client and server.") - (license license:lgpl3+))) - -(define-public cl-s-xml-rpc - (sbcl-package->cl-source-package sbcl-s-xml-rpc)) - -(define-public ecl-s-xml-rpc - (sbcl-package->ecl-package sbcl-s-xml-rpc)) - -(define-public sbcl-trivial-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 "aee67d6132a46237f61d508ae4bd9ff44032566d") - (revision "7")) - (package - (name "sbcl-trivial-clipboard") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/snmsts/trivial-clipboard") - (commit commit))) - (file-name (git-file-name "cl-trivial-clipboard" version)) - (sha256 - (base32 "029qmx523xfk54p99ndgbmdd20s5i32mzpf77xymngrn4c33v9jk")))) - (build-system asdf-build-system/sbcl) - (inputs - ;; Pick xsel instead of xclip because its closure size is slightly - ;; smaller. - (list wl-clipboard xsel)) - (native-inputs - (list sbcl-fiveam)) - (arguments - `(#:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "src/text.lisp" - (("\"xsel\"") - (string-append "\"" (assoc-ref inputs "xsel") "/bin/xsel\"")) - (("\"wl-copy\"") - (string-append "\"" - (assoc-ref inputs "wl-clipboard") - "/bin/wl-copy\"")) - (("\"wl-paste\"") - (string-append "\"" - (assoc-ref inputs "wl-clipboard") - "/bin/wl-paste\"")))))))) - (home-page "https://github.com/snmsts/trivial-clipboard") - (synopsis "Access system clipboard in Common Lisp") - (description - "@command{trivial-clipboard} gives access to the system clipboard.") - (license license:expat)))) + (home-page "https://codeberg.org/cage/cl-colors2") + (license license:boost1.0))) -(define-public cl-trivial-clipboard - (sbcl-package->cl-source-package sbcl-trivial-clipboard)) +(define-public cl-colors2 + (sbcl-package->cl-source-package sbcl-cl-colors2)) -(define-public ecl-trivial-clipboard - (sbcl-package->ecl-package sbcl-trivial-clipboard)) +(define-public ecl-cl-colors2 + (sbcl-package->ecl-package sbcl-cl-colors2)) -(define-public sbcl-trivial-backtrace - (let ((commit "7f90b4a4144775cca0728791e4b92ac2557b07a1") +(define-public sbcl-cl-conspack + (let ((commit "6e529d7b3a7223ef1bb5c7b9f18384ba67b50b09") (revision "2")) (package - (name "sbcl-trivial-backtrace") - (version (git-version "1.1.0" revision commit)) + (name "sbcl-cl-conspack") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/hraban/trivial-backtrace") + (url "https://github.com/conspack/cl-conspack") (commit commit))) - (file-name (git-file-name "trivial-backtrace" version)) + (file-name (git-file-name "cl-conspack" version)) (sha256 - (base32 "11j0p3vgmnn5q84xw7sacr5p3cvff2hfhsh2is8xpm2iwxc723kn")))) + (base32 "0y5wp5c89ph44k2xjppy1c1jf2ac3q9yrk22da2rkwnbxn0h1a8d")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-lift)) (arguments - `(#:phases - (modify-phases %standard-phases - (add-after 'check 'delete-test-results - (lambda* (#:key outputs #:allow-other-keys) - (let ((test-results (string-append (assoc-ref outputs "out") - "/share/common-lisp/" - (%lisp-type) - "/trivial-backtrace" - "/test-results"))) - (when (file-exists? test-results) - (delete-file-recursively test-results))) - #t))))) - (home-page "https://common-lisp.net/project/trivial-backtrace/") - (synopsis "Portable simple API to work with backtraces in Common Lisp") + '(#:asd-test-systems '("cl-conspack-test"))) + (native-inputs + (list sbcl-fiveam)) + (inputs + (list sbcl-alexandria + sbcl-closer-mop + sbcl-fast-io + sbcl-ieee-floats + sbcl-trivial-garbage + sbcl-trivial-utf-8)) + (home-page "https://github.com/conspack/cl-conspack") + (synopsis "CONSPACK implementation for Common Lisp") (description - "One of the many things that didn't quite get into the Common Lisp -standard was how to get a Lisp to output its call stack when something has -gone wrong. As such, each Lisp has developed its own notion of what to -display, how to display it, and what sort of arguments can be used to -customize it. @code{trivial-backtrace} is a simple solution to generating a -backtrace portably.") - (license license:expat)))) + "This package provides a CONSPACK implementation for Common Lisp.") + (license license:bsd-3)))) -(define-public cl-trivial-backtrace - (sbcl-package->cl-source-package sbcl-trivial-backtrace)) +(define-public cl-conspack + (sbcl-package->cl-source-package sbcl-cl-conspack)) -(define-public ecl-trivial-backtrace - (sbcl-package->ecl-package sbcl-trivial-backtrace)) +(define-public ecl-cl-conspack + (sbcl-package->ecl-package sbcl-cl-conspack)) -(define-public sbcl-rfc2388 - (let ((commit "591bcf7e77f2c222c43953a80f8c297751dc0c4e") +(define-public sbcl-cl-cont + (let ((commit "fc1fa7e6eb64894fdca13e688e6015fad5290d2a") (revision "1")) (package - (name "sbcl-rfc2388") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/jdz/rfc2388") - (commit commit))) - (file-name (git-file-name "rfc2388" version)) - (sha256 - (base32 "0phh5n3clhl9ji8jaxrajidn22d3f0aq87mlbfkkxlnx2pnw694k")))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/jdz/rfc2388/") - (synopsis "Implementation of RFC 2388 in Common Lisp") - (description - "This package contains an implementation of RFC 2388, which is used to -process form data posted with HTTP POST method using enctype -\"multipart/form-data\".") - (license license:bsd-2)))) - -(define-public cl-rfc2388 - (sbcl-package->cl-source-package sbcl-rfc2388)) - -(define-public ecl-rfc2388 - (sbcl-package->ecl-package sbcl-rfc2388)) - -(define-public sbcl-md5 - (package - (name "sbcl-md5") - (version "2.0.5") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/pmai/md5") - (commit (string-append "release-" version)))) - (file-name (git-file-name "md5" version)) - (sha256 - (base32 "1g20np6rhn3y08z8mlmlk721mw2207s52v2pwp4smm3lz25sx3q5")))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/pmai/md5") - (synopsis - "Common Lisp implementation of the MD5 Message-Digest Algorithm (RFC 1321)") - (description - "This package implements The MD5 Message-Digest Algorithm, as defined in -RFC 1321 by R. Rivest, published April 1992.") - (license license:public-domain))) - -(define-public cl-md5 - (sbcl-package->cl-source-package sbcl-md5)) - -(define-public ecl-md5 - (package - (inherit (sbcl-package->ecl-package sbcl-md5)) - (inputs - (list ecl-flexi-streams)))) - -(define-public sbcl-cl+ssl - (let ((commit "17d5cdd65405f1d26e26f3e875e70027d0c8eedb") - (revision "6")) - (package - (name "sbcl-cl+ssl") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-cl-cont") + (version (git-version "0.3.8" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/cl-plus-ssl/cl-plus-ssl") + (url "https://gitlab.common-lisp.net/cl-cont/cl-cont.git") (commit commit))) - (file-name (git-file-name "cl+ssl" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "0v0kx2m5355jkdshmj0z923c5rlvdl2n11rb3hjbv3kssdfsbs0s")))) + (base32 + "1zf8zvb0i6jm3hhfks4w74hibm6avgc6f9s1qwgjrn2bcik8lrvz")))) (build-system asdf-build-system/sbcl) - (arguments - '(#:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "src/reload.lisp" - (("libssl.so" all) - (string-append - (assoc-ref inputs "openssl") "/lib/" all)) - (("libcrypto.so" all) - (string-append - (assoc-ref inputs "openssl") "/lib/" all))))) - (add-after 'fix-paths 'fix-tests - (lambda _ - ;; Disable coverall support in tests because of a circular - ;; dependency: cl+ssl -> cl-coverall -> dexador - ;; -> clack -> hunchentoot -> cl+ssl - (substitute* "cl+ssl.test.asd" - (("\\(:feature \\(:or :sbcl :ccl\\) :cl-coveralls\\)") - ""))))))) - (native-inputs - (list ;sbcl-cl-coveralls - sbcl-fiveam - sbcl-trivial-sockets)) (inputs - (list openssl - sbcl-alexandria - sbcl-bordeaux-threads - sbcl-cffi - sbcl-flexi-streams - sbcl-trivial-features - sbcl-trivial-garbage - sbcl-trivial-gray-streams - sbcl-usocket)) - (home-page "https://common-lisp.net/project/cl-plus-ssl/") - (synopsis "Common Lisp bindings to OpenSSL") + (list sbcl-alexandria sbcl-closer-mop)) + (native-inputs + (list sbcl-rt)) + (synopsis "Delimited continuations for Common Lisp") (description - "This library is a fork of SSL-CMUCL. The original SSL-CMUCL source -code was written by Eric Marsden and includes contributions by Jochen Schmidt. -Development into CL+SSL was done by David Lichteblau.") - (license license:expat)))) + "This is a library that implements delimited continuations by +transforming Common Lisp code to continuation passing style.") + (home-page "https://common-lisp.net/project/cl-cont/") + (license license:llgpl)))) -(define-public cl-cl+ssl - (sbcl-package->cl-source-package sbcl-cl+ssl)) +(define-public cl-cont + (sbcl-package->cl-source-package sbcl-cl-cont)) -(define-public ecl-cl+ssl - ;; The trivial-sockets system used for the tests doesn't support ECL, so we - ;; remove it from native-inputs and disable the tests. - (let ((pkg (sbcl-package->ecl-package sbcl-cl+ssl))) - (package - (inherit pkg) - (native-inputs - (modify-inputs (package-native-inputs pkg) - (delete "sbcl-trivial-sockets"))) - (arguments - (substitute-keyword-arguments (package-arguments pkg) - ((#:tests? _ #f) #f)))))) +(define-public ecl-cl-cont + (sbcl-package->ecl-package sbcl-cl-cont)) -(define-public sbcl-kons-9 - (let ((commit "fe0b3228ca28c316457d35f9e7c67edc83b2a4cc") - (revision "0")) +(define-public sbcl-cl-containers + (let ((commit "781ebfe0888bae46f07c018f7d473898b1bd4f5f") + (revision "4")) (package - (name "sbcl-kons-9") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-cl-containers") + (version (git-version "0.12.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/kaveh808/kons-9") + (url "https://github.com/hraban/cl-containers") (commit commit))) - (file-name (git-file-name "cl-kons-9" version)) + (file-name (git-file-name "cl-containers" version)) (sha256 - (base32 "1kdwva4qj1s5vmbv6gbmpnk56ahaf8n2kvij5xjlfyk7nriy4bbi")))) + (base32 + "1nrql8s1j123v5gscy99lxvhlzp0ijig9x94w30v3lwfa58hf90l")))) (build-system asdf-build-system/sbcl) - (arguments - `(#:asd-systems '("kons-9") - #:asd-test-systems '("kons-9/testsuite"))) (native-inputs - (list sbcl-alexandria sbcl-confidence)) + (list sbcl-lift)) (inputs - (list sbcl-closer-mop - sbcl-cffi - sbcl-cl-glfw3 - sbcl-cl-opengl - sbcl-cl-vectors - sbcl-clobber - sbcl-origin - sbcl-trivial-backtrace - sbcl-trivial-main-thread - sbcl-zpb-ttf)) - (home-page "https://github.com/kaveh808/kons-9") - (synopsis "Common Lisp 3D graphics system") + (list sbcl-asdf-system-connections + sbcl-metatilities-base + sbcl-moptilities)) + (arguments + '(#:asd-systems '("cl-containers" + "cl-containers/with-moptilities" + "cl-containers/with-utilities") + #:phases + (modify-phases %standard-phases + (add-after 'unpack 'relax-version-checks + (lambda _ + (substitute* "cl-containers.asd" + (("\\(:version \"metatilities-base\" \"0\\.6\\.6\"\\)") + "\"metatilities-base\"")) + (substitute* "cl-containers-test.asd" + (("\\(:version \"lift\" \"1\\.7\\.0\"\\)") + "\"lift\"")) + #t))))) + (synopsis "Container library for Common Lisp") (description - "This package provides KONS-9 which can be considered as a traditional user -interface driven 3D application for general artists, or as a REPL-based -development environment for technical artists and software developers. These two -approaches can be seamlessly combined into a flexible and powerful workflow, -where non-technical users can immediately benefit from software tools and -extensions developed by technical users.") - (license (list license:expat - ;; lib/JMC-font-libs/font-master - ;; lib/JMC-font-libs/font-zpb-ttf-master - license:lgpl2.1))))) + "Common Lisp ships with a set of powerful built in data structures +including the venerable list, full featured arrays, and hash-tables. +CL-containers enhances and builds on these structures by adding containers +that are not available in native Lisp (for example: binary search trees, +red-black trees, sparse arrays and so on), and by providing a standard +interface so that they are simpler to use and so that changing design +decisions becomes significantly easier.") + (home-page "https://common-lisp.net/project/cl-containers/") + (license license:expat)))) -(define-public cl-kons-9 - (sbcl-package->cl-source-package sbcl-kons-9)) +(define-public cl-containers + (sbcl-package->cl-source-package sbcl-cl-containers)) -;; TODO: (Sharlatan-20221110T230620+0000): ECL is not supported yet. -;; https://github.com/kaveh808/kons-9/issues/176 -;; (define-public ecl-kons-9 -;; (sbcl-package->ecl-package sbcl-kons-9)) +(define-public ecl-cl-containers + (sbcl-package->ecl-package sbcl-cl-containers)) -(define-public sbcl-kmrcl - (let ((version "1.111") - (commit "4a27407aad9deb607ffb8847630cde3d041ea25a") +(define-public sbcl-cl-cookie + (let ((commit "cea55aed8b9ad25fafd13defbcb9fe8f41b29546") (revision "1")) (package - (name "sbcl-kmrcl") - (version (git-version version revision commit)) + (name "sbcl-cl-cookie") + (build-system asdf-build-system/sbcl) + (version (git-version "0.9.10" revision commit)) + (home-page "https://github.com/fukamachi/cl-cookie") (source (origin (method git-fetch) (uri (git-reference - (url "http://git.kpe.io/kmrcl.git/") + (url home-page) (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 "06gx04mah5nc8w78s0j8628divbf1s5w7af8w7pvzb2d5mgvrbd2")) - (modules '((guix build utils))) - (snippet - ;; The useless bundled debian folder drags `make' into the closure. - `(begin - (delete-file-recursively "debian") - #t)))) - (build-system asdf-build-system/sbcl) + (base32 + "090g7z75h98zvc1ldx0vh4jn4086dhjm2w30jcwkq553qmyxwl8h")))) (inputs - (list sbcl-rt)) - (home-page "http://files.kpe.io/kmrcl/") - (synopsis "General utilities for Common Lisp programs") - (description - "KMRCL is a collection of utilities used by a number of Kevin -Rosenberg's Common Lisp packages.") - (license license:llgpl)))) + `(("proc-parse" ,sbcl-proc-parse) + ("alexandria" ,sbcl-alexandria) + ("quri" ,sbcl-quri) + ("cl-ppcre" ,sbcl-cl-ppcre) + ("local-time" ,sbcl-local-time))) + (native-inputs + (list sbcl-prove)) + (arguments + '(#:asd-systems '("cl-cookie-test" "cl-cookie"))) + (synopsis "HTTP cookie manager for Common Lisp") + (description "cl-cookie is a Common Lisp library featuring parsing of +cookie headers, cookie creation, cookie jar creation and more.") + (license license:bsd-2)))) -(define-public cl-kmrcl - (sbcl-package->cl-source-package sbcl-kmrcl)) +(define-public cl-cookie + (sbcl-package->cl-source-package sbcl-cl-cookie)) -(define-public ecl-kmrcl - (sbcl-package->ecl-package sbcl-kmrcl)) +(define-public ecl-cl-cookie + (sbcl-package->ecl-package sbcl-cl-cookie)) -(define-public sbcl-cl-base64 - (let ((commit "577683b18fd880b82274d99fc96a18a710e3987a")) +(define-public sbcl-cl-coroutine + (let ((commit "de098f8d5debd8b14ef6864b5bdcbbf5ddbcfd72") + (revision "1")) (package - (name "sbcl-cl-base64") - (version (git-version "3.3.4" "1" commit)) + (name "sbcl-cl-coroutine") + (version (git-version "0.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "http://git.kpe.io/cl-base64.git/") + (url "https://github.com/takagi/cl-coroutine") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 "12jj54h0fs6n237cvnp8v6hn0imfksammq22ys6pi0gwz2w47rbj")) - (modules '((guix build utils))) - (snippet - ;; The useless bundled debian folder drags `make' into the closure. - `(begin - (delete-file-recursively "debian") - #t)))) + (base32 + "1cqdhdjxffgfs116l1swjlsmcbly0xgcgrckvaajd566idj9yj4l")))) (build-system asdf-build-system/sbcl) - (native-inputs ; For tests. - (list sbcl-ptester sbcl-kmrcl)) - (home-page "http://files.kpe.io/cl-base64/") - (synopsis - "Common Lisp package to encode and decode base64 with URI support") + (inputs + `(("alexandria" ,sbcl-alexandria) + ("cl-cont" ,sbcl-cl-cont))) + (native-inputs + (list sbcl-prove)) + (arguments + `(;; TODO: Fix the tests. They fail with: + ;; "Component CL-COROUTINE-ASD::CL-COROUTINE-TEST not found" + #:tests? #f + #:phases + (modify-phases %standard-phases + (add-after 'unpack 'fix-tests + (lambda _ + (substitute* "cl-coroutine-test.asd" + (("cl-test-more") + "prove")) + #t))))) + (synopsis "Coroutine library for Common Lisp") (description - "This package provides highly optimized base64 encoding and decoding. -Besides conversion to and from strings, integer conversions are supported. -Encoding with Uniform Resource Identifiers is supported by using a modified -encoding table that uses only URI-compatible characters.") - (license license:bsd-3)))) + "This is a coroutine library for Common Lisp implemented using the +continuations of the @code{cl-cont} library.") + (home-page "https://github.com/takagi/cl-coroutine") + (license license:llgpl)))) -(define-public cl-base64 - (sbcl-package->cl-source-package sbcl-cl-base64)) +(define-public cl-coroutine + (sbcl-package->cl-source-package sbcl-cl-coroutine)) -(define-public ecl-cl-base64 - (sbcl-package->ecl-package sbcl-cl-base64)) +(define-public ecl-cl-coroutine + (sbcl-package->ecl-package sbcl-cl-coroutine)) -(define-public sbcl-chunga +(define-public sbcl-cl-cpus (package - (name "sbcl-chunga") - (version "1.1.7") + (name "sbcl-cl-cpus") + (version "0.0.3") (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/edicl/chunga") - (commit (string-append "v" version)))) - (file-name (git-file-name name version)) + (url "https://github.com/muyinliu/cl-cpus") + (commit (string-append "v" version)))) + (file-name (git-file-name "cl-cpus" version)) (sha256 - (base32 "0jzn3nyb3f22gm983rfk99smqs3mhb9ivjmasvhq9qla5cl9pyhd")))) + (base32 "0sdaff9hpsx7bpkkkqavmxmrrlc2d61gmqjjgn8xchncng4a0rf8")))) (build-system asdf-build-system/sbcl) (inputs - (list sbcl-trivial-gray-streams)) - (home-page "https://edicl.github.io/chunga/") - (synopsis "Portable chunked streams for Common Lisp") + (list sbcl-cffi)) + (home-page "https://github.com/muyinliu/cl-cpus") + (synopsis "Common Lisp feature to get number of CPUs") (description - "Chunga implements streams capable of chunked encoding on demand as -defined in RFC 2616.") - (license license:bsd-2))) + "This package provides a Common Lisp system which has only one function to +return the CPU count of the current system.") + (license license:isc))) -(define-public cl-chunga - (sbcl-package->cl-source-package sbcl-chunga)) +(define-public cl-cpus + (sbcl-package->cl-source-package sbcl-cl-cpus)) -(define-public ecl-chunga - (sbcl-package->ecl-package sbcl-chunga)) +(define-public ecl-cl-cpus + (sbcl-package->ecl-package sbcl-cl-cpus)) -(define-public sbcl-cl-who - (let ((version "1.1.4") - (commit "07dafe9b351c32326ce20b5804e798f10d4f273d") - (revision "3")) +(define-public sbcl-cl-cron + (let ((commit "092aef5d5666fb43c04258e4043f609670a20456") + (revision "0")) (package - (name "sbcl-cl-who") - (version (git-version version revision commit)) + (name "sbcl-cl-cron") + (version (git-version "0.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/edicl/cl-who") + (url "https://github.com/ciel-lang/cl-cron") (commit commit))) - (file-name (git-file-name "cl-who" version)) + (file-name (git-file-name "cl-cron" version)) (sha256 - (base32 - "1rdvs113q6d46cblwhsv1vmm31p952wyzkyibqix0ypadpczlgp5")))) + (base32 "0y4li8j2h1nbpldpqm39ld9kgs4a7biy94h49n27l59l7mn1jd0d")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-flexi-streams)) - (home-page "https://edicl.github.io/cl-who/") - (synopsis "Yet another Lisp markup language") + (inputs + (list sbcl-bordeaux-threads)) + (home-page "https://github.com/ciel-lang/cl-cron/") + (synopsis "Run cron like jobs in Common Lisp") (description - "There are plenty of Lisp Markup Languages out there - every Lisp -programmer seems to write at least one during his career - and CL-WHO (where -WHO means \"with-html-output\" for want of a better acronym) is probably just -as good or bad as the next one.") - (license license:bsd-2)))) + "@code{cl-cron} is a simple tool that provides cron like facilities +directly inside of Common Lisp.") + (license license:gpl3+)))) -(define-public cl-who - (sbcl-package->cl-source-package sbcl-cl-who)) +(define-public cl-cron + (sbcl-package->cl-source-package sbcl-cl-cron)) -(define-public ecl-cl-who - (sbcl-package->ecl-package sbcl-cl-who)) +(define-public ecl-cl-cron + (sbcl-package->ecl-package sbcl-cl-cron)) -(define-public sbcl-chipz - (let ((version "0.8") - (commit "82a17d39c78d91f6ea63a03aca8f9aa6069a5e11") - (revision "2")) +(define-public sbcl-cl-css + (let ((commit "8fe654c8f0cf95b300718101cce4feb517f78e2f")) (package - (name "sbcl-chipz") - (version (git-version version revision commit)) + (name "sbcl-cl-css") + (version (git-version "0.1" "1" commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/sharplispers/chipz") + (url "https://github.com/inaimathi/cl-css/") (commit commit))) - (file-name (git-file-name "cl-chipz" version)) + (file-name (git-file-name "cl-css" version)) (sha256 - (base32 "1n4f22i9j8iapjd6yx1z348rggcybvg9h794kx9libjgz4bs371h")))) + (base32 + "1lc42zi2sw11fl2589sc19nr5sd2p0wy7wgvgwaggxa5f3ajhsmd")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-flexi-streams)) - (home-page "http://method-combination.net/lisp/chipz/") - (synopsis - "Common Lisp library for decompressing deflate, zlib, gzip, and bzip2 -data") + (home-page "https://github.com/inaimathi/cl-css/") + (synopsis "Non-validating, inline CSS generator for Common Lisp") (description - "DEFLATE data, defined in RFC1951, forms the core of popular -compression formats such as zlib (RFC 1950) and gzip (RFC 1952). As such, -Chipz also provides for decompressing data in those formats as well. BZIP2 is -the format used by the popular compression tool bzip2.") - ;; The author describes it as "MIT-like" + "This is a dead-simple, non validating, inline CSS generator for Common +Lisp. Its goals are axiomatic syntax, simple implementation to support +portability, and boilerplate reduction in CSS.") (license license:expat)))) -(define-public cl-chipz - (sbcl-package->cl-source-package sbcl-chipz)) - -(define-public ecl-chipz - (sbcl-package->ecl-package sbcl-chipz)) - -(define-public sbcl-cl-tls - (let ((commit "2ab4fc3ae7e79e451126a9bb6bc38ca2cd2cb4ba") - (revision "0")) - (package - (name "sbcl-cl-tls") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/shrdlu68/cl-tls") - (commit commit))) - (file-name (git-file-name "cl-tls" version)) - (sha256 - (base32 "1j6gwv21ibkk6xd1xxm54wgwp09dzqg60b8z72hivpnq8gwm0ba7")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-alexandria - sbcl-babel - sbcl-cl-base64 - sbcl-fast-io - sbcl-ironclad)) - (home-page "https://github.com/shrdlu68/cl-tls") - (synopsis "Implementation of Transport Layer Security Protocols") - (description "This package provides prototype Common Lisp -implementations of TLS, RFC5246, ASN.1, x{501,509}, and PKCS{1,3,5,8}.") - (license license:bsd-3)))) - -(define-public cl-tls - (sbcl-package->cl-source-package sbcl-cl-tls)) +(define-public cl-css + (sbcl-package->cl-source-package sbcl-cl-css)) -(define-public ecl-cl-tls - (sbcl-package->ecl-package sbcl-cl-tls)) +(define-public ecl-cl-css + (sbcl-package->ecl-package sbcl-cl-css)) -(define-public sbcl-dns-client - (let ((commit "9f252e9c2bb61c57a6cd367e21ad366b0d3e87e0") - (revision "0")) +(define-public sbcl-cl-csv + (let ((commit "68ecb5d816545677513d7f6308d9e5e8d2265651") + (revision "2")) (package - (name "sbcl-dns-client") - (version (git-version "1.0.0" revision commit)) + (name "sbcl-cl-csv") + (version (git-version "1.0.6" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/Shinmera/dns-client") + (url "https://github.com/AccelerationNet/cl-csv") (commit commit))) - (file-name (git-file-name "cl-dns-client" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "1b6g2wvydwmv1k68favjyq4gfalfxfyl5i0hyh640wdaz2rfvi4n")))) + (base32 + "0gcmlbwx5m3kwgk12qi80w08ak8fgdnvyia429fz6gnxmhg0k54x")))) (build-system asdf-build-system/sbcl) (arguments - ;; No tests provided. + ;; See: https://github.com/AccelerationNet/cl-csv/pull/34 `(#:tests? #f)) (inputs - (list sbcl-documentation-utils sbcl-usocket)) - (home-page "https://shinmera.github.io/dns-client/") - (synopsis "DNS protocol client for Common Lisp") + `(("alexandria" ,sbcl-alexandria) + ("cl-interpol" ,sbcl-cl-interpol) + ("iterate" ,sbcl-iterate))) + (native-inputs + (list sbcl-lisp-unit2)) + (synopsis "Common lisp library for comma-separated values") (description - "This package provides a pure-lisp implementation of a DNS client. It can be -used to resolve hostnames, reverse-lookup IP addresses, and fetch other kinds of -DNS records.") - (license license:zlib)))) - -(define-public ecl-dns-client - (sbcl-package->ecl-package sbcl-dns-client)) - -(define-public cl-dns-client - (sbcl-package->cl-source-package sbcl-dns-client)) - -(define-public sbcl-lisp-pay - (let ((commit "c4de776f0a284709931ff3674160ced3b41bd000") - (revision "0")) - (package - (name "sbcl-lisp-pay") - (version (git-version "0.0.5" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/K1D77A/lisp-pay") - (commit commit))) - (file-name (git-file-name "cl-lisp-pay" version)) - (sha256 - (base32 "09r6qy4fipriqa0d6g9qm6dq992lr58vh24g5j0adm19i5fnjavh")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-alexandria - sbcl-babel - sbcl-cl-base64 - sbcl-cl-str - sbcl-cl-tls - sbcl-closer-mop - sbcl-dexador - sbcl-hu.dwim.defclass-star - sbcl-hunchentoot - sbcl-ironclad - sbcl-jonathan - sbcl-lack - sbcl-ningle - sbcl-shasht)) - (home-page "https://github.com/K1D77A/lisp-pay/") - (synopsis "Wrappers over multiple Payment Processor APIs") - (description "This library provides payment API wrappers over -BTCPay, Paypal, and Stripe.") - (license license:expat)))) + "This is a Common Lisp library providing functions to read/write CSV +from/to strings, streams and files.") + (home-page "https://github.com/AccelerationNet/cl-csv") + (license license:bsd-3)))) -(define-public cl-lisp-pay - (sbcl-package->cl-source-package sbcl-lisp-pay)) +(define-public cl-csv + (sbcl-package->cl-source-package sbcl-cl-csv)) -(define-public ecl-lisp-pay - (sbcl-package->ecl-package sbcl-lisp-pay)) +(define-public ecl-cl-csv + (sbcl-package->ecl-package sbcl-cl-csv)) -(define-public sbcl-stripe - (let ((commit "b59631d21d63e101de6eb96b56941471504ba644") - (revision "0")) +(define-public sbcl-cl-debug + (let ((commit "b334280806104ee7f7d3aec666bf7e08d2f89b31") + (revision "1")) (package - (name "sbcl-stripe") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/atlas-engineer/stripe") - (commit commit))) - (file-name (git-file-name "cl-stripe" version)) - (sha256 - (base32 "00sfq2f6dnpwa6pf7rgw5hazbwx4yf1g0jrkfz9h4kq5zyxwk1cy")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-dexador - sbcl-golden-utils - sbcl-local-time - sbcl-yason)) - (home-page "https://github.com/atlas-engineer/stripe") - (synopsis "Stripe payment API client for Common Lisp") - (description "A client for the Stripe payment API.") - (license license:expat)))) - -(define-public cl-stripe - (sbcl-package->cl-source-package sbcl-stripe)) - -(define-public ecl-stripe - (sbcl-package->ecl-package sbcl-stripe)) - -(define-public sbcl-drakma - (package - (name "sbcl-drakma") - (version "2.0.8") - (source - (origin + (name "sbcl-cl-debug") + (version (git-version "1.0.0" revision commit)) + (source + (origin (method git-fetch) (uri (git-reference - (url "https://github.com/edicl/drakma") - (commit (string-append "v" version)))) - (file-name (git-file-name "cl-drakma" version)) + (url "https://github.com/kmx-io/cl-debug") + (commit commit))) + (file-name (git-file-name "cl-debug" version)) (sha256 - (base32 - "1wf2zivfvhsh6zvd6wcwfd67bm8s8a1p2fismszc8xb819dqk9yl")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-puri - sbcl-cl-base64 - sbcl-chunga - sbcl-flexi-streams - sbcl-cl-ppcre - sbcl-chipz - sbcl-usocket - sbcl-cl+ssl)) - (native-inputs - (list sbcl-fiveam)) - (home-page "https://edicl.github.io/drakma/") - (synopsis "HTTP client written in Common Lisp") - (description - "Drakma is a full-featured HTTP client implemented in Common Lisp. It -knows how to handle HTTP/1.1 chunking, persistent connections, re-usable -sockets, SSL, continuable uploads, file uploads, cookies, and more.") - (license license:bsd-2))) + (base32 "0w5vxbjsgr3zfpivdmghmhzxskfdvm1p34c8whwps2xlhypxsa78")))) + (build-system asdf-build-system/sbcl) + (home-page "https://github.com/kmx-io/cl-debug") + (synopsis "Common Lisp cross-package debugging facility") + (description + "CL-DEBUG provides a unified way to enable or disable debug-specific code. +Debugging code can be enabled or disabled relative to program features denoted +by either a symbol or a keyword.") + (license license:isc)))) -(define-public cl-drakma - (sbcl-package->cl-source-package sbcl-drakma)) +(define-public cl-debug + (sbcl-package->cl-source-package sbcl-cl-debug)) -(define-public ecl-drakma - (sbcl-package->ecl-package sbcl-drakma)) +(define-public ecl-cl-debug + (sbcl-package->ecl-package sbcl-cl-debug)) -(define-public sbcl-hunchentoot - ;; NOTE: (Sharlatan-20220520T213309+0100): The latest commit fixed tests, - ;; switch to the version tag when release is ready. - (let ((commit "76862391040c20255c7275e815c2175e46bfd080") +(define-public sbcl-cl-dejavu + (let ((commit "9d68ced4edee6f96fead42cb4835d0ff4a158373") (revision "1")) (package - (name "sbcl-hunchentoot") - (version (git-version "1.3.0" revision commit)) + (name "sbcl-cl-dejavu") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/edicl/hunchentoot") + (url "https://github.com/dkochmanski/cl-dejavu") (commit commit))) - (file-name (git-file-name "cl-hunchentoot" version)) + (file-name (git-file-name "cl-dejavu" version)) (sha256 - (base32 "1h7ggmmzvgwr4p6j3ai0dqrw30q5309l13w4c03gqrapvwrb65l0")))) + (base32 "1lbxiq21bxj8r11c58cqskgn8gnl2p8q1ydkhdsv7i7xnhv2y7r0")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-cl-who sbcl-drakma)) - (inputs - (list sbcl-chunga - sbcl-cl-base64 - sbcl-cl-fad - sbcl-cl-ppcre - sbcl-flexi-streams - sbcl-cl+ssl - sbcl-md5 - sbcl-rfc2388 - sbcl-trivial-backtrace - sbcl-usocket)) - (home-page "https://edicl.github.io/hunchentoot/") - (synopsis "Web server written in Common Lisp") + (home-page "https://github.com/dkochmanski/cl-dejavu") + (synopsis "DejaVu fonts for Common Lisp") (description - "Hunchentoot is a web server written in Common Lisp and at the same -time a toolkit for building dynamic websites. As a stand-alone web server, -Hunchentoot is capable of HTTP/1.1 chunking (both directions), persistent -connections (keep-alive), and SSL.") - (license license:bsd-2)))) + "This is a repackage of the original DejaVu Fonts with some convenience +functions.") + (license (list license:cc0 + (license:x11-style "http://dejavu-fonts.org/")))))) -(define-public cl-hunchentoot - (sbcl-package->cl-source-package sbcl-hunchentoot)) +(define-public cl-dejavu + (sbcl-package->cl-source-package sbcl-cl-dejavu)) -(define-public ecl-hunchentoot - (package - (inherit (sbcl-package->ecl-package sbcl-hunchentoot)) - (arguments - ;; Tests fail on ECL with 'Socket error in "socket": EINVAL'. - '(#:tests? #f)))) +(define-public ecl-dejavu + (sbcl-package->ecl-package sbcl-cl-dejavu)) -(define-public sbcl-hunchentoot-errors - (let ((commit "69eb3bcea59ed1ccf3dd1960e6d48fb21f1dadab") +(define-public sbcl-cl-difflib + (let ((commit "98eb335c693f1881584b83ca7be4a0fe05355c4e") (revision "0")) (package - (name "sbcl-hunchentoot-errors") - (version (git-version "0.0.1" revision commit)) + (name "sbcl-cl-difflib") + (version (git-version "0.2" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/mmontone/hunchentoot-errors") + (url "https://github.com/wiseman/cl-difflib") (commit commit))) - (file-name (git-file-name "cl-hunchentoot-errors" version)) + (file-name + (git-file-name name version)) (sha256 - (base32 "0fab7s8qhhs713cw014qqvzm5z61wmxm2fcbkarhg41cz3li9k1j")))) + (base32 "08if0abhqg191xcz9s7xv8faqq51nswzp8hw423fkqjzr24pmq48")))) (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-cl-mimeparse - sbcl-hunchentoot - sbcl-parse-number - sbcl-string-case)) - (home-page "https://github.com/mmontone/hunchentoot-errors/") - (synopsis "Hunchentoot error pages and logs with request and session information") + ;; Due to the age of this library tests use some deprecated + ;; functionality and keep failing. + (arguments + '(#:tests? #f)) + (home-page "https://github.com/wiseman/cl-difflib") + (synopsis "Compute differences between pairs of sequences") (description - "This package provides a functionality augmenting Hunchentoot error -pages and logs with request and session information.") - (license license:expat)))) - -(define-public cl-hunchentoot-errors - (sbcl-package->cl-source-package sbcl-hunchentoot-errors)) - -(define-public ecl-hunchentoot-errors - (sbcl-package->ecl-package sbcl-hunchentoot-errors)) - -(define-public sbcl-lunamech-matrix-api - (let ((commit "aa54a820149584c237b03d500ad83397fe25dc92") - (revision "0")) - (package - (name "sbcl-lunamech-matrix-api") - (version (git-version "0.0.2" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/K1D77A/lunamech-matrix-api") - (commit commit))) - (file-name (git-file-name "cl-lunamech-matrix-api" version)) - (sha256 - (base32 "0a664qq4m5gk4iv5ck63gmsl3218jhjsalawklj56wn2pw0cf8a0")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-cl-json - sbcl-cl-str - sbcl-closer-mop - sbcl-dexador - sbcl-do-urlencode - sbcl-drakma - sbcl-jonathan - sbcl-plump - sbcl-quri - sbcl-reader - sbcl-shasht)) - (home-page "https://github.com/K1D77A/lunamech-matrix-api/") - (synopsis "Implementation of the Matrix API") - (description "This package provides an implementation of the Matrix -API for Common Lisp.") + "A Common Lisp library for computing differences between +sequences based on the Python difflib module.") (license license:expat)))) -(define-public cl-lunamech-matrix-api - (sbcl-package->cl-source-package sbcl-lunamech-matrix-api)) - -(define-public ecl-lunamech-matrix-api - (sbcl-package->ecl-package sbcl-lunamech-matrix-api)) - -(define-public sbcl-trivial-types - (package - (name "sbcl-trivial-types") - (version "0.0.1") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/m2ym/trivial-types") - (commit "ee869f2b7504d8aa9a74403641a5b42b16f47d88"))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1s4cp9bdlbn8447q7w7f1wkgwrbvfzp20mgs307l5pxvdslin341")))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/m2ym/trivial-types") - (synopsis "Trivial type definitions for Common Lisp") - (description - "TRIVIAL-TYPES provides missing but important type definitions such as -PROPER-LIST, ASSOCIATION-LIST, PROPERTY-LIST and TUPLE.") - (license license:llgpl))) - -(define-public cl-trivial-types - (sbcl-package->cl-source-package sbcl-trivial-types)) +(define-public cl-difflib + (sbcl-package->cl-source-package sbcl-cl-difflib)) -(define-public ecl-trivial-types - (sbcl-package->ecl-package sbcl-trivial-types)) +(define-public ecl-cl-difflib + (sbcl-package->ecl-package sbcl-cl-difflib)) -(define-public sbcl-cl-annot - (let ((commit "c99e69c15d935eabc671b483349a406e0da9518d") +(define-public sbcl-cl-diskspace + (let ((commit "2dce2d0387d58221c452bd76c7b9b7a7de81ef55") (revision "1")) (package - (name "sbcl-cl-annot") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-cl-diskspace") + (version (git-version "0.3.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/m2ym/cl-annot") + (url "https://github.com/muyinliu/cl-diskspace") (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1wq1gs9jjd5m6iwrv06c2d7i5dvqsfjcljgbspfbc93cg5xahk4n")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-alexandria)) - (home-page "https://github.com/m2ym/cl-annot") - (synopsis "Python-like Annotation Syntax for Common Lisp") - (description - "@code{cl-annot} is an general annotation library for Common Lisp.") - (license license:llgpl)))) - -(define-public cl-annot - (sbcl-package->cl-source-package sbcl-cl-annot)) - -(define-public ecl-cl-annot - (sbcl-package->ecl-package sbcl-cl-annot)) - -(define-public sbcl-cl-syntax - (package - (name "sbcl-cl-syntax") - (version "0.0.3") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/m2ym/cl-syntax") - (commit "03f0c329bbd55b8622c37161e6278366525e2ccc"))) - (file-name (git-file-name "cl-syntax" version)) - (sha256 - (base32 "17ran8xp77asagl31xv8w819wafh6whwfc9p6dgx22ca537gyl4y")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("cl-annot" ,sbcl-cl-annot) - ("cl-interpol" ,sbcl-cl-interpol) - ("named-readtables" ,sbcl-named-readtables) - ("trivial-types" ,sbcl-trivial-types))) - (arguments - '(#:asd-systems '("cl-syntax" - "cl-syntax-annot" - "cl-syntax-interpol"))) - (home-page "https://github.com/m2ym/cl-syntax") - (synopsis "Reader Syntax Coventions for Common Lisp and SLIME") - (description - "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp and SLIME.") - (license license:llgpl))) - -(define-public cl-syntax - (sbcl-package->cl-source-package sbcl-cl-syntax)) - -(define-public ecl-cl-syntax - (sbcl-package->ecl-package sbcl-cl-syntax)) - -(define-public sbcl-cl-utilities - (let ((commit "dce2d2f6387091ea90357a130fa6d13a6776884b") - (revision "1")) - (package - (name "sbcl-cl-utilities") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method url-fetch) - (uri - (string-append - "https://gitlab.common-lisp.net/cl-utilities/cl-utilities/-/" - "archive/" commit "/cl-utilities-" commit ".tar.gz")) + (file-name (git-file-name "cl-diskspace" version)) (sha256 - (base32 "1r46v730yf96nk2vb24qmagv9x96xvd08abqwhf02ghgydv1a7z2")))) + (base32 "0l19hxqw6b8i5i1jdbr45k1xib9axcwdagsp3y8wkb35g6wwc0s7")))) (build-system asdf-build-system/sbcl) (arguments - '(#:phases + `(#:phases (modify-phases %standard-phases (add-after 'unpack 'fix-paths (lambda* (#:key inputs #:allow-other-keys) - (substitute* "rotate-byte.lisp" - (("in-package :cl-utilities)" all) - "in-package :cl-utilities)\n\n#+sbcl\n(require :sb-rotate-byte)"))))))) - (home-page "https://common-lisp.net/project/cl-utilities") - (synopsis "Collection of semi-standard utilities") + (substitute* "src/unix/cl-diskspace-list-all-disks-with-df.lisp" + (("grep") + (search-input-file inputs "/bin/grep"))) + (substitute* "src/unix/cl-diskspace-list-all-disks-with-df.lisp" + (("/bin/df") + (which "df"))) + #t))))) + (inputs + `(("cl-ppcre" ,sbcl-cl-ppcre) + ("cffi" ,sbcl-cffi) + ("grep" ,grep))) + (home-page "https://github.com/muyinliu/cl-diskspace") + (synopsis "Disk space information library for Common Lisp") (description - "On Cliki.net <http://www.cliki.net/Common%20Lisp%20Utilities>, there -is a collection of Common Lisp Utilities, things that everybody writes since -they're not part of the official standard. There are some very useful things -there; the only problems are that they aren't implemented as well as you'd -like (some aren't implemented at all) and they aren't conveniently packaged -and maintained. It takes quite a bit of work to carefully implement utilities -for common use, commented and documented, with error checking placed -everywhere some dumb user might make a mistake.") - (license license:public-domain)))) + "CL-DISKSPACE is a Common Lisp library to list disks with the command +line tool @code{df} and get disk space information using @code{statvfs}.") + (license license:isc)))) -(define-public cl-utilities - (sbcl-package->cl-source-package sbcl-cl-utilities)) +(define-public cl-diskspace + (sbcl-package->cl-source-package sbcl-cl-diskspace)) -(define-public ecl-cl-utilities - (sbcl-package->ecl-package sbcl-cl-utilities)) +(define-public ecl-cl-diskspace + (sbcl-package->ecl-package sbcl-cl-diskspace)) -(define-public sbcl-map-set - (let ((commit "7b4b545b68b8") +(define-public sbcl-cl-docutils + (let ((commit "756b5ad42360e84d8225fa69815bdd1623ceaa40") (revision "1")) (package - (name "sbcl-map-set") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-cl-docutils") + (version (git-version "0.1.1" revision commit)) (source (origin - (method url-fetch) - (uri (string-append - "https://bitbucket.org/tarballs_are_good/map-set/get/" - commit ".tar.gz")) + (method git-fetch) + (uri + (git-reference + (url "https://github.com/willijar/cl-docutils/") + (commit commit))) + (file-name (git-file-name "cl-docutils" version)) (sha256 - (base32 "1sx5j5qdsy5fklspfammwb16kjrhkggdavm922a9q86jm5l0b239")))) + (base32 + "132bxlj0jlhiabi29mygmkcbbgyb5s1yz1xdfhm3pgrf9f8605gg")))) (build-system asdf-build-system/sbcl) - (home-page "https://bitbucket.org/tarballs_are_good/map-set") - (synopsis "Set-like data structure") + (arguments + '(#:asd-systems '("docutils"))) + (inputs + (list sbcl-cl-ppcre + sbcl-data-format-validation + sbcl-trivial-gray-streams)) + (synopsis "Document utilities and Restructured text parser") (description - "Implementation of a set-like data structure with constant time -addition, removal, and random selection.") - (license license:bsd-3)))) - -(define-public cl-map-set - (sbcl-package->cl-source-package sbcl-map-set)) - -(define-public ecl-map-set - (sbcl-package->ecl-package sbcl-map-set)) - -(define-public sbcl-quri - (package - (name "sbcl-quri") - (version "0.7.0") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/fukamachi/quri") - (commit version))) - (file-name (git-file-name name version)) - (sha256 - (base32 "0l1jnvvkyaxbf08lnqfdbv6lrkq02iqr3y3rwvqxm4fvnzp7mnpz")))) - (build-system asdf-build-system/sbcl) - (native-inputs (list sbcl-prove)) - (inputs (list sbcl-babel sbcl-split-sequence sbcl-cl-utilities - sbcl-alexandria)) - (home-page "https://github.com/fukamachi/quri") - (synopsis "Yet another URI library for Common Lisp") - (description - "QURI (pronounced \"Q-ree\") is yet another URI library for Common -Lisp. It is intended to be a replacement of PURI.") - (license license:bsd-3))) - -(define-public cl-quri - (sbcl-package->cl-source-package sbcl-quri)) - -(define-public ecl-quri - (sbcl-package->ecl-package sbcl-quri)) - -(define-public sbcl-myway - (let ((commit "286230082a11f879c18b93f17ca571c5f676bfb7") - (revision "1")) - (package - (name "sbcl-myway") - (version (git-version "0.1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/fukamachi/myway") - (commit commit))) - (file-name (git-file-name "myway" version)) - (sha256 - (base32 "0briia9bk3lbr0frnx39d1qg6i38dm4j6z9w3yga3d40k6df4a90")))) - (build-system asdf-build-system/sbcl) - (arguments - '(#:asd-systems '("myway-test" "myway"))) - (native-inputs - (list sbcl-prove)) - (inputs - (list sbcl-cl-ppcre sbcl-quri sbcl-map-set)) - (home-page "https://github.com/fukamachi/myway") - (synopsis "Sinatra-compatible URL routing library for Common Lisp") - (description "My Way is a Sinatra-compatible URL routing library.") - (license license:llgpl)))) - -(define-public cl-myway - (sbcl-package->cl-source-package sbcl-myway)) - -(define-public ecl-myway - (sbcl-package->ecl-package sbcl-myway)) - -(define-public sbcl-xsubseq - (let ((commit "5ce430b3da5cda3a73b9cf5cee4df2843034422b") - (revision "1")) - (package - (name "sbcl-xsubseq") - (version (git-version "0.0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/fukamachi/xsubseq") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1xz79q0p2mclf3sqjiwf6izdpb6xrsr350bv4mlmdlm6rg5r99px")))) - (build-system asdf-build-system/sbcl) - (arguments - '(#:asd-systems '("xsubseq-test" "xsubseq"))) - (native-inputs - (list sbcl-prove)) - (home-page "https://github.com/fukamachi/xsubseq") - (synopsis "Efficient way to use \"subseq\"s in Common Lisp") - (description - "XSubseq provides functions to be able to handle \"subseq\"s more -effieiently.") - (license license:bsd-2)))) + "@code{cl-docutils} is a Common Lisp implementation of the Docutils text +processing system for processing plaintext into presentational formats such as +HTML and LaTeX. It is based upon the Python Docutils reference implementation +but uses Common Lisp idioms making it easier to extend and more flexible. As +with the reference implementation it includes a parser for the reStructured +text plaintext markup syntax which is suitable for marking up documentation +and for use as user markup for collaborative web sites. It is successfully +used to support a higher education peer-review assessment and online tutorial +system.") + (home-page "http://www.jarw.org.uk/lisp/cl-docutils.html") + (license license:gpl3)))) -(define-public cl-xsubseq - (sbcl-package->cl-source-package sbcl-xsubseq)) +(define-public cl-docutils + (sbcl-package->cl-source-package sbcl-cl-docutils)) -(define-public ecl-xsubseq - (sbcl-package->ecl-package sbcl-xsubseq)) +(define-public ecl-cl-docutils + (sbcl-package->ecl-package sbcl-cl-docutils)) -(define-public sbcl-smart-buffer - (let ((commit "09b9a9a0b3abaa37abe9a730f5aac2643dca4e62") - (revision "1")) +(define-public sbcl-cl-dot + (let ((commit "73dfbb6e015a28ebed873266e4e8190e509b43de") + (revision "0")) (package - (name "sbcl-smart-buffer") - (version (git-version "0.0.1" revision commit)) + (name "sbcl-cl-dot") + (version (git-version "0.9.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/fukamachi/smart-buffer") + (url "https://github.com/michaelw/cl-dot") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-dot" version)) (sha256 - (base32 "0qz1zzxx0wm5ff7gpgsq550a59p0qj594zfmm2rglj97dahj54l7")))) + (base32 "0mcvzqfcg5rzr8rz8aa2yr2jl3ifflaksvps08zj71hbhiacqpxa")))) (build-system asdf-build-system/sbcl) - (arguments - '(#:asd-systems '("smart-buffer-test" "smart-buffer"))) - (native-inputs - (list sbcl-prove - sbcl-babel)) - (inputs - (list sbcl-xsubseq sbcl-flexi-streams)) - (home-page "https://github.com/fukamachi/smart-buffer") - (synopsis "Smart octets buffer") + (home-page "https://github.com/michaelw/cl-dot") + (synopsis "Generate Graphviz dot output from arbitrary Lisp data") (description - "Smart-buffer provides an output buffer which changes the destination -depending on content size.") - (license license:bsd-3)))) + "CL-DOT is a Common Lisp library for generating Graphviz dot output from +arbitrary Lisp data.") + (license license:expat)))) -(define-public cl-smart-buffer - (sbcl-package->cl-source-package sbcl-smart-buffer)) +(define-public cl-dot + (sbcl-package->cl-source-package sbcl-cl-dot)) -(define-public ecl-smart-buffer - (sbcl-package->ecl-package sbcl-smart-buffer)) +(define-public ecl-cl-dot + (sbcl-package->ecl-package sbcl-cl-dot)) -(define-public sbcl-fast-http - (let ((commit "502a37715dcb8544cc8528b78143a942de662c5a") - (revision "2")) +(define-public sbcl-cl-emb + (let ((commit "fd8652174d048d4525a81f38cdf42f4fa519f840") + (revision "1")) (package - (name "sbcl-fast-http") - (version (git-version "0.2.0" revision commit)) + (name "sbcl-cl-emb") + (version (git-version "0.4.3" revision commit)) + (home-page "https://common-lisp.net/project/cl-emb/") (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/fukamachi/fast-http") + (url "https://github.com/38a938c2/cl-emb") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 "0al2g7g219jjljsf7b23pbilpgacxy5as5gs2nqf76b5qni396mi")))) + (base32 "1xcm31n7afh5316lwz8iqbjx7kn5lw0l11arg8mhdmkx42aj4gkk")))) (build-system asdf-build-system/sbcl) - (arguments - '(#:asd-systems '("fast-http-test" "fast-http"))) - (native-inputs - `(("sbcl-prove" ,sbcl-prove) - ("cl-syntax" ,sbcl-cl-syntax))) (inputs - (list sbcl-alexandria sbcl-proc-parse sbcl-xsubseq - sbcl-smart-buffer sbcl-cl-utilities)) - (home-page "https://github.com/fukamachi/fast-http") - (synopsis "HTTP request/response parser for Common Lisp") - (description - "@code{fast-http} is a HTTP request/response protocol parser for Common -Lisp.") - ;; Author specified the MIT license - (license license:expat)))) + (list sbcl-cl-ppcre)) + (synopsis "Templating system for Common Lisp") + (description "A mixture of features from eRuby and HTML::Template. You +could name it \"Yet Another LSP\" (LispServer Pages) but it's a bit more than +that and not limited to a certain server or text format.") + (license license:llgpl)))) -(define-public cl-fast-http - (sbcl-package->cl-source-package sbcl-fast-http)) +(define-public cl-emb + (sbcl-package->cl-source-package sbcl-cl-emb)) -(define-public ecl-fast-http - (sbcl-package->ecl-package sbcl-fast-http)) +(define-public ecl-cl-emb + (sbcl-package->ecl-package sbcl-cl-emb)) -(define-public sbcl-static-vectors +(define-public sbcl-cl-environments (package - (name "sbcl-static-vectors") - (version "1.8.9") + (name "sbcl-cl-environments") + (version "0.4") (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/sionescu/static-vectors") + (url "https://github.com/alex-gutev/cl-environments") (commit (string-append "v" version)))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-environments" version)) (sha256 - (base32 "079qa20lhanzsz1qf4iags91n0ziylbjgbcymm5a5qj7yryas4fw")))) - (native-inputs - (list sbcl-fiveam)) - (inputs - (list sbcl-alexandria sbcl-cffi)) + (base32 "10jxj043d2dw5vc0i0lz0lsa4qszn8him5is8jdhl4nsyfcazmky")))) (build-system asdf-build-system/sbcl) - (home-page "https://github.com/sionescu/static-vectors") - (synopsis "Allocate SIMPLE-ARRAYs in static memory") + (inputs + (list sbcl-alexandria sbcl-anaphora sbcl-collectors sbcl-optima)) + (native-inputs + (list sbcl-prove)) + (home-page "https://github.com/alex-gutev/cl-environments") + (synopsis "Implements the Common Lisp standard environment access API") (description - "With @code{static-vectors}, you can create vectors allocated in static -memory.") + "This library provides a uniform API, as specified in Common Lisp the +Language 2, for accessing information about variable and function bindings +from implementation-defined lexical environment objects. All major Common +Lisp implementations are supported, even those which don't support the CLTL2 +environment access API.") (license license:expat))) -(define-public cl-static-vectors - (sbcl-package->cl-source-package sbcl-static-vectors)) - -(define-public ecl-static-vectors - (sbcl-package->ecl-package sbcl-static-vectors)) - -(define-public sbcl-marshal - (let ((commit "eff1b15f2b0af2f26f71ad6a4dd5c4beab9299ec") - (revision "1")) - (package - (name "sbcl-marshal") - (version (git-version "1.3.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/wlbr/cl-marshal") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "08qs6fhk38xpkkjkpcj92mxx0lgy4ygrbbzrmnivdx281syr0gwh")))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/wlbr/cl-marshal") - (synopsis "Simple (de)serialization of Lisp datastructures") - (description - "Simple and fast marshalling of Lisp datastructures. Convert any object -into a string representation, put it on a stream an revive it from there. -Only minimal changes required to make your CLOS objects serializable.") - (license license:expat)))) - -(define-public cl-marshal - (sbcl-package->cl-source-package sbcl-marshal)) - -(define-public ecl-marshal - (sbcl-package->ecl-package sbcl-marshal)) - -(define-public sbcl-fast-io - (let ((commit "a4c5ad600425842e8b6233b1fa22610ffcd874c3") - (revision "3")) - (package - (name "sbcl-fast-io") - (version (git-version "1.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/rpav/fast-io") - (commit commit))) - (file-name (git-file-name "cl-fast-io" version)) - (sha256 - (base32 "0wh02yagbqahy9z6787jz5ggpagvr18qd0z13wvwq1vjf8xd2530")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-fiveam sbcl-checkl)) - (inputs - (list sbcl-alexandria sbcl-trivial-gray-streams sbcl-static-vectors)) - (home-page "https://github.com/rpav/fast-io") - (synopsis "Fast octet-vector/stream I/O for Common Lisp") - (description - "Fast-io is about improving performance to octet-vectors and octet -streams (though primarily the former, while wrapping the latter).") - ;; Author specifies this as NewBSD which is an alias - (license license:bsd-3)))) - -(define-public cl-fast-io - (sbcl-package->cl-source-package sbcl-fast-io)) - -(define-public ecl-fast-io - (sbcl-package->ecl-package sbcl-fast-io)) - -(define-public sbcl-legion - (let ((commit "599cca19f0e34246814621f7fe90322221c2e263") - (revision "1")) - (package - (name "sbcl-legion") - (version (git-version "0.1.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/fukamachi/legion/") - (commit commit))) - (file-name (git-file-name "cl-legion" version)) - (sha256 - (base32 "0583pw0mf8bd4dj42w2xrlzcwfkl8q28n1bh8dpxxfg93crx4si6")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-prove sbcl-local-time)) - (inputs - (list - sbcl-bordeaux-threads - sbcl-cl-speedy-queue - sbcl-vom)) - (home-page "https://github.com/fukamachi/legion") - (synopsis "Simple multithreading worker mechanism for Common Lisp") - (description - "This library provides a simple multithreading worker mechanism.") - (license license:bsd-3)))) - -(define-public cl-legion - (sbcl-package->cl-source-package sbcl-legion)) - -(define-public ecl-legion - (package - (inherit (sbcl-package->ecl-package sbcl-legion)) - (arguments - ;; Tests get stuck forever - (list #:tests? #f)))) - -(define-public sbcl-jonathan - (let ((commit "1f448b4f7ac8265e56e1c02b32ce383e65316300") - (revision "1")) - (package - (name "sbcl-jonathan") - (version (git-version "0.1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Rudolph-Miller/jonathan") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "14x4iwz3mbag5jzzzr4sb6ai0m9r4q4kyypbq32jmsk2dx1hi807")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-prove sbcl-legion)) - (inputs - (list sbcl-cl-syntax sbcl-fast-io sbcl-proc-parse sbcl-cl-ppcre)) - (home-page "https://rudolph-miller.github.io/jonathan/overview.html") - (synopsis "JSON encoder and decoder") - (description - "High performance JSON encoder and decoder. Currently support: SBCL, -CCL.") - ;; Author specifies the MIT license - (license license:expat)))) - -(define-public cl-jonathan - (sbcl-package->cl-source-package sbcl-jonathan)) - -(define-public ecl-jonathan - (sbcl-package->ecl-package sbcl-jonathan)) - -(define-public sbcl-http-body - (let ((commit "3e4bedd6a9d9bc4e1dc0a45e5b55360ae30fd388") - (revision "2")) - (package - (name "sbcl-http-body") - (version (git-version "0.1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/fukamachi/http-body") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "0kcg43l5674drzid9cj938q0ki5z25glx296rl239dm7yfmxlzz2")))) - (build-system asdf-build-system/sbcl) - (arguments - '(#:asd-systems '("http-body-test" "http-body"))) - (native-inputs - (list sbcl-assoc-utils sbcl-prove sbcl-trivial-utf-8)) - (inputs - (list sbcl-babel - sbcl-cl-ppcre - sbcl-fast-http - sbcl-flexi-streams - sbcl-jonathan - sbcl-trivial-gray-streams - sbcl-cl-utilities - sbcl-quri)) - (home-page "https://github.com/fukamachi/http-body") - (synopsis "HTTP POST data parser") - (description - "HTTP-Body parses HTTP POST data and returns POST parameters. It -supports application/x-www-form-urlencoded, application/json, and -multipart/form-data.") - (license license:bsd-2)))) - -(define-public cl-http-body - (sbcl-package->cl-source-package sbcl-http-body)) - -(define-public ecl-http-body - (sbcl-package->ecl-package sbcl-http-body)) - -(define-public sbcl-ciel - (let ((commit "6cc1cef5e37e9f495c8163271a5de48de99f348a") - (revision "0")) - (package - (name "sbcl-ciel") - (version (git-version "0.1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/ciel-lang/CIEL") - (commit commit))) - (file-name (git-file-name "ciel" version)) - (sha256 - (base32 "1bwafbbsppxqvijf43dii55mpzrklh6faj2m5dhajg2f2m8qckgi")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-fiveam)) - (inputs - (list sbcl-access - sbcl-alexandria - sbcl-arrow-macros - sbcl-bordeaux-threads - sbcl-cl-ansi-text - sbcl-cl-ansi-text - sbcl-cl-cron - sbcl-cl-csv - sbcl-cl-json-pointer - sbcl-cl-ppcre - sbcl-cl-punch - sbcl-cl-reexport - sbcl-cl-str - sbcl-clesh - sbcl-clingon - sbcl-closer-mop - sbcl-cmd - sbcl-dbi - sbcl-defstar - sbcl-deploy - sbcl-dexador - sbcl-dissect - sbcl-easy-routes - sbcl-file-notify - sbcl-fn - sbcl-for - sbcl-fset - sbcl-generic-cl - sbcl-hunchentoot - sbcl-local-time - sbcl-log4cl - sbcl-lparallel - sbcl-lquery - sbcl-metabang-bind - sbcl-modf - sbcl-named-readtables - sbcl-nodgui - sbcl-parse-float - sbcl-parse-number - sbcl-printv - sbcl-pythonic-string-reader - sbcl-quicksearch - sbcl-quri - sbcl-repl-utilities - sbcl-serapeum - sbcl-shasht - sbcl-shlex - sbcl-spinneret - sbcl-sxql - sbcl-trivia - sbcl-trivial-arguments - sbcl-trivial-do - sbcl-trivial-monitored-thread - sbcl-trivial-package-local-nicknames - sbcl-trivial-types - sbcl-vgplot - sbcl-which)) - (home-page "http://ciel-lang.org/") - (synopsis "CIEL Is an Extended Lisp") - (description - "CIEL is a ready-to-use collection of libraries providing: a binary, to -run CIEL scripts; a simple full-featured REPL for the terminal; a Lisp library -and a core image .") - (license license:expat)))) - -(define-public cl-ciel - (sbcl-package->cl-source-package sbcl-ciel)) - -(define-public ecl-ciel - (sbcl-package->ecl-package sbcl-ciel)) - -(define-public sbcl-circular-streams - (let ((commit "e770bade1919c5e8533dd2078c93c3d3bbeb38df") - (revision "1")) - (package - (name "sbcl-circular-streams") - (version (git-version "0.1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/fukamachi/circular-streams") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1wpw6d5cciyqcf92f7mvihak52pd5s47kk4qq6f0r2z2as68p5rs")))) - (build-system asdf-build-system/sbcl) - (arguments - ;; The tests depend on cl-test-more which is now prove. Prove - ;; tests aren't working for some reason. - `(#:tests? #f)) - (inputs - (list sbcl-fast-io sbcl-trivial-gray-streams)) - (home-page "https://github.com/fukamachi/circular-streams") - (synopsis "Circularly readable streams for Common Lisp") - (description - "Circular-Streams allows you to read streams circularly by wrapping real -streams. Once you reach end-of-file of a stream, it's file position will be -reset to 0 and you're able to read it again.") - (license license:llgpl)))) - -(define-public cl-circular-streams - (sbcl-package->cl-source-package sbcl-circular-streams)) - -(define-public ecl-circular-streams - (sbcl-package->ecl-package sbcl-circular-streams)) - -(define-public sbcl-trivial-rfc-1123 - (let ((commit "9ef59c3fdec08b0e3c9ed02d39533887b6d1b8e3") - (revision "0")) - (package - (name "sbcl-trivial-rfc-1123") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/stacksmith/trivial-rfc-1123") - (commit commit))) - (file-name (git-file-name "cl-trivial-rfc-1123" version)) - (sha256 - (base32 "1w4ywpj10fnp7cya62dzlxlg8nyk4lppn2pnmfixsndwr4ib1h6x")))) - (build-system asdf-build-system/sbcl) - (arguments `(#:asd-systems '("trivial-rfc-1123"))) - (inputs (list sbcl-cl-ppcre)) - (home-page "https://github.com/stacksmith/trivial-rfc-1123") - (synopsis "Parse and print RFC-1123 timestamps") - (description - "This package parses and prints dates in RFC-1123 format.") - (license license:bsd-3)))) - -(define-public cl-trivial-rfc-1123 - (sbcl-package->cl-source-package sbcl-trivial-rfc-1123)) +(define-public cl-environments + (sbcl-package->cl-source-package sbcl-cl-environments)) -(define-public ecl-trivial-rfc-1123 - (sbcl-package->ecl-package sbcl-trivial-rfc-1123)) +(define-public ecl-cl-environments + (sbcl-package->ecl-package sbcl-cl-environments)) -(define-public sbcl-lack - (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b") +(define-public sbcl-cl-fad + ;; No release since 2019 + (let ((commit "3f4d32d3aa1093966046d001411a852eb8f4b535") (revision "1")) (package - (name "sbcl-lack") - (version (git-version "0.1.0" revision commit)) + (name "sbcl-cl-fad") + (version (git-version "0.7.6" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/fukamachi/lack") + (url "https://github.com/edicl/cl-fad/") (commit commit))) - (file-name (git-file-name "lack" version)) (sha256 - (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85")))) + (base32 "0a1xqldrq170lflnns3xp6swpnvsvllf5vq0h7sz8jqh4riqlny6")) + (file-name (git-file-name "cl-fad" version)))) (build-system asdf-build-system/sbcl) (native-inputs - (list sbcl-prove)) + (list sbcl-cl-ppcre sbcl-unit-test)) (inputs - `(("circular-streams" ,sbcl-circular-streams) - ("http-body" ,sbcl-http-body) - ("ironclad" ,sbcl-ironclad) - ("local-time" ,sbcl-local-time) - ("quri" ,sbcl-quri) - ("trivial-mimes" ,sbcl-trivial-mimes))) - (arguments - '(#:asd-systems '("lack" - "lack-request" - "lack-response" - "lack-component" - "lack-util" - "lack-middleware-backtrace" - "lack-middleware-static") - ;; XXX: Component :CLACK not found - #:tests? #f)) - (home-page "https://github.com/fukamachi/lack") - (synopsis "Lack, the core of Clack") + (list sbcl-alexandria sbcl-bordeaux-threads)) + (synopsis "Portable pathname library for Common Lisp") (description - "Lack is a Common Lisp library which allows web applications to be -constructed of modular components. It was originally a part of Clack, however -it's going to be rewritten as an individual project since Clack v2 with -performance and simplicity in mind.") - (license license:llgpl)))) - -(define-public cl-lack - (sbcl-package->cl-source-package sbcl-lack)) - -(define-public ecl-lack - (sbcl-package->ecl-package sbcl-lack)) - -(define-public sbcl-cl-isaac - (let ((commit "9cd88f39733be753facbf361cb0e08b9e42ff8d5") - (revision "0")) - (package - (name "sbcl-cl-isaac") - (version (git-version "1.0.7" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/thephoeron/cl-isaac") - (commit commit))) - (file-name (git-file-name "cl-isaac" version)) - (sha256 - (base32 "0ig1mf8iridfr7vci9gy499194h0hda0xki5s6g0y04g85ibnpw9")))) - (build-system asdf-build-system/sbcl) - (native-inputs (list sbcl-prove)) - (home-page "https://github.com/thephoeron/cl-isaac/") - (synopsis "Fast cryptographic random number generators") - (description "This is an optimized Common Lisp library of Bob Jenkins' -ISAAC-32 and ISAAC-64 algorithms, which are fast cryptographic random number -generators: Indirection, Shift, Accumulate, Add, and Count.") - (license license:bsd-0)))) - -(define-public cl-isaac - (sbcl-package->cl-source-package sbcl-cl-isaac)) - -(define-public ecl-cl-isaac - (sbcl-package->ecl-package sbcl-cl-isaac)) - -(define-public sbcl-local-time - (let ((commit "40169fe26d9639f3d9560ec0255789bf00b30036") - (revision "4")) - (package - (name "sbcl-local-time") - (version (git-version "1.0.6" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/dlowe-net/local-time") - (commit commit))) - (file-name (git-file-name "cl-local-time" version)) - (sha256 - (base32 "1dbp33zmkqzzshmf5k76pxqgli285wvy0p0dhcz816fdikpwn2jg")))) - (build-system asdf-build-system/sbcl) - (arguments - `(#:phases - (modify-phases %standard-phases - ;; Delete the extension provided by sbcl-cl-postgres+local-time - (add-after 'unpack 'delete-local-time - (lambda _ - (delete-file "cl-postgres+local-time.asd") - (delete-file "src/integration/cl-postgres.lisp")))))) - (native-inputs - (list sbcl-hu.dwim.stefil)) - (home-page "https://common-lisp.net/project/local-time/") - (synopsis "Time manipulation library for Common Lisp") - (description - "The LOCAL-TIME library is a Common Lisp library for the manipulation of -dates and times. It is based almost entirely upon Erik Naggum's paper \"The -Long Painful History of Time\".") - (license license:expat)))) - -(define-public cl-local-time - (sbcl-package->cl-source-package sbcl-local-time)) - -(define-public ecl-local-time - (sbcl-package->ecl-package sbcl-local-time)) - -(define-public sbcl-cl-postgres+local-time - (package - (inherit sbcl-local-time) - (name "sbcl-cl-postgres+local-time") - (inputs (list sbcl-local-time sbcl-postmodern)) - (arguments - `(#:asd-systems '("cl-postgres+local-time") - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'delete-local-time - (lambda _ - (delete-file "local-time.asd") - (delete-file "src/package.lisp") - (delete-file "src/local-time.lisp") - (delete-file-recursively "doc") - (delete-file-recursively "test") - (delete-file-recursively "zoneinfo")))))) - (synopsis "Integration between cl-postgres and local-time") - (description - "This package provides the LOCAL-TIME extensions for the cl-postgres -ASDF system of postmodern.") - (license license:expat))) + "CL-FAD (for \"Files and Directories\") is a thin layer atop Common +Lisp's standard pathname functions. It is intended to provide some +unification between current CL implementations on Windows, OS X, Linux, and +Unix. Most of the code was written by Peter Seibel for his book Practical +Common Lisp.") + (home-page "https://edicl.github.io/cl-fad/") + (license license:bsd-2)))) -(define-public cl-postgres+local-time - (sbcl-package->cl-source-package sbcl-cl-postgres+local-time)) +(define-public cl-fad + (sbcl-package->cl-source-package sbcl-cl-fad)) -(define-public ecl-cl-postgres+local-time - (sbcl-package->ecl-package sbcl-cl-postgres+local-time)) +(define-public ecl-cl-fad + (sbcl-package->ecl-package sbcl-cl-fad)) -(define-public sbcl-chronicity +(define-public sbcl-cl-fast-ecs (package - (name "sbcl-chronicity") - (version "0.4.1") + (name "sbcl-cl-fast-ecs") + (version "0.2.2") (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/chaitanyagupta/chronicity") - (commit (string-append "v" version)))) - (file-name (git-file-name "chronicity" version)) + (url "https://gitlab.com/lockie/cl-fast-ecs") + (commit version))) + (file-name (git-file-name "cl-fast-ecs" version)) (sha256 - (base32 "0rzrl9is2v1aqbm0sym0qx3blnpd0bl13dkkmll6mb3983k2mkax")))) + (base32 "00nw5nwzcz8x1x1lycmjik8pcqzxrl896j0xjjl33rjljsmj45sx")))) (build-system asdf-build-system/sbcl) (native-inputs - (list sbcl-lisp-unit)) + (list sbcl-chlorophyll sbcl-cl-mock sbcl-parachute)) (inputs - (list sbcl-cl-interpol sbcl-cl-ppcre sbcl-local-time)) - (home-page "https://github.com/chaitanyagupta/chronicity") - (synopsis "Natural language date and time parser for Common Lisp") + (list sbcl-alexandria sbcl-trivial-garbage)) + (home-page "https://lockie.gitlab.io/cl-fast-ecs/") + (synopsis "Blazingly fast Entity-Component-System microframework") (description - "CHRONICITY is Common Lisp natural language date and time parser inspired -by Ruby's @code{Chronic}.") - (license license:bsd-3))) - -(define-public ecl-chronicity - (sbcl-package->ecl-package sbcl-chronicity)) - -(define-public cl-chronicity - (sbcl-package->cl-source-package sbcl-chronicity)) - -(define-public sbcl-trivial-mimes - (let ((commit "a741fc2f567a4f86b853fd4677d75e62c03e51d9") - (revision "2")) - (package - (name "sbcl-trivial-mimes") - (version (git-version "1.1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shinmera/trivial-mimes") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "00kcm17q5plpzdj1qwg83ldhxksilgpcdkf3m9azxcdr968xs9di")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-hu.dwim.stefil)) - (inputs - (list sbcl-cl-fad)) - (home-page "https://shinmera.github.io/trivial-mimes/") - (synopsis "Tiny Common Lisp library to detect mime types in files") - (description - "This is a teensy library that provides some functions to determine the -mime-type of a file.") - (license license:zlib)))) - -(define-public cl-trivial-mimes - (sbcl-package->cl-source-package sbcl-trivial-mimes)) - -(define-public ecl-trivial-mimes - (sbcl-package->ecl-package sbcl-trivial-mimes)) + "CL-FAST-ECS is a Common Lisp library providing an implementation of the +@acronym{ECS, Entity-Component-System} pattern, primarily focused on speed and +interactive development. -(define-public sbcl-ningle - (let ((commit "2e85675bbb668d6ef341514fc9f22391a0f506b1") - (revision "2")) - (package - (name "sbcl-ningle") - (version (git-version "0.3.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/fukamachi/ningle") - (commit commit))) - (file-name (git-file-name "cl-ningle" version)) - (sha256 - (base32 "0s9nn8ml1j4839rycvdjcbsynkqnhxw1zmrgpjz48smscwdf1f8p")))) - (build-system asdf-build-system/sbcl) - (arguments - '(#:tests? #f)) ; TODO: pull in clack-test - (native-inputs - (list sbcl-prove)) - (inputs - (list sbcl-cl-syntax sbcl-myway sbcl-lack sbcl-alexandria - sbcl-babel)) - (home-page "https://8arrow.org/ningle/") - (synopsis "Super micro framework for Common Lisp") - (description - "Ningle is a lightweight web application framework for Common Lisp.") - (license license:llgpl)))) +ECS is an architectural data-oriented design pattern that allows for the +effective processing of a large number of in-game objects while keeping the code +and data separated. This provides flexibility in the way that game objects are +built at runtime.") + (license license:expat))) -(define-public cl-ningle - (sbcl-package->cl-source-package sbcl-ningle)) +(define-public cl-fast-ecs + (sbcl-package->cl-source-package sbcl-cl-fast-ecs)) -(define-public ecl-ningle - (sbcl-package->ecl-package sbcl-ningle)) +(define-public ecl-cl-fast-ecs + (sbcl-package->ecl-package sbcl-cl-fast-ecs)) (define-public sbcl-cl-fastcgi (let ((commit "de8b49b26de9863996ec18db28af8ab7e8ac4e20") @@ -7644,43 +5156,6 @@ mostly Common Lisp implementation.") (define-public ecl-cl-fastcgi (sbcl-package->ecl-package sbcl-cl-fastcgi)) -(define-public sbcl-cl-fast-ecs - (package - (name "sbcl-cl-fast-ecs") - (version "0.2.2") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://gitlab.com/lockie/cl-fast-ecs") - (commit version))) - (file-name (git-file-name "cl-fast-ecs" version)) - (sha256 - (base32 "00nw5nwzcz8x1x1lycmjik8pcqzxrl896j0xjjl33rjljsmj45sx")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-chlorophyll sbcl-cl-mock sbcl-parachute)) - (inputs - (list sbcl-alexandria sbcl-trivial-garbage)) - (home-page "https://lockie.gitlab.io/cl-fast-ecs/") - (synopsis "Blazingly fast Entity-Component-System microframework") - (description - "CL-FAST-ECS is a Common Lisp library providing an implementation of the -@acronym{ECS, Entity-Component-System} pattern, primarily focused on speed and -interactive development. - -ECS is an architectural data-oriented design pattern that allows for the -effective processing of a large number of in-game objects while keeping the code -and data separated. This provides flexibility in the way that game objects are -built at runtime.") - (license license:expat))) - -(define-public cl-fast-ecs - (sbcl-package->cl-source-package sbcl-cl-fast-ecs)) - -(define-public ecl-cl-fast-ecs - (sbcl-package->ecl-package sbcl-cl-fast-ecs)) - (define-public sbcl-cl-flac (let ((commit "d094d33d3cc2cf263263b917798d338eded3c532") (revision "0")) @@ -7722,703 +5197,611 @@ built at runtime.") audio library for Common Lisp.") (license license:zlib)))) -(define-public ecl-cl-flac - (sbcl-package->ecl-package sbcl-cl-flac)) - (define-public cl-flac (sbcl-package->cl-source-package sbcl-cl-flac)) -(define-public sbcl-clack - (let ((commit "6fd0279424f7ba5fd4f92d69a1970846b0b11222") - (revision "2")) +(define-public ecl-cl-flac + (sbcl-package->ecl-package sbcl-cl-flac)) + +(define-public sbcl-cl-fond + (let ((commit "dac975cbc73f231b400d5b8d8539b16330239a4a") + (revision "1")) (package - (name "sbcl-clack") - (version (git-version "2.0.0" revision commit)) + (name "sbcl-cl-fond") + (version (git-version "1.1.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/fukamachi/clack") + (url "https://github.com/Shirakumo/cl-fond") (commit commit))) - (file-name (git-file-name "cl-clack" version)) + (file-name (git-file-name "cl-fond" version)) (sha256 - (base32 "0sfmvqmsg9z13x0v77448rpdqgyprdq739nsbrjw9a28hv9jmkg9")))) + (base32 "03ygcw1azb44bhdsqcq99xi4ci0by76ap5jf5l2d1vfxq04v8grq")))) (build-system asdf-build-system/sbcl) - (arguments - '(#:asd-systems '("clack" - "clack-handler-fcgi" - "clack-socket" - "clack-handler-hunchentoot"))) (inputs (list sbcl-alexandria - sbcl-bordeaux-threads - sbcl-cl-fastcgi - sbcl-flexi-streams - sbcl-hunchentoot - sbcl-lack - sbcl-quri - sbcl-split-sequence - sbcl-usocket)) - (home-page "https://github.com/fukamachi/clack") - (synopsis "Web Application Environment for Common Lisp") - (description - "Clack is a web application environment for Common Lisp inspired by -Python's WSGI and Ruby's Rack.") - (license license:llgpl)))) + sbcl-cffi + sbcl-cl-opengl + sbcl-documentation-utils + sbcl-trivial-features + sbcl-trivial-garbage)) + (home-page "https://shirakumo.github.io/cl-fond/") + (synopsis "Bindings to libfond, a simple text rendering engine for OpenGL") + (description "This is a Common Lisp bindings library to libfond, a +simple OpenGL text rendering engine.") + (license license:zlib)))) -(define-public cl-clack - (sbcl-package->cl-source-package sbcl-clack)) +(define-public cl-fond + (sbcl-package->cl-source-package sbcl-cl-fond)) -(define-public ecl-clack - (sbcl-package->ecl-package sbcl-clack)) +(define-public ecl-cl-fond + (sbcl-package->ecl-package sbcl-cl-fond)) -(define-public sbcl-cl-log - (let ((commit "8f4b766d51e02245c310526cf1e4534ce634f837") - (revision "1")) - (package - (name "sbcl-cl-log") - (version "1.0.1") - (source - (origin +(define-public sbcl-cl-form-types + (package + (name "sbcl-cl-form-types") + (version "0.3.2") + (source + (origin (method git-fetch) (uri (git-reference - (url "https://github.com/nicklevine/cl-log") - (commit commit))) + (url "https://github.com/alex-gutev/cl-form-types") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) (sha256 - (base32 "1r3z9swy1b59swvaa5b97is9ysrfmjvjjhhw56p7p5hqg93b92ak")) - (file-name (git-file-name "cl-log" version)))) - (build-system asdf-build-system/sbcl) - (synopsis "Common Lisp general purpose logging utility") - (description "CL-LOG is a general purpose logging utility, loosely modelled -in some respects after Gary King's Log5. Its features include: logging to -several destinations at once, via \"messengers\", each messenger is tailored to -accept some log messages and reject others, and this tailoring can be changed -on-the-fly, very rapid processing of messages which are rejected by all -messengers, fully independent use of the utility by several different -sub-systems in an application, support for messengers which cl:format text to a -stream, support for messengers which do not invoke cl:format, timestamps in -theory accurate to internal-time-units-per-second.") - (home-page "https://github.com/nicklevine/cl-log") - (license license:expat)))) + (base32 + "0k4j657vfh4zblp9a7d3z15r82yyz4fzqh8vfn2s7ljsj1dmhp2n")))) + (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-agutil + sbcl-anaphora + sbcl-arrows + sbcl-cl-environments + sbcl-introspect-environment + sbcl-optima)) + (native-inputs + (list sbcl-fiveam)) + (home-page "https://github.com/alex-gutev/cl-form-types") + (synopsis "Determine the types of Common Lisp forms") + (description "This library provides functions for determining the value +types of Common Lisp forms, based on type information contained in the +environment. -(define-public cl-log - (sbcl-package->cl-source-package sbcl-cl-log)) +In order for this library to work the values types of variables and return +types of functions have to be declared. -(define-public ecl-cl-log - (sbcl-package->ecl-package sbcl-cl-log)) +Macros and symbol-macros are fully expanded and all special forms, except +@code{CATCH}, are supported.") + (license license:expat))) -(define-public sbcl-log4cl - (let ((commit "fe3da517147d023029782ced7cd989ba24f1e62d") - (revision "2")) +(define-public cl-form-types + (sbcl-package->cl-source-package sbcl-cl-form-types)) + +(define-public ecl-cl-form-types + (let ((pkg (sbcl-package->ecl-package sbcl-cl-form-types))) (package - (name "sbcl-log4cl") - (version (git-version "1.1.4" revision commit)) + (inherit pkg) + (arguments + ;; FIXME: Syntax error in declaration (TYPE T (FORM &KEY STRICT + ;; EXPAND-COMPILER-MACROS (TEST (QUOTE FORM-TYPE=)))) + ;; An error occurred during initialization: COMPILE-FILE-ERROR while... + ;; See <https://github.com/alex-gutev/cl-form-types/issues/22>. + '(#:tests? #f))))) + +(define-public sbcl-cl-freetype2 + (let ((commit "8bcb232b319a66fb700eaea88d0b308a837bce04") + (revision "1")) + (package + (name "sbcl-cl-freetype2") + (version (git-version "1.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/sharplispers/log4cl") + (url "https://github.com/rpav/cl-freetype2") (commit commit))) - (file-name (git-file-name "cl-log4cl" version)) + (file-name (git-file-name "cl-freetype2" version)) (sha256 - (base32 "0n119sy35k9yl4n18az1sw9a7saa5jh3v44863b305by1p5xdy7k")))) + (base32 "1nhq3qslja0bcgpbmzfycqhd4vw1l58zh4ia15m1h6535qxliy0q")))) (build-system asdf-build-system/sbcl) (native-inputs - (list sbcl-stefil)) + (list sbcl-fiveam)) (inputs - (list sbcl-bordeaux-threads)) - (home-page "https://github.com/7max/log4cl") - (synopsis "Common Lisp logging framework, modeled after Log4J") + (list freetype + sbcl-alexandria + sbcl-cffi + sbcl-trivial-garbage)) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'fix-paths + (lambda* (#:key inputs #:allow-other-keys) + (substitute* "src/ffi/ft2-lib.lisp" + (("\"libfreetype\"") + (string-append "\"" (assoc-ref inputs "freetype") + "/lib/libfreetype\""))) + (substitute* "src/ffi/grovel/grovel-freetype2.lisp" + (("-I/usr/include/freetype") + (string-append "-I" (assoc-ref inputs "freetype") + "/include/freetype"))) + #t))))) + (home-page "https://github.com/rpav/cl-freetype2") + (synopsis "Common Lisp bindings for Freetype 2") (description - "This is a Common Lisp logging framework that can log at various levels -and mix text with expressions.") - (license license:asl2.0)))) + "This is a general Freetype 2 wrapper for Common Lisp using CFFI. It's +geared toward both using Freetype directly by providing a simplified API, as +well as providing access to the underlying C structures and functions for use +with other libraries which may also use Freetype.") + (license license:bsd-3)))) -(define-public cl-log4cl - (sbcl-package->cl-source-package sbcl-log4cl)) +(define-public cl-freetype2 + (sbcl-package->cl-source-package sbcl-cl-freetype2)) -(define-public ecl-log4cl - (sbcl-package->ecl-package sbcl-log4cl)) +(define-public ecl-cl-freetype2 + (sbcl-package->ecl-package sbcl-cl-freetype2)) -(define-public sbcl-printv - (let ((commit "e717a7fe076dae861a96117b2f9af29db8d2294d") - (revision "2")) +(define-public sbcl-cl-gamepad + (let ((commit "d5b99fbaa2e39294d23061699e8f1e761eda7205") + (revision "3")) (package - (name "sbcl-printv") - (version (git-version "0.1.0" revision commit)) + (name "sbcl-cl-gamepad") + (version (git-version "3.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/danlentz/printv") + (url "https://github.com/Shirakumo/cl-gamepad") (commit commit))) - (file-name (git-file-name "cl-printv" version)) + (file-name (git-file-name "cl-gamepad" version)) (sha256 - (base32 "07agyzkwp3w2r4d2anrmr8h00yngpr5dq9mjd3m4kzhn1jcmilfb")))) + (base32 "0y6kg9wq92p07i1chm1v7j7p77iqc5c985pdvmmivcip8zmd4hm4")))) (build-system asdf-build-system/sbcl) - (inputs - (list figlet)) (arguments - `(#:phases + `(#:tests? #f ; No tests + #:phases (modify-phases %standard-phases - (add-after 'unpack 'patch-figlet-executable + (add-after 'unpack 'patch-evdev-lib-path (lambda* (#:key inputs #:allow-other-keys) - (substitute* "printv.lisp" - (("\"figlet") - (string-append "\"" (search-input-file inputs - "/bin/figlet"))))))))) - (home-page "https://github.com/danlentz/printv") - (synopsis "Common Lisp tracing and debug-logging macro") + (substitute* "evdev-cffi.lisp" + (("libevdev.so") + (search-input-file inputs "/lib/libevdev.so")))))))) + (inputs + (list libevdev + sbcl-cffi + sbcl-documentation-utils + sbcl-trivial-features)) + (home-page "https://shirakumo.github.io/cl-gamepad/") + (synopsis "Library for access to gamepads and joystick input devices") (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-cl-debug - (let ((commit "b334280806104ee7f7d3aec666bf7e08d2f89b31") - (revision "1")) - (package - (name "sbcl-cl-debug") - (version (git-version "1.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/kmx-io/cl-debug") - (commit commit))) - (file-name (git-file-name "cl-debug" version)) - (sha256 - (base32 "0w5vxbjsgr3zfpivdmghmhzxskfdvm1p34c8whwps2xlhypxsa78")))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/kmx-io/cl-debug") - (synopsis "Common Lisp cross-package debugging facility") - (description - "CL-DEBUG provides a unified way to enable or disable debug-specific code. -Debugging code can be enabled or disabled relative to program features denoted -by either a symbol or a keyword.") - (license license:isc)))) + "This is a library to provide cross-platform access to gamepads, +joysticks, and other such HID devices.") + (license license:zlib)))) -(define-public ecl-cl-debug - (sbcl-package->ecl-package sbcl-cl-debug)) +(define-public cl-gamepad + (sbcl-package->cl-source-package sbcl-cl-gamepad)) -(define-public cl-debug - (sbcl-package->cl-source-package sbcl-cl-debug)) +(define-public ecl-cl-gamepad + (sbcl-package->ecl-package sbcl-cl-gamepad)) -(define-public sbcl-verbose - (let ((commit "c5b7ecd465be61b35af17ef57564697b88397174") - (revision "1")) +(define-public sbcl-cl-geometry + (let ((commit "24eddedc47b931cec27361752736ef0b54fc9984")) (package - (name "sbcl-verbose") - (version (git-version "2.0.0" revision commit)) + (name "sbcl-cl-geometry") + (version (git-version "0.0.3" "1" commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/Shinmera/verbose/") + (url "https://github.com/vydd/cl-geometry") (commit commit))) - (file-name (git-file-name "verbose" version)) + (file-name (git-file-name "cl-cl-geometry" version)) (sha256 - (base32 "0r51ydj5v7afi2jrlscbhxprv13d9vzg5316g1yzwaxc1kzsdsw6")))) + (base32 "188xrd8plvc34gz7q01zmkdrzxbpwzln103l5dl78pa4a6vzz34h")))) (build-system asdf-build-system/sbcl) (inputs - (list sbcl-bordeaux-threads sbcl-dissect sbcl-documentation-utils - sbcl-local-time sbcl-piping)) - (home-page "https://shinmera.github.io/verbose/") - (synopsis "Logging framework using the piping library") + (list sbcl-iterate + sbcl-trees)) + (home-page "https://github.com/lispgames/cl-geometry/") + (synopsis "Simple two dimensional computational geometry in Common Lisp") (description - "This is a Common Lisp library providing logging faciltiy similar to -@code{CL-LOG} and @code{LOG4CL}.") - (license license:zlib)))) + "This is a system for two dimensional computational geometry for Common Lisp. -(define-public ecl-verbose - (sbcl-package->ecl-package sbcl-verbose)) +Note: the system assumes exact rational arithmetic, so no floating point +coordinates are allowed. This is not checked when creating geometric +objects.") + ;; The .asd says BSD-style but the LICENSE.txt is expat. + (license license:expat)))) -(define-public cl-verbose - (sbcl-package->cl-source-package sbcl-verbose)) +(define-public cl-cl-geometry + (sbcl-package->cl-source-package sbcl-cl-geometry)) -(define-public sbcl-vgplot - (let ((commit "76329928a3709387c0779175af56ec49d16bcd35") - (revision "0")) +(define-public ecl-cl-geometry + (sbcl-package->ecl-package sbcl-cl-geometry)) + +(define-public sbcl-cl-glfw3 + (let ((commit "32c3f34d592d55ee7ce932ed85804c1a9c4158c6") + (revision "1")) (package - (name "sbcl-vgplot") + (name "sbcl-cl-glfw3") (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/volkers/vgplot") + (url "https://github.com/AlexCharlton/cl-glfw3") (commit commit))) - (file-name (git-file-name "vgplot" version)) + (file-name (git-file-name "cl-glfw3" version)) (sha256 - (base32 "1vc5fd787xa8831wjbmwrpg17f9isi5k8dmb85fsysz47plbvi1y")))) + (base32 "1wzr43nckdx4rlgxzhm1r4kfc264q969mc43y0js9ramh7l8gba5")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-lisp-unit)) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'patch-glfw-lib-path + (lambda* (#:key inputs #:allow-other-keys) + (substitute* "glfw-bindings.lisp" + (("libglfw.so.3" _) + (search-input-file inputs "/lib/libglfw.so.3")))))))) (inputs - (list sbcl-cl-fad sbcl-cl-ppcre sbcl-ltk)) - (home-page "https://github.com/volkers/vgplot") - (synopsis "Common lisp library interfacing to the gnuplot utility") + `(("alexandria" ,sbcl-alexandria) + ("cffi" ,sbcl-cffi) + ("cl-opengl" ,sbcl-cl-opengl) + ("glfw" ,glfw) + ("trivial-main-thread" ,sbcl-trivial-main-thread))) + (home-page "https://github.com/AlexCharlton/cl-glfw3") + (synopsis "Common Lisp bindings to GLFW version 3.x") (description - "This package provides an interface to the @code{gnuplot} plotting -utility. The intention of the API is to resemble to some of the plot commands -of octave or matlab.") - (license license:gpl3+)))) + "This package provides a Common Lisp bindings to @code{glfw}, an OpenGL +application development library.") + (license license:bsd-2)))) -(define-public cl-vgplot - (sbcl-package->cl-source-package sbcl-vgplot)) +(define-public cl-glfw3 + (sbcl-package->cl-source-package sbcl-cl-glfw3)) -(define-public ecl-vgplot - (sbcl-package->ecl-package sbcl-vgplot)) +(define-public ecl-cl-glfw3 + (sbcl-package->ecl-package sbcl-cl-glfw3)) -(define-public sbcl-find-port - (let ((commit "811727f88d7f000623bf92fdb0e64678a7112a28") - (revision "2")) +(define-public sbcl-cl-glib + (let ((commit "9e52827cce1cbb3962536b6a5e628febab593f57") + (revision "1")) (package - (name "sbcl-find-port") - (build-system asdf-build-system/sbcl) - (version (git-version "0.1" revision commit)) - (home-page "https://github.com/eudoxia0/find-port") + (name "sbcl-cl-glib") + (version (git-version "1.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url home-page) + (url "https://github.com/bohonghuang/cl-glib") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-glib" version)) (sha256 - (base32 - "1fw6q7d2bxxb7fqk548ylq8mx4sz95yc0q5h0rwd0mnqjrbwbari")))) - (native-inputs - (list sbcl-fiveam)) + (base32 "0dxa493zdp1p93cahhpp3yaggn3j3kkn90mdw99g4ld7scmiglp4" )))) + (build-system asdf-build-system/sbcl) + (arguments + '(#:asd-systems '("cl-gio" "cl-glib" "cl-gobject"))) (inputs - (list sbcl-usocket)) - (synopsis "Find open ports programmatically in Common Lisp") - (description "This is a small Common Lisp library that finds an open -port within a range.") - (license license:expat)))) + (list glib + gobject-introspection + sbcl-bordeaux-threads + sbcl-cl-gobject-introspection-wrapper)) + (home-page "https://github.com/bohonghuang/cl-glib") + (synopsis "Glib, GIO and Gobject bindings for Common Lisp") + (description "This library provides Glib, GIO and Gobject bindings for +Common Lisp via Gobject Introspection.") + (license license:lgpl3+)))) -(define-public cl-find-port - (sbcl-package->cl-source-package sbcl-find-port)) +(define-public cl-glib + (sbcl-package->cl-source-package sbcl-cl-glib)) -(define-public ecl-find-port - (sbcl-package->ecl-package sbcl-find-port)) +(define-public ecl-cl-glib + (sbcl-package->ecl-package sbcl-cl-glib)) -(define-public sbcl-numpy-file-format - (let ((commit "e440c7bbc0d86b9abf73acb0fa665b77b82a6c98") - (revision "2")) +(define-public sbcl-cl-gltf + (let ((commit "7a3af05a7f491d8973b217f096806ef12a97474b") + (revision "1")) (package - (name "sbcl-numpy-file-format") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-cl-gltf") + (version (git-version "2.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/marcoheisig/numpy-file-format") + (url "https://github.com/Shirakumo/cl-gltf") (commit commit))) - (file-name (git-file-name "cl-numpy-file-format" version)) + (file-name (git-file-name "cl-gltf" version)) (sha256 - (base32 "1n0nixc44z1cymm20wif0l2100ydv0h69l6i6xz5bmwcb2zc4gqr")))) + (base32 "1d64fg2l2c0wns3wpp1xypd8687gnp3k70fv9fb48m1kpzg4kvrh")))) (build-system asdf-build-system/sbcl) + (arguments + ;; No tests provided. + `(#:tests? #f)) (inputs - (list sbcl-ieee-floats sbcl-trivial-features)) - (home-page "https://github.com/marcoheisig/numpy-file-format") - (synopsis "Read and write NumPy .npy and .npz files") + (list sbcl-documentation-utils + sbcl-cffi + sbcl-jzon + sbcl-mmap + sbcl-nibbles + sbcl-qbase64 + sbcl-static-vectors + sbcl-trivial-extensible-sequences)) + (home-page "https://shirakumo.github.io/cl-gltf/") + (synopsis "Common Lisp parser for glTF file format") (description - "The NUMPY-FILE-FORMAT library is a Common Lisp library for reading and -writing NumPy @file{.npy} and @file{.npz} files.") - (license license:expat)))) + "This package provides a Common Lisp parser for glTF file format.") + (license license:zlib)))) -(define-public cl-numpy-file-format - (sbcl-package->cl-source-package sbcl-numpy-file-format)) +(define-public cl-gltf + (sbcl-package->cl-source-package sbcl-cl-gltf)) -(define-public ecl-numpy-file-format - (sbcl-package->ecl-package sbcl-numpy-file-format)) +;; FIXME: ECL part is failing +;; ;;; Internal error: +;; +;; ** There is no package with the name SEQUENCE.An error occurred during +;; initialization: COMPILE-FILE-ERROR while compiling #<cl-source-file +;; "trivial-extensible-sequences" "fallback">. +;; +;; See <https://github.com/Shirakumo/cl-gltf/issues/3> +;; +;; (define-public ecl-cl-gltf +;; (sbcl-package->ecl-package sbcl-cl-gltf)) -(define-public sbcl-py4cl - (let ((commit "2f2a008dd6162d4446803971292fe1b323fe0dd5") - (revision "2")) +(define-public sbcl-cl-gobject-introspection + (let ((commit "83beec4492948b52aae4d4152200de5d5c7ac3e9") + (revision "3")) (package - (name "sbcl-py4cl") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-cl-gobject-introspection") + (version (git-version "0.3" revision commit)) + (home-page "https://github.com/andy128k/cl-gobject-introspection") (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/bendudson/py4cl") + (url home-page) (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-gobject-introspection" version)) (sha256 - (base32 - "1zx1kpfpd8mi1qaa7gr32mki6nvl6pqcs3437fvn4xa3yf7ybsha")) - (modules '((guix build utils))))) + (base32 "0xwmj4b3whz12i474g54krp1v6h0fpvsx8lgwpk6rkli9xc71wc3")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-clunit)) (inputs - (list python sbcl-trivial-garbage)) - (propagated-inputs - (list ;; For multi-dimensional array support - python-numpy)) + (list glib + gobject-introspection + sbcl-alexandria + sbcl-cffi + sbcl-iterate + sbcl-trivial-garbage)) + (native-inputs + (list sbcl-fiveam)) (arguments '(#:phases (modify-phases %standard-phases - (add-after 'unpack 'fix-python3-path + (add-after 'unpack 'fix-paths (lambda* (#:key inputs #:allow-other-keys) - (substitute* "src/python-process.lisp" - (("\\*python-command\\* \"python\"") - (string-append "*python-command* " - "\"" - (search-input-file inputs "/bin/python3") - "\""))))) - (add-after 'unpack 'replace-*base-directory*-var - (lambda* (#:key outputs #:allow-other-keys) - ;; In the ASD, the author makes an attempt to - ;; programatically determine the location of the - ;; source-code so lisp can call into "py4cl.py". We can - ;; hard-code this since we know where this file will - ;; reside. - (substitute* "src/python-process.lisp" - (("py4cl/config:\\*base-directory\\*") - (string-append - "\"" - (assoc-ref outputs "out") - "/share/common-lisp/" - (%lisp-type) - "/py4cl/" - "\"")))))))) - (synopsis "Call python from Common Lisp") + (substitute* "src/init.lisp" + (("libgobject-2\\.0\\.so") + (search-input-file inputs "/lib/libgobject-2.0.so")) + (("libgirepository-1\\.0\\.so") + (search-input-file inputs + "/lib/libgirepository-1.0.so")))))))) + (synopsis "Common Lisp bindings to GObject Introspection") (description - "Py4CL is a bridge between Common Lisp and Python, which enables Common -Lisp to interact with Python code. It uses streams to communicate with a -separate python process, the approach taken by cl4py. This is different to -the CFFI approach used by burgled-batteries, but has the same goal.") - (home-page "https://github.com/bendudson/py4cl") - ;; MIT License - (license license:expat)))) + "This library is a bridge between Common Lisp and GObject +Introspection, which enables Common Lisp programs to access the full interface +of C+GObject libraries without the need of writing dedicated bindings.") + (license (list license:bsd-3 + ;; Tests are under a different license. + license:llgpl))))) -(define-public cl-py4cl - (sbcl-package->cl-source-package sbcl-py4cl)) +(define-public cl-gobject-introspection + (sbcl-package->cl-source-package sbcl-cl-gobject-introspection)) -(define-public ecl-py4cl - (sbcl-package->ecl-package sbcl-py4cl)) +(define-public ecl-cl-gobject-introspection + (sbcl-package->ecl-package sbcl-cl-gobject-introspection)) -(define-public sbcl-schemeish - (let ((commit "dff57bafae5d0cffa104c8fdc4146502f32d7f85") +(define-public sbcl-cl-gobject-introspection-wrapper + (let ((commit "2d197cba7e7d734ac8a2e181e5e709e5b218bada") (revision "1")) (package - (name "sbcl-schemeish") - (version (git-version "0.0.1" revision commit)) + (name "sbcl-cl-gobject-introspection-wrapper") + (version (git-version "1.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/chebert/schemeish") + (url "https://github.com/bohonghuang/cl-gobject-introspection-wrapper") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-gobject-introspection-wrapper" version)) (sha256 - (base32 "0q9b07spmhg1b576cnnacvkf7zr3mab2rdydfylbn92y9mms9vyj")))) + (base32 "05np2zs5806ib6qfz7d6knyaz6llxgwvjqavl1fsz5hcga40296s")))) (build-system asdf-build-system/sbcl) (inputs - (list sbcl-trivial-arguments)) - (synopsis "Scheme style syntax/macros/functions for Common Lisp") + (list sbcl-alexandria + sbcl-cl-gobject-introspection + sbcl-cl-ppcre)) + (home-page + "https://github.com/bohonghuang/cl-gobject-introspection-wrapper") + (synopsis + "Wrap and call GObject Introspection FFI function in Common Lisp") (description - "Schemeish implements several useful Scheme constructs for Common Lisp. -These include named-let, define, scheme argument lists, and a shortcut to -FUNCALL with [] instead of ().") - (home-page "https://github.com/chebert/schemeish") - ;; MIT License - (license license:expat)))) + "This library converts the elements from GObject Introspection into +Common Lisp-style definitions, based on cl-gobject-introspection.") + (license license:lgpl3+)))) -(define-public cl-schemeish - (sbcl-package->cl-source-package sbcl-schemeish)) +(define-public cl-gobject-introspection-wrapper + (sbcl-package->cl-source-package sbcl-cl-gobject-introspection-wrapper)) -(define-public ecl-schemeish - (sbcl-package->ecl-package sbcl-schemeish)) +(define-public ecl-cl-gobject-introspection-wrapper + (sbcl-package->ecl-package sbcl-cl-gobject-introspection-wrapper)) -(define-public sbcl-parse-declarations - (let ((commit "549aebbfb9403a7fe948654126b9c814f443f4f2") - (revision "1")) +(define-public sbcl-cl-gopher + (let ((commit "0899e7fa2134206f9d9778c7d53c49b7a59ff070") + (revision "3")) (package - (name "sbcl-parse-declarations") - (version (git-version "1.0.0" revision commit)) + (name "sbcl-cl-gopher") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url (string-append - "https://gitlab.common-lisp.net/parse-declarations/" - "parse-declarations.git")) + (url "https://github.com/knusbaum/cl-gopher") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-gopher" version)) (sha256 - (base32 "03g5qks4c59nmxa48pbslxkfh77h8hn8566jddp6m9pl15dzzpxd")))) + (base32 "1ky4s33m5d0wvdaqji12pxr93qqfl5x62zjp3m4ihbdj0ws3yw2f")) + (snippet + '(begin + ;; These files are mostly examples (that assume Quicklisp) which + ;; drag the SBCL package into the CL package. + (for-each delete-file + '("cl-gopher-network.lsh" + "cl-gopher-start.lsh")) + #t)))) (build-system asdf-build-system/sbcl) - (arguments - `(#:asd-systems '("parse-declarations-1.0"))) - (home-page "https://common-lisp.net/project/parse-declarations/") - (synopsis "Parse, filter, and build declarations") + (inputs + (list sbcl-bordeaux-threads + sbcl-drakma + sbcl-flexi-streams + sbcl-quri + sbcl-split-sequence + sbcl-usocket)) + (home-page "https://github.com/knusbaum/cl-gopher") + (synopsis "Gopher protocol library in Common Lisp") (description - "Parse-Declarations is a Common Lisp library to help writing -macros which establish bindings. To be semantically correct, such -macros must take user declarations into account, as these may affect -the bindings they establish. Yet the ANSI standard of Common Lisp does -not provide any operators to work with declarations in a convenient, -high-level way. This library provides such operators.") - ;; MIT License - (license license:expat)))) + "@code{cl-gopher} is a Common Lisp library for interacting with the +Gopher protocol. -(define-public cl-parse-declarations - (sbcl-package->cl-source-package sbcl-parse-declarations)) +It is suitable for building both clients and servers, and provides a sample +client.") + (license license:bsd-2)))) -(define-public ecl-parse-declarations - (sbcl-package->ecl-package sbcl-parse-declarations)) +(define-public cl-gopher + (sbcl-package->cl-source-package sbcl-cl-gopher)) -(define-public sbcl-burgled-batteries3 - (let ((commit "f65f454d13bb6c40e17e9ec62e41eb5069e09760") +(define-public ecl-cl-gopher + (sbcl-package->ecl-package sbcl-cl-gopher)) + +(define-public sbcl-cl-graph + (let ((commit "c617de35390cb02db88bc5b5febffafdb8947ae8") (revision "2")) (package - (name "sbcl-burgled-batteries3") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-cl-graph") + (version (git-version "0.10.2" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/snmsts/burgled-batteries3") + (url "https://github.com/hraban/cl-graph") (commit commit))) - (file-name (git-file-name "cl-burgled-batteries3" version)) + (file-name (git-file-name "cl-graph" version)) (sha256 - (base32 - "1nzn7jawrfajyzwfnzrg2cmn9xxadcqh4szbpg0jggkhdkdzz4wa")) - (patches - (search-patches "sbcl-burgled-batteries3-fix-signals.patch")))) + (base32 "0g1abkph9zb0m9zz6q2471ml9q9acdhwyapk8ra3bisqpwlxvpyf")))) (build-system asdf-build-system/sbcl) (arguments + ;; TODO: (Sharlatan-20221118T215839+0000): Tests failed + ;; + ;; https://github.com/gwkkwg/cl-graph/issues/17 + ;; `(#:tests? #f - #:modules (((guix build python-build-system) #:select (python-version)) - ,@%asdf-build-system-modules) - #:imported-modules ((guix build python-build-system) - ,@%asdf-build-system-modules) - #:phases - (modify-phases (@ (guix build asdf-build-system) %standard-phases) - (add-after 'unpack 'set-*cpython-include-dir*-var - (lambda* (#:key inputs #:allow-other-keys) - (let ((python (assoc-ref inputs "python"))) - (setenv "BB_PYTHON3_INCLUDE_DIR" - (string-append python "/include/python" - (python-version python))) - (setenv "BB_PYTHON3_DYLIB" - (string-append python "/lib/libpython3.so")) - #t))) - (add-after 'unpack 'adjust-for-python-3.10 - (lambda _ - ;; These methods are no longer part of the public API. - (substitute* "ffi-interface.lisp" - ((".*PyEval_ReInitThreads.*") "") - ((".*\"PyErr_Warn\".*") "") - ((".*\"PyFloat_ClearFreeList\".*") "") - ((".*\"PyParser_SimpleParseString\".*") "") - ((".*\"PyParser_SimpleParseStringFlags\".*") "") - ((".*\"PyParser_SimpleParseStringFlagsFilename\".*") "") - ((".*\"PyParser_SimpleParseFile\".*") "") - ((".*\"PyParser_SimpleParseFileFlags\".*") "") - ((".*\"PyLong_FromUnicode\".*") ""))))))) + #:asd-systems '("cl-graph" "cl-graph+hu.dwim.graphviz"))) (native-inputs - (list sbcl-cl-fad sbcl-lift sbcl-cl-quickcheck)) + (list sbcl-lift sbcl-moptilities)) (inputs - (list python - sbcl-alexandria - sbcl-cffi - sbcl-parse-declarations - sbcl-trivial-garbage)) - (synopsis "Bridge between Python and Lisp (FFI bindings, etc.)") - (description - "This package provides a shim between Python3 (specifically, the -CPython implementation of Python) and Common Lisp.") - (home-page "https://github.com/snmsts/burgled-batteries3") - (license license:expat)))) - -(define-public cl-burgled-batteries3 - (sbcl-package->cl-source-package sbcl-burgled-batteries3)) - -(define-public ecl-burgled-batteries3 - (sbcl-package->ecl-package sbcl-burgled-batteries3)) - -(define-public sbcl-metabang-bind - (let ((commit "08196426cb099db0623e6cae2aeca566e0b788b2") - (revision "2")) - (package - (name "sbcl-metabang-bind") - (version (git-version "0.8.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/hraban/metabang-bind") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "14g7k3zhm8cd6bssc5mm5h6iq1dv5lfhiq33aimcmj5a6vbiq47d")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-lift)) - (synopsis "Macro that generalizes @code{multiple-value-bind} etc.") + (list sbcl-cl-containers + sbcl-cl-mathstats + sbcl-dynamic-classes + sbcl-hu.dwim.graphviz + sbcl-metabang-bind + sbcl-metacopy + sbcl-metatilities-base)) + (home-page "https://github.com/gwkkwg/cl-graph") + (synopsis "Graph manipulation utilities for Common Lisp") (description - "Bind extends the idea of of let and destructing to provide a uniform -syntax for all your accessor needs. It combines @code{let}, -@code{destructuring-bind}, @code{with-slots}, @code{with-accessors}, structure -editing, property or association-lists, and @code{multiple-value-bind} and a -whole lot more into a single form.") - (home-page "https://common-lisp.net/project/metabang-bind/") - ;; MIT License + "This package provides a Common Lisp library for manipulating graphs +and running graph algorithms.") (license license:expat)))) -(define-public cl-metabang-bind - (sbcl-package->cl-source-package sbcl-metabang-bind)) +(define-public cl-cl-graph + (sbcl-package->cl-source-package sbcl-cl-graph)) -(define-public ecl-metabang-bind - (sbcl-package->ecl-package sbcl-metabang-bind)) +;; NOTE: (Sharlatan-20221118T214734+0000): No ECL support +;; +;; ecl-cl-graph -(define-public sbcl-fare-csv - (let ((commit "f877a238dcbf587a89359cccf2128919a94a348c") +(define-public sbcl-cl-grnm + (let ((commit "778a312e9eb3d3de7541457b516ea3d9055a15aa") (revision "0")) (package - (name "sbcl-fare-csv") - (version (git-version "1.0.4" revision commit)) + (name "sbcl-cl-grnm") + (version (git-version "0.1.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://gitlab.common-lisp.net/frideau/fare-csv") + (url "https://github.com/quil-lang/cl-grnm") (commit commit))) - (file-name (git-file-name "cl-fare-csv" version)) - (sha256 - (base32 "0k3mf968w94m4yff1k2jh7xlnpsm016qs4448bvklacjrr72vk8x")))) - (build-system asdf-build-system/sbcl) - (native-inputs (list sbcl-hu.dwim.stefil)) - (home-page "https://gitlab.common-lisp.net/frideau/fare-csv/") - (synopsis "Robust CSV parser and printer") - (description - "This package provides a robust CSV parser and printer that tries to -follow the fine print of de facto standards. It can be configured to choose -which standard exactly.") - (license license:expat)))) - -(define-public cl-fare-csv - (sbcl-package->cl-source-package sbcl-fare-csv)) - -(define-public ecl-fare-csv - (sbcl-package->ecl-package sbcl-fare-csv)) - -(define-public sbcl-fare-utils - (let ((commit "66e9c6f1499140bc00ccc22febf2aa528cbb5724") - (revision "1")) - (package - (name "sbcl-fare-utils") - (version (git-version "1.0.0.5" revision commit)) - (source - (origin - (method git-fetch) - (uri - (git-reference - (url - "https://gitlab.common-lisp.net/frideau/fare-utils.git") - (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-grnm" version)) (sha256 - (base32 - "01wsr1aap3jdzhn4hrqjbhsjx6qci9dbd3gh4gayv1p49rbg8aqr")))) + (base32 "1hb5n37n3x2ylrghcqsia2g9a6f5wg24l659jiz4ncpi5bsv4m3s")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-hu.dwim.stefil)) - (synopsis "Collection of utilities and data structures") + (synopsis "Common Lisp implementation of (grid restrained) Nelder-Mead") (description - "fare-utils is a small collection of utilities. It contains a lot of -basic everyday functions and macros.") - (home-page "https://gitlab.common-lisp.net/frideau/fare-utils") - ;; MIT License + "These common lisp sources contain two variants of the Nelder-Mead +algorithm. The original algorithm and a provably convergent, reliable variant +by A. Bürmen et al, called the +@acronym{GRNMA, Grid Restrained Nelder Mead Algorithm}.") + (home-page "https://github.com/quil-lang/cl-grnm") (license license:expat)))) -(define-public cl-fare-utils - (sbcl-package->cl-source-package sbcl-fare-utils)) - -(define-public ecl-fare-utils - (sbcl-package->ecl-package sbcl-fare-utils)) - -(define-public sbcl-fare-mop - (let ((commit "538aa94590a0354f382eddd9238934763434af30") - (revision "1")) - (package - (name "sbcl-fare-mop") - (version (git-version "1.0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/fare/fare-mop") - (commit commit))) - (file-name (git-file-name "fare-mop" version)) - (sha256 - (base32 - "0maxs8392953fhnaa6zwnm2mdbhxjxipp4g4rvypm06ixr6pyv1c")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-closer-mop sbcl-fare-utils)) - (home-page "https://github.com/fare/fare-mop") - (synopsis "General purpose Common Lisp utilities using the MOP") - (description - "FARE-MOP is a small collection of utilities using the MetaObject -Protocol. It notably contains a SIMPLE-PRINT-OBJECT method, and -a SIMPLE-PRINT-OBJECT-MIXIN mixin that allow you to trivially define -PRINT-OBJECT methods that print the interesting slots in your objects, which is -great for REPL interaction and debugging.") - (license license:unlicense)))) +(define-public cl-grnm + (sbcl-package->cl-source-package sbcl-cl-grnm)) -(define-public ecl-fare-mop - (sbcl-package->ecl-package sbcl-fare-mop)) +(define-public ecl-cl-grnm + (sbcl-package->ecl-package sbcl-cl-grnm)) -(define-public cl-fare-mop - (sbcl-package->cl-source-package sbcl-fare-mop)) +(define-public sbcl-cl-gserver + (package + (name "sbcl-cl-gserver") + (version "1.8.0") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/mdbergmann/cl-gserver") -(define-public sbcl-inferior-shell - (let ((commit "15c2d04a7398db965ea1c3ba2d49efa7c851f2c2") - (revision "1")) - (package - (name "sbcl-inferior-shell") - (version (git-version "2.0.5" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/fare/inferior-shell") - (commit commit))) - (file-name (git-file-name "inferior-shell" version)) - (sha256 - (base32 "02qx37zzk5j4xmwh77k2qa2wvnzvaj6qml5dh2q7b6b1ljvgcj4m")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-hu.dwim.stefil)) - (inputs - (list sbcl-alexandria sbcl-fare-mop sbcl-fare-quasiquote - sbcl-fare-utils sbcl-trivia)) - (home-page "https://github.com/fare/inferior-shell") - (synopsis "Spawn local or remote processes and shell pipes") - (description - "This package provides a Common Lisp system helping in scripting, it -uses @code{uiop:run-program} as a backend.") - (license license:expat)))) + ;; The "1.8.0" tag must have been moved from + ;; c83d92a66102faa514b546029a9bd2078b95dc0f to + ;; 90832f02f0556463e332cd055c3c1be58f323aea, 22 commits later! + (commit "c83d92a66102faa514b546029a9bd2078b95dc0f"))) + (file-name (git-file-name "cl-gserver" version)) + (sha256 + (base32 "1bfz7z8v417dvsp1jz76ir3ihcs8g7zis2d56xx1dpzqzjd95g7z")))) + (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-alexandria + sbcl-bordeaux-threads + sbcl-lparallel + sbcl-cl-speedy-queue + sbcl-log4cl + sbcl-cl-str + sbcl-blackbird + sbcl-cl-hamt + sbcl-binding-arrows + sbcl-atomics)) + (native-inputs + (list sbcl-fiveam sbcl-cl-mock)) + (home-page "https://mdbergmann.github.io/cl-gserver/index.html") + (synopsis "Actor framework for easy access to state and async operations") + (description + "@code{cl-gserver} is a 'message passing' library / framework with actors +similar to Erlang or Akka. It supports creating reactive systems for parallel +computing and event based message handling.") + (license license:agpl3))) -(define-public ecl-inferior-shell - (sbcl-package->ecl-package sbcl-inferior-shell)) +(define-public cl-gserver + (sbcl-package->cl-source-package sbcl-cl-gserver)) -(define-public cl-inferior-shell - (sbcl-package->cl-source-package sbcl-inferior-shell)) +(define-public ecl-cl-gserver + (sbcl-package->ecl-package sbcl-cl-gserver)) (define-public sbcl-cl-gss (let ((commit "60086f4fd3b82316352e7f2288edbd58f03e08c5") @@ -8460,213 +5843,120 @@ The most common one is Kerberos, which has several implementations, the most common of which is probably Active Directory.") (license license:bsd-3)))) -(define-public ecl-cl-gss - (sbcl-package->ecl-package sbcl-cl-gss)) - (define-public cl-gss (sbcl-package->cl-source-package sbcl-cl-gss)) -(define-public sbcl-trivial-utf-8 - (let ((commit "6ca9943588cbc61ad22a3c1ff81beb371e122394") - (revision "2")) +(define-public ecl-cl-gss + (sbcl-package->ecl-package sbcl-cl-gss)) + +(define-public sbcl-cl-gtk4 + (let ((commit "d116905e7b68508d03681a50b3b24d63e7b111e4") + (revision "1")) (package - (name "sbcl-trivial-utf-8") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-cl-gtk4") + (version (git-version "1.0.0" revision commit)) (source (origin (method git-fetch) - (uri - (git-reference - (url (string-append "https://gitlab.common-lisp.net/" - "trivial-utf-8/trivial-utf-8.git")) - (commit commit))) - (file-name (git-file-name "cl-trivial-utf-8" version)) + (uri (git-reference + (url "https://github.com/bohonghuang/cl-gtk4") + (commit commit))) + (file-name (git-file-name "cl-gtk4" version)) (sha256 - (base32 "0gzgbyzbbhny5y1lq2x82vfy4b4p1snq1sy9lj82hdq7lkyj03ss")))) - (arguments - ;; Guix incorrectly assumes the "8" is part of the version - ;; number and lobs it off. - `(#:asd-systems '("trivial-utf-8"))) + (base32 "0mprmmvbagnflvhynn51l42nbwr08rld99ls0c48m5lpjn0ja4zc")))) (build-system asdf-build-system/sbcl) - (synopsis "UTF-8 input/output library") + (arguments + '(#:asd-systems '("cl-gtk4" "cl-gdk4"))) + ;; propagate because it at least requires the typelib files at runtime + (propagated-inputs (list gtk)) + (inputs + (list gobject-introspection + sbcl-cl-glib + sbcl-cl-gobject-introspection-wrapper)) + (home-page "https://github.com/bohonghuang/cl-gtk4") + (synopsis "GTK4 bindings for Common Lisp") (description - "The Babel library solves a similar problem while understanding more -encodings. Trivial UTF-8 was written before Babel existed, but for new -projects you might be better off going with Babel. The one plus that Trivial -UTF-8 has is that it doesn't depend on any other libraries.") - (home-page "https://common-lisp.net/project/trivial-utf-8/") - (license license:bsd-3)))) + "This library provides GTK4 bindings for Common Lisp via Gobject +Introspection, in the cl-gtk4 ASDF system.") + (license license:lgpl3)))) -(define-public cl-trivial-utf-8 - (sbcl-package->cl-source-package sbcl-trivial-utf-8)) +(define-public cl-gtk4 + (sbcl-package->cl-source-package sbcl-cl-gtk4)) -(define-public ecl-trivial-utf-8 - (sbcl-package->ecl-package sbcl-trivial-utf-8)) +(define-public ecl-cl-gtk4 + (sbcl-package->ecl-package sbcl-cl-gtk4)) -(define-public sbcl-trivial-utilities - (let ((commit "279ff255562628196942632c543d91c357067221") - (revision "0")) +(define-public sbcl-cl-hamt + ;; No release + (let ((commit "7a99eaaca1f952029def9ad5a2b80a612a712208")) (package - (name "sbcl-trivial-utilities") - (version (git-version "0.4.0" revision commit)) + (name "sbcl-cl-hamt") + (version (git-version "0.0.0" "1" commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://gitlab.com/ediethelm/trivial-utilities") + (url "https://github.com/danshapero/cl-hamt/") (commit commit))) - (file-name (git-file-name "trivial-utilities" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "0k1xmn5f5dik7scadw0vyy67mik4ypnfqbhlv2vsg9afxzbpx2dz")))) + (base32 "1ycbd73ykfj5j9sdhlzamyv18qbjj6xqf7fhm4fa0nsyr6sr3rf5")))) (build-system asdf-build-system/sbcl) (inputs - (list sbcl-alexandria sbcl-iterate sbcl-closer-mop)) - (home-page "https://gitlab.com/ediethelm/trivial-utilities") - (synopsis "Collection of useful types, functions and macros for Common Lisp") + (list sbcl-cl-murmurhash)) + (native-inputs + (list sbcl-fiveam)) + (home-page "https://github.com/danshapero/cl-hamt") + (synopsis "Dictionary & set data structure using hash array-mapped tries") (description - "This package provides a collection of types, functions and macros. Some - of the functionality is implemented from Graham's On Lisp and Seibel's Practical - Common Lisp.") - (license license:expat)))) + "This library provides purely functional dictionaries and sets in +Common Lisp based on the hash array-mapped trie data structure.") + (license license:bsd-3)))) -(define-public cl-trivial-utilities - (sbcl-package->cl-source-package sbcl-trivial-utilities)) +(define-public cl-hamt + (sbcl-package->cl-source-package sbcl-cl-hamt)) -(define-public ecl-trivial-utilities - (sbcl-package->ecl-package sbcl-trivial-utilities)) +(define-public ecl-cl-hamt + (sbcl-package->ecl-package sbcl-cl-hamt)) -(define-public sbcl-idna +(define-public sbcl-cl-heap (package - (name "sbcl-idna") - (build-system asdf-build-system/sbcl) - (version "0.2.2") - (home-page "https://github.com/antifuchs/idna") + (name "sbcl-cl-heap") + (version "0.1.6") (source (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit version))) - (file-name (git-file-name name version)) + (method url-fetch) + (uri (string-append "https://common-lisp.net/project/cl-heap/releases/" + "cl-heap_" version ".tar.gz")) (sha256 (base32 - "00nbr3mffxhlq14gg9d16pa6691s4qh35inyw76v906s77khm5a2")))) - (inputs - (list sbcl-split-sequence)) - (synopsis "IDNA string encoding and decoding routines for Common Lisp") - (description "This Common Lisp library provides string encoding and -decoding routines for IDNA, the International Domain Names in Applications.") - (license license:expat))) - -(define-public cl-idna - (sbcl-package->cl-source-package sbcl-idna)) - -(define-public ecl-idna - (sbcl-package->ecl-package sbcl-idna)) - -(define-public sbcl-swap-bytes - (package - (name "sbcl-swap-bytes") + "163hb07p2nxz126rpq3cj5dyala24n0by5i5786n2qcr1w0bak4i")))) (build-system asdf-build-system/sbcl) - (version "1.2") - (home-page "https://github.com/sionescu/swap-bytes") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit (string-append "v" version)))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "1hw1v1lw26rifyznpnj1csphha9jgzwpiic16ni3pvs6hcsni9rz")))) - (inputs - (list sbcl-trivial-features)) (native-inputs - (list sbcl-fiveam)) - (synopsis "Efficient endianness conversion for Common Lisp") - (description "This Common Lisp library provides optimized byte-swapping -primitives. The library can change endianness of unsigned integers of length -1/2/4/8. Very useful in implementing various network protocols and file -formats.") - (license license:expat))) - -(define-public cl-swap-bytes - (sbcl-package->cl-source-package sbcl-swap-bytes)) - -(define-public ecl-swap-bytes - (sbcl-package->ecl-package sbcl-swap-bytes)) - -(define-public sbcl-iolib - (let ((commit "010b7a6bdd2e918ebf2ec85edd3853179f01cb30") - (revision "0")) - (package - (name "sbcl-iolib") - (version (git-version "0.8.4" revision commit)) - (home-page "https://github.com/sionescu/iolib") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (file-name (git-file-name "cl-iolib" version)) - (sha256 - (base32 "1qqy2yhprkmdn2vmi69akf818q3n99gv8cacv6456af0wjm5p1ga")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list pkg-config sbcl-fiveam)) - (inputs - (list libfixposix - sbcl-alexandria - sbcl-bordeaux-threads - sbcl-cffi - sbcl-idna - sbcl-split-sequence - sbcl-swap-bytes)) - (arguments - '(#:asd-systems '("iolib" - "iolib/os") - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "src/syscalls/ffi-functions-unix.lisp" - (("\\(:default \"libfixposix\"\\)") - (string-append - "(:default \"" - (assoc-ref inputs "libfixposix") "/lib/libfixposix\")"))) - ;; Socket tests need Internet access, disable them. - (substitute* "iolib.asd" - (("\\(:file \"sockets\" :depends-on \\(\"pkgdcl\" \"defsuites\"\\)\\)") - ""))))))) - (synopsis "Common Lisp I/O library") - (description "IOlib is to be a better and more modern I/O library than -the standard Common Lisp library. It contains a socket library, a DNS -resolver, an I/O multiplexer(which supports @code{select(2)}, @code{epoll(4)} -and @code{kqueue(2)}), a pathname library and file-system utilities.") - (license license:expat)))) + (list sbcl-xlunit)) + (arguments + '(#:asd-test-systems '("cl-heap-tests"))) + (synopsis "Heap and priority queue data structures for Common Lisp") + (description + "CL-HEAP provides various implementations of heap data structures (a +binary heap and a Fibonacci heap) as well as an efficient priority queue.") + (home-page "https://common-lisp.net/project/cl-heap/") + (license license:gpl3+))) -(define-public cl-iolib - (let ((parent (sbcl-package->cl-source-package sbcl-iolib))) - (package - (inherit parent) - (propagated-inputs - ;; Need header to compile. - (modify-inputs (package-propagated-inputs parent) - (prepend libfixposix)))))) +(define-public cl-heap + (sbcl-package->cl-source-package sbcl-cl-heap)) -(define-public ecl-iolib - (sbcl-package->ecl-package sbcl-iolib)) +(define-public ecl-cl-heap + (sbcl-package->ecl-package sbcl-cl-heap)) -(define-public sbcl-ieee-floats - (let ((commit "566b51a005e81ff618554b9b2f0b795d3b29398d") +(define-public sbcl-cl-hooks + (let ((commit "5b638083f3b4f1221a52631d9c8a0a265565cac7") (revision "1")) (package - (name "sbcl-ieee-floats") + (name "sbcl-cl-hooks") (build-system asdf-build-system/sbcl) - (version (git-version "20170924" revision commit)) - (home-page "https://github.com/marijnh/ieee-floats/") + (version (git-version "0.2.1" revision commit)) + (home-page "https://github.com/scymtym/architecture.hooks") (source (origin (method git-fetch) @@ -8676,3923 +5966,4094 @@ and @code{kqueue(2)}), a pathname library and file-system utilities.") (file-name (git-file-name name version)) (sha256 (base32 - "1xyj49j9x3lc84cv3dhbf9ja34ywjk1c46dklx425fxw9mkwm83m")))) + "0bg3l0a28lw5gqqjp6p6b5nhwqk46sgkb7184w5qbfngw1hk8x9y")))) + (inputs + (list sbcl-alexandria sbcl-let-plus sbcl-trivial-garbage + sbcl-closer-mop)) (native-inputs (list sbcl-fiveam)) - (synopsis "IEEE 754 binary representation for floats in Common Lisp") - (description "This is a Common Lisp library that converts -floating point values to IEEE 754 binary representation.") - (license license:bsd-3)))) + (synopsis "Hooks extension point mechanism (as in Emacs) for Common Lisp") + (description "A hook, in the present context, is a certain kind of +extension point in a program that allows interleaving the execution of +arbitrary code with the execution of a the program without introducing any +coupling between the two. Hooks are used extensively in the extensible editor +Emacs. -(define-public cl-ieee-floats - (sbcl-package->cl-source-package sbcl-ieee-floats)) +In the Common LISP Object System (CLOS), a similar kind of extensibility is +possible using the flexible multi-method dispatch mechanism. It may even seem +that the concept of hooks does not provide any benefits over the possibilities +of CLOS. However, there are some differences: -(define-public ecl-ieee-floats - (sbcl-package->ecl-package sbcl-ieee-floats)) +@itemize -(define sbcl-closure-common - (let ((commit "e3c5f5f454b72b01b89115e581c3c52a7e201e5c") - (revision "1")) +@item There can be only one method for each combination of specializers and +qualifiers. As a result this kind of extension point cannot be used by +multiple extensions independently. +@item Removing code previously attached via a @code{:before}, @code{:after} or +@code{:around} method can be cumbersome. +@item There could be other or even multiple extension points besides @code{:before} +and @code{:after} in a single method. +@item Attaching codes to individual objects using eql specializers can be +cumbersome. +@item Introspection of code attached a particular extension point is +cumbersome since this requires enumerating and inspecting the methods of a +generic function. +@end itemize + +This library tries to complement some of these weaknesses of method-based +extension-points via the concept of hooks.") + (license license:llgpl)))) + +(define-public cl-hooks + (sbcl-package->cl-source-package sbcl-cl-hooks)) + +(define-public ecl-cl-hooks + (sbcl-package->ecl-package sbcl-cl-hooks)) + +(define-public sbcl-cl-html-diff + (let ((commit "5a0b39d1c524278d6f60851d7786bb2585614310") + (revision "0")) (package - (name "sbcl-closure-common") - (build-system asdf-build-system/sbcl) - (version (git-version "20101006" revision commit)) - (home-page "https://common-lisp.net/project/cxml/") + (name "sbcl-cl-html-diff") + (version (git-version "0.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/sharplispers/closure-common") + (url "https://github.com/wiseman/cl-html-diff") (commit commit))) - (file-name (git-file-name name version)) + (file-name + (git-file-name name version)) (sha256 - (base32 - "0k5r2qxn122pxi301ijir3nayi9sg4d7yiy276l36qmzwhp4mg5n")))) + (base32 "1varnijivzd4jpimn1cz8p5ks713zzha5cgl4vmb0xr8ahravwzb")))) + (build-system asdf-build-system/sbcl) (inputs - `(("trivial-gray-streams" ,sbcl-trivial-gray-streams) - ("babel" ,sbcl-babel))) - (synopsis "Support Common Lisp library for CXML") - (description "Closure-common is an internal helper library. The name -Closure is a reference to the web browser it was originally written for.") - ;; TODO: License? - (license #f)))) + (list sbcl-cl-difflib)) + (home-page "https://github.com/wiseman/cl-html-diff") + (synopsis "Generate a human-readable diff of two HTML documents") + (description + "A Common Lisp library for generating a human-readable diff of two +HTML documents.") + (license license:expat)))) -(define-public sbcl-cxml - (let ((commit "00b22bf4c4cf11c993d5866fae284f95ab18e6bf") +(define-public cl-html-diff + (sbcl-package->cl-source-package sbcl-cl-html-diff)) + +(define-public ecl-cl-html-diff + (sbcl-package->ecl-package sbcl-cl-html-diff)) + +(define-public sbcl-cl-html5-parser + (let ((commit "74a92eb3a183a0afd089ea33350e816e6b9aeefa") (revision "1")) (package - (name "sbcl-cxml") + (name "sbcl-cl-html5-parser") (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/sharplispers/cxml") + (url "https://github.com/rotatef/cl-html5-parser") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-html5-parser" version)) (sha256 - (base32 - "13kif7rf3gqdycsk9zq0d7y0g9y81krkl0z87k0p2fkbjfgrph37")))) + (base32 "04if61wigylsmn996rbfl8ylsd0d9hzdmg7p2wiglncibjzcl5k9")))) (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-closure-common sbcl-puri sbcl-trivial-gray-streams)) - (synopsis "Common Lisp XML parser") - (description "CXML implements a namespace-aware, validating XML 1.0 -parser as well as the DOM Level 2 Core interfaces. Two parser interfaces are -offered, one SAX-like, the other similar to StAX.") - (home-page "https://common-lisp.net/project/cxml/") - (license license:llgpl)))) + (native-inputs + (list sbcl-json-streams sbcl-split-sequence sbcl-stefil)) + (inputs + (list sbcl-cl-ppcre sbcl-flexi-streams sbcl-string-case)) + (synopsis "HTML5 parser for Common Lisp") + (description "This a Common Lisp library to parse HTML5 documents.") + (home-page "https://github.com/rotatef/cl-html5-parser") + (license license:lgpl3+)))) -(define-public cl-cxml - (sbcl-package->cl-source-package sbcl-cxml)) +(define-public cl-html5-parser + (sbcl-package->cl-source-package sbcl-cl-html5-parser)) -(define-public ecl-cxml - (sbcl-package->ecl-package sbcl-cxml)) +(define-public ecl-cl-html5-parser + (sbcl-package->ecl-package sbcl-cl-html5-parser)) -(define-public sbcl-cxml-rng - (let ((commit "bdcfeb92798694b2935a8321e641d8803e814b7b") - (revision "1")) +(define-public sbcl-cl-https-everywhere + ;; No release. + ;; Don't forget to update the https-everywhere input. + (let ((commit "cbcc73b985a5b1c0ce0d4ec38bc982a0538d4bd8")) (package - (name "sbcl-cxml-rng") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-cl-https-everywhere") + (version (git-version "0.0.0" "1" commit)) (source (origin (method git-fetch) (uri (git-reference - (url "http://www.lichteblau.com/git/cxml-rng.git") + (url "https://github.com/ruricolist/cl-https-everywhere/") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 - "1rld038hmvm0whaffkszd5ks7mg44z1vfbgddal434df8sgspzql")))) + (base32 "1wcvx1icwym1ncd6wl1wxzkyyndrm796caalbklvjd4a2cbl3xxi")))) (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-cxml sbcl-cl-ppcre sbcl-cl-yacc sbcl-parse-number - sbcl-cl-base64)) - (synopsis "Relax NG for Closure XML (CXML)") - (description "An implementation of Relax NG schema validation written in -Common Lisp, including support for compact syntax, DTD Compatibility, and the -XSD type library.") - (home-page "http://www.lichteblau.com/cxml-rng/") - (license license:bsd-2)))) - -(define-public cl-cxml-rng - (sbcl-package->cl-source-package sbcl-cxml-rng)) + (inputs + `(("alexandria" ,sbcl-alexandria) + ("global-vars" ,sbcl-global-vars) + ("parenscript" ,sbcl-parenscript) + ("cl-markdown" ,sbcl-cl-markdown) + ("cl-tld" ,sbcl-cl-tld) + ("fxml" ,sbcl-fxml) + ("overlord" ,sbcl-overlord) + ("ppcre" ,sbcl-cl-ppcre) + ("serapeum" ,sbcl-serapeum) + ("trivial-gray-streams" ,sbcl-trivial-gray-streams) + ("vernacular" ,sbcl-vernacular))) + (native-inputs + `(("fiveam" ,sbcl-fiveam) + ("https-everywhere" + ,(let ((version "2021.7.13")) + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/EFForg/https-everywhere") + (commit version))) + (file-name (git-file-name "https-everywhere" version)) + (sha256 + (base32 + "1k5gj29imhxf47sv3d8rxyrgr6k65scp2fm040va3nfshayslzia"))))))) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'link-https-everywhere-repo + (lambda* (#:key inputs #:allow-other-keys) + (let ((https-everywhere (assoc-ref inputs "https-everywhere"))) + (symlink https-everywhere "https-everywhere")))) + (add-after 'unpack 'fix-overlord-build + ;; Upstream bugs? See + ;; https://github.com/ruricolist/cl-https-everywhere/issues/1. + (lambda* (#:key outputs #:allow-other-keys) + (let* ((out (assoc-ref outputs "out")) + (rulesets.xml (string-append out "/share/common-lisp/" (%lisp-type) + "/cl-https-everywhere/rulesets.xml"))) + (substitute* "build.lisp" + (("\\(depends-on https-everywhere-version\\)") "") + ;; Don't rebuild the rulesets just because the timestamp is epoch. + (("\\(vernacular:require-default :cl-https-everywhere/rulesets-file \"rulesets.xml\"\\)") + (format #f "(if (uiop:file-exists-p ~s) + (compile-rulesets ~s) + (vernacular:require-default :cl-https-everywhere/rulesets-file \"rulesets.xml\"))" + rulesets.xml + rulesets.xml)) + (("\\(uiop:parse-unix-namestring \"https-everywhere/src/chrome/content/rules/\\*\\.xml\")") + "\"https-everywhere/src/chrome/content/rules/*.xml\"") + (("\\(out temp :external-format :utf-8\\)") + "(out temp :external-format :utf-8 :if-exists :supersede)"))) + #t))))) + (home-page "https://github.com/ruricolist/cl-https-everywhere/") + (synopsis "Use HTTPS Everywhere rules from Lisp") + (description + "CL-HTTPS-EVERYWHERE parses HTTPS Everywhere rulesets and makes them +available for use in Lisp programs.") + (license (list license:expat + ;; For the ruleset + license:gpl2+))))) -;; FIXME: Fails on ECL with -;; In function STRUCTURE-SET, the value of the first argument is -;; #<empty 0x7fffeb0fd440> -;; which is not of the expected type %TYPED-PATTERN. -;; (define-public ecl-cxml-rng -;; (sbcl-package->ecl-package sbcl-cxml-rng)) +(define-public cl-https-everywhere + (sbcl-package->cl-source-package sbcl-cl-https-everywhere)) -(define-public sbcl-cl-reexport - (let ((commit "03ad7a0e7307e510b3b25a622d3c5f8a077879b4") - (revision "2")) +(define-public sbcl-cl-i18n + (let ((commit "acb162a12dac50fc46d83da8934fce85d19e31c4") + (revision "3")) (package - (name "sbcl-cl-reexport") - (build-system asdf-build-system/sbcl) - (version (git-version "0.1" revision commit)) - (home-page "https://github.com/takagi/cl-reexport") + (name "sbcl-cl-i18n") + (version (git-version "0.5.5" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/takagi/cl-reexport") + (url "https://codeberg.org/cage/cl-i18n") (commit commit))) - (file-name (git-file-name "cl-reexport" version)) + (file-name (git-file-name "cl-i18n" version)) (sha256 - (base32 - "02la6z3ickhmh2m87ymm2ijh9nkn7l6slskj99l8a1rhps394qqc")))) + (base32 "1y29cirmlyc406a45sdx39spvnjzbs772c977075ccicz46qaxz7")))) + (build-system asdf-build-system/sbcl) (inputs - (list sbcl-alexandria)) - (native-inputs - (list sbcl-prove)) - (synopsis "Reexport external symbols in other Common Lisp packages") + (list sbcl-alexandria sbcl-babel sbcl-cl-ppcre-unicode)) + (synopsis "Internationalisation framework for Common Lisp") (description - "Cl-reexport makes a package reexport symbols which are external -symbols in other Common Lisp packages. This functionality is intended to be -used with (virtual) hierarchical packages.") + "This is a Gettext-style internationalisation framework for Common +Lisp.") + (home-page "https://codeberg.org/cage/cl-i18n") (license license:llgpl)))) -(define-public cl-reexport - (sbcl-package->cl-source-package sbcl-cl-reexport)) +(define-public cl-i18n + (sbcl-package->cl-source-package sbcl-cl-i18n)) -(define-public ecl-cl-reexport - (sbcl-package->ecl-package sbcl-cl-reexport)) +(define-public ecl-cl-i18n + (sbcl-package->ecl-package sbcl-cl-i18n)) -(define-public sbcl-cl-cookie - (let ((commit "cea55aed8b9ad25fafd13defbcb9fe8f41b29546") - (revision "1")) +(define-public sbcl-cl-indentify + (let ((commit "eb770f434defa4cd41d84bca822428dfd0dbac53")) (package - (name "sbcl-cl-cookie") - (build-system asdf-build-system/sbcl) - (version (git-version "0.9.10" revision commit)) - (home-page "https://github.com/fukamachi/cl-cookie") + (name "sbcl-cl-indentify") + (version (git-version "0.1" "1" commit)) (source (origin (method git-fetch) (uri (git-reference - (url home-page) + (url "https://github.com/yitzchak/cl-indentify") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name name commit)) (sha256 - (base32 - "090g7z75h98zvc1ldx0vh4jn4086dhjm2w30jcwkq553qmyxwl8h")))) + (base32 "0ha36bhg474vr76vfhr13szc8cfdj1ickg92k1icz791bqaqg67p")))) + (build-system asdf-build-system/sbcl) (inputs - `(("proc-parse" ,sbcl-proc-parse) - ("alexandria" ,sbcl-alexandria) - ("quri" ,sbcl-quri) - ("cl-ppcre" ,sbcl-cl-ppcre) - ("local-time" ,sbcl-local-time))) + (list sbcl-alexandria sbcl-command-line-arguments + sbcl-trivial-gray-streams)) (native-inputs - (list sbcl-prove)) - (arguments - '(#:asd-systems '("cl-cookie-test" "cl-cookie"))) - (synopsis "HTTP cookie manager for Common Lisp") - (description "cl-cookie is a Common Lisp library featuring parsing of -cookie headers, cookie creation, cookie jar creation and more.") - (license license:bsd-2)))) + (list sbcl-trivial-escapes 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 cl-cookie - (sbcl-package->cl-source-package sbcl-cl-cookie)) +(define-public cl-indentify + (sbcl-package->cl-source-package sbcl-cl-indentify)) -(define-public ecl-cl-cookie - (sbcl-package->ecl-package sbcl-cl-cookie)) +(define-public ecl-cl-indentify + (sbcl-package->ecl-package sbcl-cl-indentify)) -(define-public sbcl-dexador - (let ((commit "051cbb784ea3015cef9731eb5a624f3122de84b5") - (revision "2")) +(define-public sbcl-cl-inflector + (let ((commit "f1ab16919ccce3bd82a0042677d9616dde2034fe") + (revision "1")) (package - (name "sbcl-dexador") - (build-system asdf-build-system/sbcl) - (version (git-version "0.9.15" revision commit)) - (home-page "https://github.com/fukamachi/dexador") + (name "sbcl-cl-inflector") + (version (git-version "0.2" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url home-page) + (url "https://github.com/AccelerationNet/cl-inflector") (commit commit))) - (file-name (git-file-name "cl-dexador" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "1sggpi43la8dai102fmkzysh7760hvk6q68f0pkbb9187vz8nd3y")))) + (base32 "1xwwlhik1la4fp984qnx2dqq24v012qv4x0y49sngfpwg7n0ya7y")))) + (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-lisp-unit2)) (inputs - (list sbcl-alexandria - sbcl-babel - sbcl-bordeaux-threads - sbcl-chipz - sbcl-chunga - sbcl-cl+ssl - sbcl-cl-base64 - sbcl-cl-cookie - sbcl-cl-ppcre - sbcl-fast-http - sbcl-fast-io - sbcl-quri - sbcl-trivial-garbage - sbcl-trivial-gray-streams - sbcl-trivial-mimes - sbcl-usocket)) - ;; These native-inputs are for tests only, which are disabled. - ;; Leave them commented since they add a lot to the closure size. - ;; (native-inputs - ;; (list sbcl-clack - ;; sbcl-lack - ;; sbcl-rove)) - (arguments - ;; TODO: Circular dependency: tests depend on clack-test which depends on dexador. - `(#:tests? #f - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-permissions - (lambda _ (make-file-writable "t/data/test.gz") #t))))) - (synopsis "Yet another HTTP client for Common Lisp") - (description "Dexador is yet another HTTP client for Common Lisp with -neat APIs and connection-pooling. It is meant to supersede Drakma.") + (list sbcl-alexandria sbcl-cl-ppcre)) + (home-page "https://github.com/AccelerationNet/cl-inflector") + (synopsis "Library to pluralize/singularize English and Portuguese words") + (description + "This is a common lisp library to easily pluralize and singularize +English and Portuguese words. This is a port of the ruby ActiveSupport +Inflector module.") (license license:expat)))) -(define-public cl-dexador - (package - (inherit (sbcl-package->cl-source-package sbcl-dexador)) - (arguments - `(#:phases - ;; asdf-build-system/source has its own phases and does not inherit - ;; from asdf-build-system/sbcl phases. - (modify-phases %standard-phases/source - ;; Already done in SBCL package. - (delete 'reset-gzip-timestamps)))))) +(define-public cl-inflector + (sbcl-package->cl-source-package sbcl-cl-inflector)) -(define-public ecl-dexador - (sbcl-package->ecl-package sbcl-dexador)) +(define-public ecl-cl-inflector + (sbcl-package->ecl-package sbcl-cl-inflector)) -(define-public sbcl-lisp-namespace - (let ((commit "699fccb6727027343bb5fca69162a3113996edfc") - (revision "2")) +(define-public sbcl-cl-ini + (let ((commit "e630acb405022a7ae11969bf908669fee1191ab7") + (revision "0")) (package - (name "sbcl-lisp-namespace") - (build-system asdf-build-system/sbcl) + (name "sbcl-cl-ini") (version (git-version "0.1" revision commit)) - (home-page "https://github.com/guicho271828/lisp-namespace") (source (origin (method git-fetch) (uri (git-reference - (url home-page) + (url "https://github.com/compufox/cl-ini") (commit commit))) - (file-name (git-file-name "cl-lisp-namespace" version)) + (file-name (git-file-name "sbcl-cl-ini" version)) (sha256 - (base32 "1p5db9mab4whapy1pl38ajw5fkrrdw266n05mnhf4xx2fb9sbx6p")))) - (inputs - (list sbcl-alexandria)) - (native-inputs - (list sbcl-fiveam)) - (synopsis "LISP-N, or extensible namespaces in Common Lisp") - (description "Common Lisp already has major 2 namespaces, function -namespace and value namespace (or variable namespace), but there are actually -more — e.g., class namespace. -This library offers macros to deal with symbols from any namespace.") - (license license:llgpl)))) + (base32 + "12vy3gspqn0wmkyz5id1xrgv1scgb16m7pkvmbmi19vlpj2iyq7p")))) + (build-system asdf-build-system/sbcl) + (native-inputs (list sbcl-prove)) + (inputs (list sbcl-cl-str)) + (home-page "https://github.com/compufox/cl-ini") + (synopsis "INI file parser for Common Lisp") + (description + "Parse INI formatted files into a Common Lisp list structure.") + (license license:expat)))) -(define-public cl-lisp-namespace - (sbcl-package->cl-source-package sbcl-lisp-namespace)) +(define-public cl-ini + (sbcl-package->cl-source-package sbcl-cl-ini)) -(define-public ecl-lisp-namespace - (sbcl-package->ecl-package sbcl-lisp-namespace)) +(define-public ecl-cl-ini + (sbcl-package->ecl-package sbcl-cl-ini)) -(define-public sbcl-trivial-cltl2 - (let ((commit "8a3bda30dc25d2f65fcf514d0eb6e6db75252c61") - (revision "2")) +(define-public sbcl-cl-inotify + (let ((commit "66f29e01ec28355ebba8292411b4de90eebd76a3") + (revision "0")) (package - (name "sbcl-trivial-cltl2") - (build-system asdf-build-system/sbcl) - (version (git-version "0.1.1" revision commit)) - (home-page "https://github.com/Zulu-Inuoe/trivial-cltl2") + (name "sbcl-cl-inotify") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url home-page) + (url "https://github.com/Ferada/cl-inotify") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-inotify" version)) (sha256 - (base32 - "08cnzb9rnczn4pn2zpf0587ny4wjy1mjndy885fz9pw7xrlx37ip")))) - (synopsis "Simple CLtL2 compatibility layer for Common Lisp") - (description "This library is a portable compatibility layer around -\"Common Lisp the Language, 2nd -Edition\" (@url{https://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node102.html}) -and it exports symbols from implementation-specific packages.") - (license license:llgpl)))) + (base32 "0d3bvp5lqnddzhk1w9yyli03njbkhc8d129a058g0j49kgd47c7v")))) + (build-system asdf-build-system/sbcl) + (native-inputs (list sbcl-fiveam)) + (inputs + (list libfixposix + sbcl-binary-types + sbcl-cffi + sbcl-osicat + sbcl-trivial-utf-8)) + (synopsis "Common Lisp interface to the Linux inotify API") + (description + "@code{cl-inotify} uses @code{cl-cffi} to provide a Common Lisp +interface to the Linux inotify API.") + (home-page "https://github.com/Ferada/cl-inotify/") + (license license:bsd-2)))) -(define-public cl-trivial-cltl2 - (sbcl-package->cl-source-package sbcl-trivial-cltl2)) +(define-public cl-inotify + (sbcl-package->cl-source-package sbcl-cl-inotify)) -(define-public ecl-trivial-cltl2 - (sbcl-package->ecl-package sbcl-trivial-cltl2)) +(define-public ecl-cl-inotify + (sbcl-package->ecl-package sbcl-cl-inotify)) -(define-public sbcl-introspect-environment - (let ((commit "8fb20a1a33d29637a22943243d1482a20c32d6ae") - (revision "2")) +(define-public sbcl-cl-interpol + (let ((commit "70a1137f41dd8889004dbab9536b1adeac2497aa") + (revision "1")) (package - (name "sbcl-introspect-environment") - (build-system asdf-build-system/sbcl) - (version (git-version "0.1" revision commit)) - (home-page "https://github.com/Bike/introspect-environment") + (name "sbcl-cl-interpol") + (version (git-version "0.2.7" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url home-page) + (url "https://github.com/edicl/cl-interpol") (commit commit))) - (file-name (git-file-name "cl-introspect-environment" version)) + (file-name (git-file-name "cl-interpol" version)) (sha256 - (base32 "1p48jnr1im47529w0ciyar4hfwbivqi57zgllkmfrav09ffigk9s")))) + (base32 + "1kr00zf62m7la7rxa2m5w49r9cyzamc106hvjcc8ffmi7a4jw490")))) + (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-cl-unicode sbcl-named-readtables)) (native-inputs - (list sbcl-fiveam)) - (synopsis "Common Lisp environment introspection portability layer") - (description "This library is a small interface to portable but -nonstandard introspection of Common Lisp environments. It is intended to -allow a bit more compile-time introspection of environments in Common Lisp. + (list sbcl-flexi-streams)) + (synopsis "String interpolation for Common Lisp") + (description + "CL-INTERPOL is a library for Common Lisp which modifies the +reader so that you can have interpolation within strings similar to +Perl or Unix Shell scripts. It also provides various ways to insert +arbitrary characters into literal strings even if your editor/IDE +doesn't support them.") + (home-page "https://edicl.github.io/cl-interpol/") + (license license:bsd-3)))) -Quite a bit of information is available at the time a macro or compiler-macro -runs; inlining info, type declarations, that sort of thing. This information -is all standard - any Common Lisp program can @code{(declare (integer x))} and -such. +(define-public cl-interpol + (sbcl-package->cl-source-package sbcl-cl-interpol)) -This info ought to be accessible through the standard @code{&environment} -parameters, but it is not. Several implementations keep the information for -their own purposes but do not make it available to user programs, because -there is no standard mechanism to do so. +(define-public ecl-cl-interpol + (sbcl-package->ecl-package sbcl-cl-interpol)) -This library uses implementation-specific hooks to make information available -to users. This is currently supported on SBCL, CCL, and CMUCL. Other -implementations have implementations of the functions that do as much as they -can and/or provide reasonable defaults.") - (license license:wtfpl2)))) +(define-public sbcl-cl-ipfs-api2 + (let ((commit "3ee52c80023bcc662f7d01276ea0a5814bd0011b") + (revision "0")) + (package + (name "sbcl-cl-ipfs-api2") + (version (git-version "0.51" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/JadedCtrl/cl-ipfs-api2") + (commit commit))) + (file-name (git-file-name "cl-ipfs-api2" version)) + (sha256 + (base32 "1h0csxk4db1hid793mk5kz3nbjyl7z4ic1zk2wy46k1vz5lnnsph")))) + (build-system asdf-build-system/sbcl) + (arguments + '(#:tests? #f)) ; There are no tests. + (inputs + (list sbcl-arnesi + sbcl-drakma + sbcl-yason)) + (home-page "https://github.com/JadedCtrl/cl-ipfs-api2/") + (synopsis "Bindings for the IPFS HTTP API") + (description + "@code{cl-sbcl-cl-ipfs-api2} is a pretty simple set of IPFS bindings +for Common Lisp, using the HTTP API for (almost) everything, except for pubsub +(which uses the locally installed go-ipfs program).") + (license license:lgpl3)))) -(define-public cl-introspect-environment - (sbcl-package->cl-source-package sbcl-introspect-environment)) +(define-public cl-ipfs-api2 + (sbcl-package->cl-source-package sbcl-cl-ipfs-api2)) -(define-public ecl-introspect-environment - (sbcl-package->ecl-package sbcl-introspect-environment)) +(define-public ecl-cl-ipfs-api2 + (sbcl-package->ecl-package sbcl-cl-ipfs-api2)) -(define-public sbcl-compiler-macro - (let ((commit "7796bda64aec5af3ca175170ad3565167868789c") +(define-public sbcl-cl-irc + (let ((commit "963823537c7bfcda2edd4c44d172192da6722175") (revision "0")) (package - (name "sbcl-compiler-macro") - (version (git-version "0.1" revision commit)) + (name "sbcl-cl-irc") + (version (git-version "0.9.2" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/Bike/compiler-macro") + (url "https://salsa.debian.org/common-lisp-team/cl-irc.git") (commit commit))) - (file-name (git-file-name "cl-compiler-macro" version)) + (file-name (git-file-name "cl-irc" version)) (sha256 - (base32 "13sswps7s0qy6939mvj8q57hkx0qkga6rl6xjhjr7pk7by0xdsjq")))) + (base32 "1b3nqbb4pj377lxl47rfgrs82pidadnrc65l48bk553c2f59b52w")))) (build-system asdf-build-system/sbcl) (native-inputs - (list sbcl-fiveam)) + (list sbcl-rt)) (inputs - (list sbcl-introspect-environment)) - (home-page "https://github.com/Bike/compiler-macro") - (synopsis "Common Lisp compiler macro utilities") - (description "This library is a collection of utilities for writing -compiler macros. It is intended to make it possible to make compiler macros -much more useful, by granting them access to lexical type information, making -the protocol for declining expansion more convenient, and establishing some -information for signaling optimization advice to programmers. Some utilities -to support this, especially for reasoning on types, are also included.") - (license license:cc0)))) + `(("cl+ssl" ,sbcl-cl+ssl) + ("flexi-streams" ,sbcl-flexi-streams) + ("split-sequence" ,sbcl-split-sequence) + ("usocket" ,sbcl-usocket))) + (arguments + `(#:asd-test-systems '("cl-irc-test"))) + (synopsis "IRC client library for Common Lisp") + (description "@code{cl-irc} is a Common Lisp IRC client library that +features (partial) DCC, CTCP and all relevant commands from the IRC +RFCs (RFC2810, RFC2811 and RFC2812). -(define-public cl-compiler-macro - (sbcl-package->cl-source-package sbcl-compiler-macro)) +Features: +@itemize +@item implements all commands in the RFCs +@item extra convenience commands such as op/deop, ban, ignore, etc. +@item partial DCC SEND/CHAT support +@item event driven model with hooks makes interfacing easy +@item the user can keep multiple connections +@item all CTCP commands +@end itemize\n") + (home-page "https://common-lisp.net/project/cl-irc/") + (license license:bsd-2)))) -(define-public ecl-compiler-macro - (sbcl-package->ecl-package sbcl-compiler-macro)) +(define-public cl-irc + (sbcl-package->cl-source-package sbcl-cl-irc)) -(define-public sbcl-type-i - (let ((commit "d34440ab4ebf5a46a58deccb35950b15670e3667") - (revision "2")) +(define-public ecl-cl-irc + (sbcl-package->ecl-package sbcl-cl-irc)) + +(define-public sbcl-cl-isaac + (let ((commit "9cd88f39733be753facbf361cb0e08b9e42ff8d5") + (revision "0")) (package - (name "sbcl-type-i") - (build-system asdf-build-system/sbcl) - (version (git-version "0.1" revision commit)) - (home-page "https://github.com/guicho271828/type-i") + (name "sbcl-cl-isaac") + (version (git-version "1.0.7" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url home-page) + (url "https://github.com/thephoeron/cl-isaac") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-isaac" version)) (sha256 - (base32 - "12wsga0pwjkkr176lnjwkmmlm3ccp0n310sjj9h20lk53iyd0z69")))) - (inputs - `(("alexandria" ,sbcl-alexandria) - ("introspect-environment" ,sbcl-introspect-environment) - ("trivia.trivial" ,sbcl-trivia.trivial))) - (native-inputs - (list sbcl-fiveam)) - (synopsis "Type inference utility on unary predicates for Common Lisp") - (description "This library tries to provide a way to detect what kind of -type the given predicate is trying to check. This is different from inferring -the return type of a function.") - (license license:llgpl)))) + (base32 "0ig1mf8iridfr7vci9gy499194h0hda0xki5s6g0y04g85ibnpw9")))) + (build-system asdf-build-system/sbcl) + (native-inputs (list sbcl-prove)) + (home-page "https://github.com/thephoeron/cl-isaac/") + (synopsis "Fast cryptographic random number generators") + (description "This is an optimized Common Lisp library of Bob Jenkins' +ISAAC-32 and ISAAC-64 algorithms, which are fast cryptographic random number +generators: Indirection, Shift, Accumulate, Add, and Count.") + (license license:bsd-0)))) -(define-public cl-type-i - (sbcl-package->cl-source-package sbcl-type-i)) +(define-public cl-isaac + (sbcl-package->cl-source-package sbcl-cl-isaac)) -(define-public ecl-type-i - (package - (inherit (sbcl-package->ecl-package sbcl-type-i)) - (arguments - ;; The tests get stuck indefinitly - '(#:tests? #f)))) +(define-public ecl-cl-isaac + (sbcl-package->ecl-package sbcl-cl-isaac)) -(define-public sbcl-simplified-types - (let ((commit "8fd0727a70a9de76289ac62c1567b8d278e7434e") - (revision "0")) +(define-public sbcl-cl-jpeg + (let ((commit "ec557038128df6895fbfb743bfe8faf8ec2534af") + (revision "1")) (package - (name "sbcl-simplified-types") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-cl-jpeg") + (version (git-version "2.8" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/marcoheisig/simplified-types") + (url "https://github.com/sharplispers/cl-jpeg") (commit commit))) - (file-name (git-file-name "cl-simplified-types" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "1hdwmn5lz717aj6qdqmfmr3cbjl8l3giwn0fb5ca9pj83cx7fg8y")))) + (base32 "1bkkiqz8fqldlj1wbmrccjsvxcwj98h6s4b6gslr3cg2wmdv5xmy")))) (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-alexandria - sbcl-introspect-environment - sbcl-trivia)) - (home-page "https://github.com/marcoheisig/simplified-types") - (synopsis "Simplify Common Lisp type specifiers") + (synopsis "JPEG image library for Common Lisp") (description - "Simplified-Types is a library that provides functions for simplifying -Common Lisp type specifiers. The API consists of two functions: + "This is a baseline JPEG codec written in Common Lisp. It can be used +for reading and writing JPEG image files.") + (home-page "https://github.com/sharplispers/cl-jpeg") + (license license:bsd-3)))) -@itemize -@item @code{simplify-type} takes a type specifier and, optionally, an -environment, and returns the corresponding simplified type. -@item @code{simplified-type-of} takes an object and returns the simplified -type of that object. -@end itemize") - (license license:expat)))) +(define-public cl-jpeg + (sbcl-package->cl-source-package sbcl-cl-jpeg)) -(define-public cl-simplified-types - (sbcl-package->cl-source-package sbcl-simplified-types)) +(define-public ecl-cl-jpeg + (sbcl-package->ecl-package sbcl-cl-jpeg)) -(define-public ecl-simplified-types - (sbcl-package->ecl-package sbcl-simplified-types)) +(define-public sbcl-cl-json + (package + (name "sbcl-cl-json") + (version "0.6.0") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/sharplispers/cl-json") + (commit (string-append "v" version)))) + (file-name (git-file-name "cl-json" version)) + (sha256 + (base32 "12vakz47d1i7pywgb9cm2364fzykidc9m7l7b6n9lx0gn2qx9ar5")))) + (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-fiveam)) + (home-page "https://github.com/sharplispers/cl-json") + (synopsis "JSON encoder and decoder for Common-Lisp") + (description "@command{cl-json} provides an encoder of Lisp objects +to JSON format and a corresponding decoder of JSON data to Lisp +objects. Both the encoder and the decoder are highly customizable; at the +same time, the default settings ensure a very simple mode of operation, +similar to that provided by @command{yason} or @command{st-json}.") + (license license:expat))) -(define-public sbcl-typo - (let ((commit "0e883490f81edf2a1be4e5b101d1caec78d7853b") +(define-public cl-json + (sbcl-package->cl-source-package sbcl-cl-json)) + +(define-public ecl-cl-json + (sbcl-package->ecl-package sbcl-cl-json)) + +(define-public sbcl-cl-json-pointer + (let ((commit "f6760e2a02972783f96b92a15f801e14a6828e0c") (revision "0")) (package - (name "sbcl-typo") + (name "sbcl-cl-json-pointer") (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/marcoheisig/Typo") + (url "https://github.com/y2q-actionman/cl-json-pointer") (commit commit))) - (file-name (git-file-name "cl-typo" version)) + (file-name (git-file-name "cl-json-pointer" version)) (sha256 - (base32 "08cmkjl3f77rfhxbjyd6f3kinhzak30mdfphnpf73sh1vw4v0vym")))) + (base32 "0b7a755wc2ghsd1pv7d32877b21h4nssp41xs017anbmj55czb2h")))) (build-system asdf-build-system/sbcl) + (arguments + ;; FIXME: Component "cl-json-pointer/test" not found. + `(#:tests? #f + #:asd-systems '("cl-json-pointer" "cl-json-pointer/synonyms"))) (inputs (list sbcl-alexandria + sbcl-boost-json + sbcl-cl-json sbcl-closer-mop - sbcl-introspect-environment - sbcl-trivia - sbcl-trivial-arguments - sbcl-trivial-garbage)) - (home-page "https://github.com/marcoheisig/Typo") - (synopsis "Portable type inference library for Common Lisp") - (description - "Typo is a portable library for Common Lisp that does approximate -reasoning about types, but without consing.") + sbcl-st-json)) + (home-page "https://github.com/y2q-actionman/cl-json-pointer") + (synopsis "JSON Pointer processor for Common Lisp") + (description " +This package provides a JSON +Pointer (@url{https://tools.ietf.org/html/rfc6901,RFC6901}) implementation for +Common Lisp. This libary aims to be independent from any JSON libraries (as much +as possible).") (license license:expat)))) -(define-public cl-typo - (sbcl-package->cl-source-package sbcl-typo)) +(define-public cl-json-pointer + (sbcl-package->cl-source-package sbcl-cl-json-pointer)) -(define-public ecl-typo - (sbcl-package->ecl-package sbcl-typo)) +(define-public ecl-cl-json-pointer + (sbcl-package->ecl-package sbcl-cl-json-pointer)) -(define-public sbcl-optima - (let ((commit "373b245b928c1a5cce91a6cb5bfe5dd77eb36195") +(define-public sbcl-cl-ledger + (let ((commit "08e0be41795e804cd36142e51756ad0b1caa377b") (revision "1")) (package - (name "sbcl-optima") - (build-system asdf-build-system/sbcl) - (version (git-version "1.0" revision commit)) - (home-page "https://github.com/m2ym/optima") + (name "sbcl-cl-ledger") + (version (git-version "4.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url home-page) + (url "https://github.com/ledger/cl-ledger") (commit commit))) (file-name (git-file-name name version)) (sha256 (base32 - "1yw4ymq7ms89342kkvb3aqxgv0w38m9kd8ikdqxxzyybnkjhndal")))) + "1via0qf6wjcyxnfbmfxjvms0ik9j8rqbifgpmnhrzvkhrq9pv8h1")))) + (build-system asdf-build-system/sbcl) (inputs - `(("alexandria" ,sbcl-alexandria) - ("closer-mop" ,sbcl-closer-mop))) - (native-inputs - (list sbcl-eos)) + `(("cambl" ,sbcl-cambl) + ("cl-ppcre" ,sbcl-cl-ppcre) + ("local-time" ,sbcl-local-time) + ("periods" ,sbcl-periods))) (arguments - ;; XXX: Circular dependencies: tests depend on optima.ppcre which depends on optima. - `(#:tests? #f)) - (synopsis "Optimized pattern matching library for Common Lisp") - (description "Optima is a fast pattern matching library which uses -optimizing techniques widely used in the functional programming world.") - (license license:expat)))) + '(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'fix-system-definition + (lambda _ + (substitute* "cl-ledger.asd" + ((" :build-operation program-op") "") + ((" :build-pathname \"cl-ledger\"") "") + ((" :entry-point \"ledger::main\"") "")) + #t))))) + (synopsis "Common Lisp port of the Ledger accounting system") + (description + "CL-Ledger is a Common Lisp port of the Ledger double-entry accounting +system.") + (home-page "https://github.com/ledger/cl-ledger") + (license license:bsd-3)))) -(define-public cl-optima - (sbcl-package->cl-source-package sbcl-optima)) +(define-public cl-ledger + (sbcl-package->cl-source-package sbcl-cl-ledger)) -(define-public ecl-optima - (sbcl-package->ecl-package sbcl-optima)) +(define-public ecl-cl-ledger + (sbcl-package->ecl-package sbcl-cl-ledger)) -(define-public sbcl-fare-quasiquote - (let ((commit "640d39a0451094071b3e093c97667b3947f43639") +(define-public sbcl-cl-lex + (let ((commit "f2dbbe25ef553005fb402d9a6203180c3fa1093b") (revision "1")) (package - (name "sbcl-fare-quasiquote") - (build-system asdf-build-system/sbcl) - (version (git-version "1.0.1" revision commit)) - (home-page "https://gitlab.common-lisp.net/frideau/fare-quasiquote") + (name "sbcl-cl-lex") + (version (git-version "1.1.3" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url (string-append "https://gitlab.common-lisp.net/frideau/" - "fare-quasiquote.git")) + (url "https://github.com/djr7C4/cl-lex") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 "1g6q11l50kgija9f55lzqpcwvaq0ljiw8v1j265hnyg6nahjwjvg")))) + (base32 "1kg50f76bfpfxcv4dfivq1n9a0xlsra2ajb0vd68lxwgbidgyc2y")))) + (build-system asdf-build-system/sbcl) (inputs - `(("fare-utils" ,sbcl-fare-utils) - ("named-readtables" ,sbcl-named-readtables) - ("optima" ,sbcl-optima))) - (arguments - ;; XXX: Circular dependencies: Tests depend on subsystems, - ;; which depend on the main systems. - `(#:tests? #f - #:asd-systems '("fare-quasiquote" - "fare-quasiquote-extras") - #:phases - (modify-phases %standard-phases - ;; XXX: Require 1.0.0 version of fare-utils, and we package some - ;; commits after 1.0.0.5, but ASDF fails to read the - ;; "-REVISION-COMMIT" part generated by Guix. - (add-after 'unpack 'patch-requirement - (lambda _ - (substitute* "fare-quasiquote.asd" - (("\\(:version \"fare-utils\" \"1.0.0\"\\)") - "\"fare-utils\"")) - (substitute* "fare-quasiquote-optima.asd" - (("\\(:version \"optima\" \"1\\.0\"\\)") - "\"optima\"")) - #t))))) - (synopsis "Pattern-matching friendly implementation of quasiquote") - (description "The main purpose of this n+2nd reimplementation of -quasiquote is enable matching of quasiquoted patterns, using Optima or -Trivia.") - (license license:expat)))) + (list sbcl-cl-ppcre)) + (synopsis "Common Lisp macros for generating lexical analyzers") + (description + "This is a Common Lisp library providing a set of macros for generating +lexical analyzers automatically. The lexers generated using @code{cl-lex} can +be used with @code{cl-yacc}.") + (home-page "https://github.com/djr7C4/cl-lex") + (license license:gpl3)))) -(define-public cl-fare-quasiquote - (sbcl-package->cl-source-package sbcl-fare-quasiquote)) +(define-public cl-lex + (sbcl-package->cl-source-package sbcl-cl-lex)) -(define-public ecl-fare-quasiquote - (sbcl-package->ecl-package sbcl-fare-quasiquote)) +(define-public ecl-cl-lex + (sbcl-package->ecl-package sbcl-cl-lex)) -;;; 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 "8b406c3f83521d290e97bb787d3f6c1eb3b716af") - (revision "0")) +(define-public sbcl-cl-liballegro + (let ((commit "49f632ce97fc4f835bf5d450588793234b980a64") + (revision "1")) (package - (name "sbcl-trivia.trivial") - (version (git-version "0.1" revision commit)) + (name "sbcl-cl-liballegro") + (version (git-version "0.2.15" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/guicho271828/trivia") + (url "https://github.com/resttime/cl-liballegro") (commit commit))) - (file-name (git-file-name "cl-trivia" version)) + (file-name (git-file-name name version)) (sha256 - (base32 - "0fnnjnba07qrsf82jm4q6dini7z72xabcssy5y2bqy082r07l8l7")))) + (base32 "0brbr7i342s0gadlnzd3a61w2b9ihhx60l19ararnc2asvyhmz7x")))) (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-alexandria - sbcl-closer-mop - sbcl-lisp-namespace - sbcl-trivial-cltl2)) (arguments - '(#:phases + `(#:phases (modify-phases %standard-phases - (add-after 'unpack 'fix-build - (lambda _ - (for-each delete-file - '("trivia.balland2006.asd" - "trivia.ppcre.asd" - "trivia.quasiquote.asd" - "trivia.cffi.asd" - "trivia.fset.asd" - "trivia.asd" - "trivia.test.asd"))))))) - (synopsis "Pattern matching in Common Lisp") - (description "Trivia is a pattern matching compiler that is compatible -with Optima, another pattern matching library for Common Lisp. It is meant to -be faster and more extensible than Optima.") - (home-page "https://github.com/guicho271828/trivia") - (license license:llgpl)))) - -(define-public cl-trivia.trivial - (sbcl-package->cl-source-package sbcl-trivia.trivial)) - -(define-public ecl-trivia.trivial - (sbcl-package->ecl-package sbcl-trivia.trivial)) - -(define-public sbcl-trivia - (package - (inherit sbcl-trivia.trivial) - (name "sbcl-trivia") - (native-inputs - (list sbcl-fiveam - sbcl-optima)) - (inputs - (list sbcl-alexandria - sbcl-cffi - sbcl-cl-ppcre - sbcl-fare-quasiquote - sbcl-fset - sbcl-iterate - sbcl-trivia.trivial - sbcl-type-i)) - (arguments - '(#:asd-systems '("trivia" - "trivia.ppcre" - "trivia.quasiquote" - "trivia.cffi" - "trivia.fset") - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-build - (lambda _ - (for-each delete-file - '("trivia.level0.asd" - "trivia.level1.asd" - "trivia.level2.asd" - "trivia.trivial.asd"))))))))) - -(define-public cl-trivia - (sbcl-package->cl-source-package sbcl-trivia)) - -(define-public ecl-trivia - (sbcl-package->ecl-package sbcl-trivia)) - -(define-public sbcl-mk-string-metrics - (package - (name "sbcl-mk-string-metrics") - (version "0.1.2") - (home-page "https://github.com/cbaggers/mk-string-metrics/") - (source (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit version))) - (sha256 - (base32 "0bg0bv2mfd4k0g3x72x563hvmrx18xavaffr6xk5rh4if5j7kcf6")) - (file-name (git-file-name name version)))) - (build-system asdf-build-system/sbcl) - (synopsis "Calculate various string metrics efficiently in Common Lisp") - (description "This library implements efficient algorithms that calculate -various string metrics in Common Lisp: - -@itemize -@item Damerau-Levenshtein distance -@item Hamming distance -@item Jaccard similarity coefficient -@item Jaro distance -@item Jaro-Winkler distance -@item Levenshtein distance -@item Normalized Damerau-Levenshtein distance -@item Normalized Levenshtein distance -@item Overlap coefficient -@end itemize\n") - (license license:x11))) - -(define-public cl-mk-string-metrics - (sbcl-package->cl-source-package sbcl-mk-string-metrics)) - -(define-public ecl-mk-string-metrics - (sbcl-package->ecl-package sbcl-mk-string-metrics)) - -(define-public sbcl-cl-str - (package - (name "sbcl-cl-str") - (version "0.19") - (home-page "https://github.com/vindarel/cl-str") - (source (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit version))) - (sha256 - (base32 "1jyza2jhn7w6fl4w87pv0m87z5ia48m6dqw12k0mdh7l3mgjq839")) - (file-name (git-file-name name version)))) - (build-system asdf-build-system/sbcl) - (inputs - `(("cl-ppcre" ,sbcl-cl-ppcre) - ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode) - ("cl-change-case" ,sbcl-cl-change-case))) - (native-inputs - (list sbcl-prove)) - (arguments - `(#:asd-systems '("str"))) - (synopsis "Modern, consistent and terse Common Lisp string manipulation library") - (description "A modern and consistent Common Lisp string manipulation -library that focuses on modernity, simplicity and discoverability: -@code{(str:trim s)} instead of @code{(string-trim '(#\\Space ...) s)}), or -@code{str:concat strings} instead of an unusual format construct; one -discoverable library instead of many; consistency and composability, where -@code{s} is always the last argument, which makes it easier to feed pipes and -arrows.") - (license license:expat))) + (add-after 'unpack 'patch-allegro-lib-path + (lambda* (#:key inputs #:allow-other-keys) + (let ((allegro-lib-path (string-append + (assoc-ref inputs "allegro") "/lib/"))) + (substitute* "src/library.lisp" + (("lib \".so\"" all) + (string-append "\"" allegro-lib-path "\"" " lib \".so\""))))))))) + (inputs + `(("allegro" ,allegro) + ("cffi" ,sbcl-cffi) + ("float-features" ,sbcl-float-features) + ("trivial-garbage" ,sbcl-trivial-garbage) + ("trivial-main-thread" ,sbcl-trivial-main-thread))) + (home-page "https://github.com/resttime/cl-liballegro") + (synopsis "Allegro 5 game programming library bindings for Common Lisp") + (description + "This package provides CFFI bindings and interface to Allegro 5 game +developing library for Common Lisp.") + (license license:zlib)))) -(define-public cl-str - (sbcl-package->cl-source-package sbcl-cl-str)) +(define-public cl-liballegro + (sbcl-package->cl-source-package sbcl-cl-liballegro)) -(define-public ecl-cl-str - (sbcl-package->ecl-package sbcl-cl-str)) +(define-public ecl-cl-liballegro + (sbcl-package->ecl-package sbcl-cl-liballegro)) -(define-public sbcl-cl-xmlspam - (let ((commit "ea06abcca2a73a9779bcfb09081e56665f94e22a")) +(define-public sbcl-cl-libsvm-format + (let ((commit "3300f84fd8d9f5beafc114f543f9d83417c742fb") + (revision "0")) (package - (name "sbcl-cl-xmlspam") - (build-system asdf-build-system/sbcl) - (version (git-version "0.0.0" "1" commit)) - (home-page "https://github.com/rogpeppe/cl-xmlspam") + (name "sbcl-cl-libsvm-format") + (version (git-version "0.1.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url home-page) + (url "https://github.com/masatoi/cl-libsvm-format") (commit commit))) - (file-name (string-append name "-" version)) + (file-name (git-file-name name version)) (sha256 (base32 - "0w4rqvrgdgk3fwfq3kx4r7wwdr2bv3b6n3bdqwsiriw9psqzpz2s")))) + "0284aj84xszhkhlivaigf9qj855fxad3mzmv3zfr0qzb5k0nzwrg")))) + (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-prove)) (inputs - (list sbcl-cxml sbcl-cl-ppcre)) - (synopsis "Concise, regexp-like pattern matching on streaming XML for Common Lisp") - (description "CXML does an excellent job at parsing XML elements, but what -do you do when you have a XML file that's larger than you want to fit in -memory, and you want to extract some information from it? Writing code to deal -with SAX events, or even using Klacks, quickly becomes tedious. -@code{cl-xmlspam} (for XML Stream PAttern Matcher) is designed to make it easy -to write code that mirrors the structure of the XML that it's parsing. It -also makes it easy to shift paradigms when necessary - the usual Lisp control -constructs can be used interchangeably with pattern matching, and the full -power of CXML is available when necessary.") - (license license:bsd-3)))) + (list sbcl-alexandria)) + (synopsis "LibSVM data format reader for Common Lisp") + (description + "This Common Lisp library provides a fast reader for data in LibSVM +format.") + (home-page "https://github.com/masatoi/cl-libsvm-format") + (license license:expat)))) -(define-public cl-xmlspam - (sbcl-package->cl-source-package sbcl-cl-xmlspam)) +(define-public cl-libsvm-format + (sbcl-package->cl-source-package sbcl-cl-libsvm-format)) -(define-public ecl-cl-xmlspam - (sbcl-package->ecl-package sbcl-cl-xmlspam)) +(define-public ecl-cl-libsvm-format + (sbcl-package->ecl-package sbcl-cl-libsvm-format)) -(define-public sbcl-dbus - (let ((commit "24b452df3a45ca5dc95015500f34baad175c981a") +(define-public sbcl-cl-libuv + (let ((commit "32100c023c518038d0670a103eaa4d50dd785d29") (revision "1")) (package - (name "sbcl-dbus") - (version (git-version "20190408" revision commit)) - (home-page "https://github.com/death/dbus") + (name "sbcl-cl-libuv") + (version (git-version "0.1.6" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url home-page) + (url "https://github.com/orthecreedence/cl-libuv") (commit commit))) (file-name (git-file-name name version)) (sha256 (base32 - "0fw2q866yddbf23nk9pxphm9gsasx35vjyss82xzvndnjmzlqfl5")))) + "1kwix4si8a8hza34ab2k7whrh7z0yrmx39v2wc3qblv9m244jkh1")))) (build-system asdf-build-system/sbcl) (inputs - (list sbcl-alexandria - sbcl-trivial-garbage - sbcl-babel - sbcl-iolib - sbcl-ieee-floats - sbcl-flexi-streams - sbcl-cl-xmlspam - sbcl-ironclad)) - (synopsis "D-Bus client library for Common Lisp") - (description "This is a Common Lisp library that publishes D-Bus -objects as well as send and notify other objects connected to a bus.") - (license license:bsd-2)))) + `(("alexandria" ,sbcl-alexandria) + ("cffi" ,sbcl-cffi) + ("libuv" ,libuv))) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'fix-paths + (lambda* (#:key inputs #:allow-other-keys) + (substitute* "lib.lisp" + (("/usr/lib/libuv.so") + (search-input-file inputs "/lib/libuv.so"))))) + (add-after 'fix-paths 'fix-system-definition + (lambda _ + (substitute* "cl-libuv.asd" + (("#:cffi #:alexandria") + "#:cffi #:cffi-grovel #:alexandria")) + #t))))) + (synopsis "Common Lisp bindings to libuv") + (description + "This library provides low-level libuv bindings for Common Lisp.") + (home-page "https://github.com/orthecreedence/cl-libuv") + (license license:expat)))) -(define-public cl-dbus - (sbcl-package->cl-source-package sbcl-dbus)) +(define-public cl-libuv + (sbcl-package->cl-source-package sbcl-cl-libuv)) -(define-public ecl-dbus - (sbcl-package->ecl-package sbcl-dbus)) +(define-public ecl-cl-libuv + (sbcl-package->ecl-package sbcl-cl-libuv)) -(define-public sbcl-cl-hooks - (let ((commit "5b638083f3b4f1221a52631d9c8a0a265565cac7") - (revision "1")) +(define-public sbcl-cl-libxml2 + (let ((commit "8d03110c532c1a3fe15503fdfefe82f60669e4bd")) (package - (name "sbcl-cl-hooks") - (build-system asdf-build-system/sbcl) - (version (git-version "0.2.1" revision commit)) - (home-page "https://github.com/scymtym/architecture.hooks") + (name "sbcl-cl-libxml2") + (version (git-version "0.3.4" "1" commit)) (source (origin (method git-fetch) (uri (git-reference - (url home-page) + (url "https://github.com/archimag/cl-libxml2") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-libxml2" version)) (sha256 - (base32 - "0bg3l0a28lw5gqqjp6p6b5nhwqk46sgkb7184w5qbfngw1hk8x9y")))) + (base32 "09049c13cfp5sc6x9lrw762jd7a9qkfq5jgngqgrzn4kn9qscarw")))) + (build-system asdf-build-system/sbcl) (inputs - (list sbcl-alexandria sbcl-let-plus sbcl-trivial-garbage - sbcl-closer-mop)) + `(("alexandria" ,sbcl-alexandria) + ("cffi" ,sbcl-cffi) + ("flexi-streams" ,sbcl-flexi-streams) + ("garbage-pools" ,sbcl-garbage-pools) + ("iterate" ,sbcl-iterate) + ("metabang-bind" ,sbcl-metabang-bind) + ("puri" ,sbcl-puri) + ;; Non-Lisp inputs: + ("libxml2" ,libxml2) + ("libxslt" ,libxslt))) (native-inputs - (list sbcl-fiveam)) - (synopsis "Hooks extension point mechanism (as in Emacs) for Common Lisp") - (description "A hook, in the present context, is a certain kind of -extension point in a program that allows interleaving the execution of -arbitrary code with the execution of a the program without introducing any -coupling between the two. Hooks are used extensively in the extensible editor -Emacs. - -In the Common LISP Object System (CLOS), a similar kind of extensibility is -possible using the flexible multi-method dispatch mechanism. It may even seem -that the concept of hooks does not provide any benefits over the possibilities -of CLOS. However, there are some differences: + (list sbcl-lift)) + (arguments + `(#:tests? #f ; FIXME: Tests get stuck indefinitly + #:phases + (modify-phases %standard-phases + (add-after 'unpack 'fix-paths + (lambda* (#:key inputs outputs #:allow-other-keys) + (substitute* "tree/xtree.lisp" + (("libxml2.so.2") + (string-append (assoc-ref inputs "libxml2") "/lib/libxml2.so"))) + (let ((libxslt (assoc-ref inputs "libxslt"))) + (substitute* "xslt/xslt.lisp" + (("libxslt.so.1") + (string-append libxslt "/lib/libxslt.so")) + (("libexslt.so.0") + (string-append libxslt "/lib/libexslt.so")) + (("cllibxml2.so") + (string-append (assoc-ref outputs "out") "/lib/cllibxml2.so")))) + #t)) + (add-before 'build 'build-helper-library + (lambda* (#:key inputs outputs #:allow-other-keys) + (let ((prefix-dir (string-append (assoc-ref outputs "out")))) + (mkdir-p (string-append prefix-dir "/lib")) + (invoke "make" "-C" "foreign" "install" + "INSOPTS=" + (string-append "PREFIX=" prefix-dir)) + #t))) + (add-after 'unpack 'fix-tests + (lambda _ + (substitute* '("cl-libxml2.asd" "cl-libxslt.asd" "xfactory.asd") + ((" :force t") "")) + #t))))) + (home-page "https://web.archive.org/web/20160121073421/http://cl-libxml2.googlecode.com/svn/doc/index.html") + (synopsis "High-level wrapper around libxml2 and libxslt libraries") + (description + "cl-libxml2 is high-level Common Lisp wrapper around the @code{libxml2} +and @code{libxslt} libraries. @itemize - -@item There can be only one method for each combination of specializers and -qualifiers. As a result this kind of extension point cannot be used by -multiple extensions independently. -@item Removing code previously attached via a @code{:before}, @code{:after} or -@code{:around} method can be cumbersome. -@item There could be other or even multiple extension points besides @code{:before} -and @code{:after} in a single method. -@item Attaching codes to individual objects using eql specializers can be -cumbersome. -@item Introspection of code attached a particular extension point is -cumbersome since this requires enumerating and inspecting the methods of a -generic function. -@end itemize - -This library tries to complement some of these weaknesses of method-based -extension-points via the concept of hooks.") +@item Interfaces for tree manipulation (like @code{cxml-stp}). +@item Interface for HTML 4.0 non-validating parsers. +@item Specific APIs to process HTML trees, especially serialization. +@item XPath API. +@item XSLT API. +@item Custom URL resolvers. +@item XPath extension functions. +@item XSLT extension elements. +@item Translates @code{libxml2} and @code{libxslt} errors to Lisp conditions. +@item Extends the Common Lisp @code{iterate} library with custom drivers for +child nodes enumeration, etc. +@item The @code{XFACTORY} system provides a simple and compact syntax for XML generation. +@end itemize\n") (license license:llgpl)))) -(define-public cl-hooks - (sbcl-package->cl-source-package sbcl-cl-hooks)) +(define-public cl-libxml2 + (sbcl-package->cl-source-package sbcl-cl-libxml2)) -(define-public ecl-cl-hooks - (sbcl-package->ecl-package sbcl-cl-hooks)) +(define-public ecl-cl-libxml2 + (sbcl-package->ecl-package sbcl-cl-libxml2)) -(define-public sbcl-cl-autowrap - (let ((revision "2") - (commit "a5d71ebd7c21b87f449db1e16ab815750d7c0ea4")) - ;; no taged branches +(define-public sbcl-cl-libyaml + (let ((commit "a7fe9f68bddfd00b7ca467b65b3b41b276336843") + (revision "1")) (package - (name "sbcl-cl-autowrap") - (version (git-version "1.0" revision commit)) + (name "sbcl-cl-libyaml") + (version (git-version "0.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/rpav/cl-autowrap") + (url "https://github.com/eudoxia0/cl-libyaml") (commit commit))) - (file-name (git-file-name "cl-autowrap" version)) + (file-name (git-file-name "cl-libyaml" version)) (sha256 - (base32 "0795c817m1c41cz3ywzzg83z4pgkxdg6si553pay9mdgjvmrwmaw")))) + (base32 + "06pvmackyhq03rjmihpx6w63m6cy8wx78ll5xpwwvd85bgrqq817")))) (build-system asdf-build-system/sbcl) - (arguments - `(#:asd-systems '("cl-plus-c" "cl-autowrap"))) + (native-inputs + (list sbcl-fiveam)) (inputs - `(("alexandria" ,sbcl-alexandria) - ("cffi" ,sbcl-cffi) - ("cl-json" ,sbcl-cl-json) - ("cl-ppcre" ,sbcl-cl-ppcre) - ("defpackage-plus" ,sbcl-defpackage-plus) - ("trivial-features" ,sbcl-trivial-features))) - (home-page "https://github.com/rpav/cl-autowrap") - (synopsis "FFI wrapper generator for Common Lisp") - (description "This is a c2ffi-based wrapper generator for Common Lisp.") - (license license:bsd-2)))) + `(("cffi" ,sbcl-cffi) + ("libyaml" ,libyaml))) + (arguments + '(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'fix-paths + (lambda* (#:key inputs #:allow-other-keys) + (substitute* "src/library.lisp" + (("libyaml.so") + (string-append (assoc-ref inputs "libyaml") + "/lib/libyaml.so")))))))) + (home-page "https://github.com/eudoxia0/cl-libyaml") + (synopsis "Libyaml bindings for Common Lisp") + (description + "This is a binding to the libyaml library. It's not meant as +a full library for YAML, just a bare binding with a couple of utility macros. +For a YAML parser and emitter using this, check out cl-yaml.") + (license license:expat)))) -(define-public cl-autowrap - (sbcl-package->cl-source-package sbcl-cl-autowrap)) +(define-public cl-libyaml + (sbcl-package->cl-source-package sbcl-cl-libyaml)) -(define-public ecl-cl-autowrap - (sbcl-package->ecl-package sbcl-cl-autowrap)) +(define-public ecl-cl-libyaml + (sbcl-package->ecl-package sbcl-cl-libyaml)) -(define-public sbcl-s-sysdeps - ;; No release since 2013. - (let ((commit "7f8de283b7fbd8b038fdf08493063a736db36ce7") - (revision "3")) +(define-public sbcl-cl-locale + (let ((commit "0a36cc0dcf5e0a8c8bf97869cd6199980ca25eec") + (revision "1")) (package - (name "sbcl-s-sysdeps") - (build-system asdf-build-system/sbcl) - (version (git-version "1" revision commit)) - (home-page "https://github.com/svenvc/s-sysdeps") + (name "sbcl-cl-locale") + (version (git-version "0.1.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url home-page) + (url "https://github.com/fukamachi/cl-locale") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-locale" version)) (sha256 - (base32 - "0rp81iq0rgl48qdwbmfy89glga81hmry2lp8adjbr5h5ybr92b4n")))) + (base32 "1rhannhpsw1yg1fpflam483a3w9qb1izgyvmnmiddv3dn4qsmn9p")))) + (build-system asdf-build-system/sbcl) + (arguments + '(#:asd-systems '("cl-locale-test" "cl-locale"))) + (native-inputs + `(("prove" ,sbcl-prove) + ("flexi-streams" ,sbcl-flexi-streams))) (inputs - (list sbcl-bordeaux-threads sbcl-usocket)) - (synopsis "Common Lisp abstraction layer over platform dependent functionality") - (description "@code{s-sysdeps} is an abstraction layer over platform -dependent functionality. This simple package is used as a building block in a -number of other projects. + `(("anaphora" ,sbcl-anaphora) + ("arnesi" ,sbcl-arnesi) + ("cl-annot" ,sbcl-cl-annot) + ("cl-syntax" ,sbcl-cl-syntax))) + (home-page "https://github.com/fukamachi/cl-locale") + (synopsis "Internalization library for Common Lisp") + (description + "This package provides a Common Lisp translation library similar to +CL-I18N and CL-L10N.") + (license license:llgpl)))) -@code{s-sysdeps} abstracts: +(define-public cl-locale + (sbcl-package->cl-source-package sbcl-cl-locale)) -@itemize -@item managing processes, -@item implementing a standard TCP/IP server, -@item opening a client TCP/IP socket stream, -@item working with process locks. -@end itemize\n") - (license license:llgpl)))) +(define-public ecl-cl-locale + (sbcl-package->ecl-package sbcl-cl-locale)) -(define-public cl-s-sysdeps - (sbcl-package->cl-source-package sbcl-s-sysdeps)) +(define-public sbcl-cl-log + (let ((commit "8f4b766d51e02245c310526cf1e4534ce634f837") + (revision "1")) + (package + (name "sbcl-cl-log") + (version "1.0.1") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/nicklevine/cl-log") + (commit commit))) + (sha256 + (base32 "1r3z9swy1b59swvaa5b97is9ysrfmjvjjhhw56p7p5hqg93b92ak")) + (file-name (git-file-name "cl-log" version)))) + (build-system asdf-build-system/sbcl) + (synopsis "Common Lisp general purpose logging utility") + (description "CL-LOG is a general purpose logging utility, loosely modelled +in some respects after Gary King's Log5. Its features include: logging to +several destinations at once, via \"messengers\", each messenger is tailored to +accept some log messages and reject others, and this tailoring can be changed +on-the-fly, very rapid processing of messages which are rejected by all +messengers, fully independent use of the utility by several different +sub-systems in an application, support for messengers which cl:format text to a +stream, support for messengers which do not invoke cl:format, timestamps in +theory accurate to internal-time-units-per-second.") + (home-page "https://github.com/nicklevine/cl-log") + (license license:expat)))) -(define-public ecl-s-sysdeps - (sbcl-package->ecl-package sbcl-s-sysdeps)) +(define-public cl-log + (sbcl-package->cl-source-package sbcl-cl-log)) -(define-public sbcl-cl-prevalence - (let ((commit "e6b27640ce89ae5f8af38beb740e319bb6cd2368") - (revision "6")) +(define-public ecl-cl-log + (sbcl-package->ecl-package sbcl-cl-log)) + +(define-public sbcl-cl-markdown + ;; The latest changes with fixes are not released yet, see + ;; https://github.com/hraban/cl-markdown/issues/9 + (let ((commit "3788802199228b49d0e06c3feb80c1c22af05cfc") + (revision "0")) (package - (name "sbcl-cl-prevalence") - (build-system asdf-build-system/sbcl) - (version (git-version "5" revision commit)) - (home-page "https://github.com/40ants/cl-prevalence") + (name "sbcl-cl-markdown") + (version (git-version "0.10.6" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url home-page) + (url "https://github.com/hraban/cl-markdown") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-markdown" version)) (sha256 - (base32 - "1lb957ivshgp56phqhvhsmnc4r55x5shvi3mpsan2xsm4hvqspp0")))) - (inputs - (list sbcl-moptilities sbcl-s-sysdeps sbcl-s-xml)) + (base32 "1algqwmafipyf194cx9wfhg0pdx1ppx6s444p1pm8yaycbsyla1v")))) + (build-system asdf-build-system/sbcl) (native-inputs - (list sbcl-fiveam sbcl-find-port)) - (synopsis "Implementation of object prevalence for Common Lisp") - (description "This Common Lisp library implements object prevalence (see -@url{https://en.wikipedia.org/wiki/System_prevalence}). It allows -for (de)serializing to and from s-exps as well as XML. Serialization of arbitrary -classes and cyclic data structures are supported.") - (license license:llgpl)))) + (list sbcl-lift sbcl-trivial-shell)) + (inputs + (list sbcl-anaphora + sbcl-cl-containers + sbcl-cl-ppcre + sbcl-dynamic-classes + sbcl-metabang-bind + sbcl-metatilities-base)) + (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 cl-prevalence - (sbcl-package->cl-source-package sbcl-cl-prevalence)) +(define-public cl-markdown + (sbcl-package->cl-source-package sbcl-cl-markdown)) -(define-public ecl-cl-prevalence - (sbcl-package->ecl-package sbcl-cl-prevalence)) +(define-public ecl-cl-markdown + (let ((pkg (sbcl-package->ecl-package sbcl-cl-markdown))) + (package + (inherit pkg) + (arguments + ;; XXX: Tests fail with "The function LIFT::GET-BACKTRACE-AS-STRING is + ;; undefined" on ECL. + ;; See https://github.com/hraban/cl-markdown/issues/11 + '(#:tests? #f))))) -(define-public sbcl-series - (let ((commit "da9061b336119d1e5214aff9117171d494d5a58a") +(define-public sbcl-cl-markless + (let ((commit "a0e145c03103bd3bf7e275d5ac0e19e8381eb844") (revision "1")) (package - (name "sbcl-series") - (version (git-version "2.2.11" revision commit)) + (name "sbcl-cl-markless") + (version (git-version "1.1.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "git://git.code.sf.net/p/series/series") + (url "https://github.com/Shirakumo/cl-markless") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-markless" version)) (sha256 - (base32 - "07hk2lhfx42zk018pxqvn4gs77vd4n4g8m4xxbqaxgca76mifwfw")))) + (base32 "154ax1yk0b1035yij29c5pgfn7ifghrxy821mk68wyljg8afgvh5")))) (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-parachute)) + (inputs + (list sbcl-3bmd + sbcl-babel + sbcl-command-line-arguments + sbcl-documentation-utils + sbcl-plump + sbcl-trivial-gray-streams + sbcl-trivial-indent + sbcl-trivial-mimes + sbcl-zip)) (arguments - ;; Disable the tests, they are apparently buggy and I didn't find - ;; a simple way to make them run and pass. - '(#:tests? #f)) - (synopsis "Series data structure for Common Lisp") - (description - "This Common Lisp library provides a series data structure much like -a sequence, with similar kinds of operations. The difference is that in many -situations, operations on series may be composed functionally and yet execute -iteratively, without the need to construct intermediate series values -explicitly. In this manner, series provide both the clarity of a functional -programming style and the efficiency of an iterative programming style.") - (home-page "https://series.sourceforge.net/") - (license license:expat)))) + '(#:asd-systems '("cl-markless" + "cl-markless-plump" + "cl-markless-epub" + "cl-markless-markdown" + "cl-markless-standalone"))) + (home-page "https://shirakumo.github.io/cl-markless/") + (synopsis "Parser implementation for Markless") + (description "This is an implementation of the \"Markless +standard\" (@url{https://github.com/shirakumo/markless}) at version 1.0. It +handles the parsing of plaintext from a stream into an abstract syntax tree +composed out of strings and component objects. From there the AST can be +easily compiled into a target markup language like HTML.") + (license license:zlib)))) -(define-public cl-series - (sbcl-package->cl-source-package sbcl-series)) +(define-public cl-markless + (sbcl-package->cl-source-package sbcl-cl-markless)) -(define-public ecl-series - (sbcl-package->ecl-package sbcl-series)) +(define-public ecl-cl-markless + (sbcl-package->ecl-package sbcl-cl-markless)) -(define-public sbcl-periods - (let ((commit "60383dcef88a1ac11f82804ae7a33c361dcd2949") - (revision "2")) +(define-public sbcl-cl-markup + (let ((commit "e0eb7debf4bdff98d1f49d0f811321a6a637b390")) (package - (name "sbcl-periods") - (version (git-version "0.0.2" revision commit)) + (name "sbcl-cl-markup") + (version (git-version "0.1" "1" commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/jwiegley/periods") + (url "https://github.com/arielnetworks/cl-markup/") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-markup" version)) (sha256 (base32 - "1ym2j4an9ig2hl210jg91gpf7xfnp6mlhkw3n9kkdnwiji3ipqlk")))) + "10l6k45971dl13fkdmva7zc6i453lmq9j4xax2ci6pjzlc6xjhp7")))) (build-system asdf-build-system/sbcl) - (inputs - `(("local-time" ,sbcl-local-time) - ("series" ,sbcl-series))) - (arguments - '(#:asd-systems '("periods" - "periods-series"))) - (synopsis "Common Lisp library for manipulating date/time objects") + (home-page "https://github.com/arielnetworks/cl-markup/") + (synopsis "Markup generation library for Common Lisp") (description - "Periods is a Common Lisp library providing a set of utilities for -manipulating times, distances between times, and both contiguous and -discontiguous ranges of time.") - (home-page "https://github.com/jwiegley/periods") - (license license:bsd-3)))) + "A modern markup generation library for Common Lisp that features: -(define-public cl-periods - (sbcl-package->cl-source-package sbcl-periods)) +@itemize +@item Fast (even faster through compiling the code) +@item Safety +@item Support for multiple document types (markup, xml, html, html5, xhtml) +@item Output with doctype +@item Direct output to stream +@end itemize\n") + (license license:lgpl3+)))) -(define-public ecl-periods - (sbcl-package->ecl-package sbcl-periods)) +(define-public cl-markup + (sbcl-package->cl-source-package sbcl-cl-markup)) -(define-public sbcl-metatilities-base - (let ((commit "ef04337759972fd622c9b27b53149f3d594a841f") - (revision "2")) +(define-public ecl-cl-markup + (sbcl-package->ecl-package sbcl-cl-markup)) + +(define-public sbcl-cl-mathstats + (let ((commit "4df38ea1b9de069cf939919253565a9ca9538eca") + (revision "1")) (package - (name "sbcl-metatilities-base") - (version (git-version "0.6.6" revision commit)) + (name "sbcl-cl-mathstats") + (version (git-version "0.8.2" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/hraban/metatilities-base") + (url "https://github.com/hraban/cl-mathstats") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-mathstats" version)) (sha256 - (base32 - "069rk5ncwvjnnzvvky6xiriynl72yzvjpnzl6jw9jf3b8na14zrk")))) + (base32 "0gsjvmkmnxc4hp5z9mkm5vsllywqyg7kx8jgz88vnx47yj3va1s8")))) (build-system asdf-build-system/sbcl) (native-inputs (list sbcl-lift)) - (synopsis "Core of the metatilities Common Lisp library") + (inputs + (list sbcl-cl-containers sbcl-metatilities-base)) + (home-page "https://github.com/hraban/cl-mathstats") + (synopsis "Common Lisp collection of mathematical routines") (description - "Metatilities-base is the core of the metatilities Common Lisp library -which implements a set of utilities.") - (home-page "https://common-lisp.net/project/metatilities-base/") + "This package provides Common Lisp math and statistics routines.") (license license:expat)))) -(define-public cl-metatilities-base - (sbcl-package->cl-source-package sbcl-metatilities-base)) +(define-public cl-mathstats + (sbcl-package->cl-source-package sbcl-cl-mathstats)) -(define-public ecl-metatilities-base - (sbcl-package->ecl-package sbcl-metatilities-base)) +(define-public ecl-cl-mathstats + (sbcl-package->ecl-package sbcl-cl-mathstats)) -(define-public sbcl-cl-containers - (let ((commit "781ebfe0888bae46f07c018f7d473898b1bd4f5f") - (revision "4")) +(define-public sbcl-cl-messagepack + (let ((commit "8ff2060ed20677feef8ac01558690df0aeac30b6") + (revision "0")) (package - (name "sbcl-cl-containers") - (version (git-version "0.12.1" revision commit)) + (name "sbcl-cl-messagepack") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/hraban/cl-containers") + (url "https://github.com/mbrezu/cl-messagepack") (commit commit))) - (file-name (git-file-name "cl-containers" version)) + (file-name (git-file-name "cl-messagepack" version)) (sha256 - (base32 - "1nrql8s1j123v5gscy99lxvhlzp0ijig9x94w30v3lwfa58hf90l")))) + (base32 "1hjd1q18lz46k46afz94ljflp76mfr30d6z4jrsgd26y2lc4gchc")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-lift)) - (inputs - (list sbcl-asdf-system-connections - sbcl-metatilities-base - sbcl-moptilities)) - (arguments - '(#:asd-systems '("cl-containers" - "cl-containers/with-moptilities" - "cl-containers/with-utilities") - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'relax-version-checks - (lambda _ - (substitute* "cl-containers.asd" - (("\\(:version \"metatilities-base\" \"0\\.6\\.6\"\\)") - "\"metatilities-base\"")) - (substitute* "cl-containers-test.asd" - (("\\(:version \"lift\" \"1\\.7\\.0\"\\)") - "\"lift\"")) - #t))))) - (synopsis "Container library for Common Lisp") + (native-inputs (list sbcl-cl-json sbcl-fiveam)) + (inputs (list sbcl-babel sbcl-closer-mop sbcl-flexi-streams)) + (synopsis "Common Lisp implementation of MessagePack") (description - "Common Lisp ships with a set of powerful built in data structures -including the venerable list, full featured arrays, and hash-tables. -CL-containers enhances and builds on these structures by adding containers -that are not available in native Lisp (for example: binary search trees, -red-black trees, sparse arrays and so on), and by providing a standard -interface so that they are simpler to use and so that changing design -decisions becomes significantly easier.") - (home-page "https://common-lisp.net/project/cl-containers/") - (license license:expat)))) + "This is a Common Lisp implementation of the MessagePack +(@url{http://msgpack.org/}) serialization/deserialization format, +implemented according to +@url{http://wiki.msgpack.org/display/MSGPACK/Format+specification}.") + (home-page "https://github.com/mbrezu/cl-messagepack") + (license license:bsd-2)))) -(define-public cl-containers - (sbcl-package->cl-source-package sbcl-cl-containers)) +(define-public cl-messagepack + (sbcl-package->cl-source-package sbcl-cl-messagepack)) -(define-public ecl-cl-containers - (sbcl-package->ecl-package sbcl-cl-containers)) +(define-public ecl-cl-messagepack + (sbcl-package->ecl-package sbcl-cl-messagepack)) -(define-public sbcl-cambl - (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636") +(define-public sbcl-cl-mime + (let ((commit "d30a28e0a40393bd3af7d138daa05319ed2e9d07") (revision "1")) (package - (name "sbcl-cambl") - (version (git-version "4.0.0" revision commit)) + (name "sbcl-cl-mime") + ;; One commit says "update to cl-mime-0.5.3", even though the .asd is at 0.5.1. + (version (git-version "0.5.3" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/jwiegley/cambl") + ;; Maintained fork according to http://www.cliki.net/CL-MIME: + (url "https://github.com/40ants/cl-mime") (commit commit))) - (file-name (git-file-name "cambl" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "103mry04j2k9vznsxm7wcvccgxkil92cdrv52miwcmxl8daa4jiz")))) + (base32 "0qn8if0fj6vzc897pqqqs0m1y107gmzqngpqhqmwrcsp1ckj5k0v")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-xlunit)) (inputs - `(("alexandria" ,sbcl-alexandria) - ("cl-containers" ,sbcl-cl-containers) - ("local-time" ,sbcl-local-time) - ("periods" ,sbcl-periods))) - (synopsis "Commoditized amounts and balances for Common Lisp") + (list sbcl-cl-ppcre sbcl-cl-base64 sbcl-cl-qprint)) + (native-inputs + (list sbcl-rove)) + (home-page "https://github.com/40ants/cl-mime/") + (synopsis "Read and print MIME content in Common Lisp") (description - "CAMBL is a Common Lisp library providing a convenient facility for -working with commoditized values. It does not allow compound units (and so is -not suited for scientific operations) but does work rather nicely for the -purpose of financial calculations.") - (home-page "https://github.com/jwiegley/cambl") - (license license:bsd-3)))) + "This is a Common Lisp library for reading and printing MIME content. +It supports automatic conversion between 7-bit, quoted-printable and base64 +encodings.") + (license license:lgpl2.1)))) -(define-public cl-cambl - (sbcl-package->cl-source-package sbcl-cambl)) +(define-public cl-mime + (sbcl-package->cl-source-package sbcl-cl-mime)) -(define-public ecl-cambl - (sbcl-package->ecl-package sbcl-cambl)) +(define-public ecl-cl-mime + (sbcl-package->ecl-package sbcl-cl-mime)) -(define-public sbcl-cl-ledger - (let ((commit "08e0be41795e804cd36142e51756ad0b1caa377b") - (revision "1")) +(define-public sbcl-cl-mimeparse + (let ((commit "93cbdf6f6fe8a2eb5f652f8adec453eb98ea0547") + (revision "0")) (package - (name "sbcl-cl-ledger") - (version (git-version "4.0.0" revision commit)) + (name "sbcl-cl-mimeparse") + (version (git-version "0.0.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/ledger/cl-ledger") + (url "https://github.com/mmontone/cl-mimeparse") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-mimeparse" version)) (sha256 - (base32 - "1via0qf6wjcyxnfbmfxjvms0ik9j8rqbifgpmnhrzvkhrq9pv8h1")))) + (base32 "0gdkpi3620va0a3q56svcn1q9f5w0pqfhx30lnldg8fjnrdfiwkk")))) (build-system asdf-build-system/sbcl) - (inputs - `(("cambl" ,sbcl-cambl) - ("cl-ppcre" ,sbcl-cl-ppcre) - ("local-time" ,sbcl-local-time) - ("periods" ,sbcl-periods))) (arguments - '(#:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-system-definition - (lambda _ - (substitute* "cl-ledger.asd" - ((" :build-operation program-op") "") - ((" :build-pathname \"cl-ledger\"") "") - ((" :entry-point \"ledger::main\"") "")) - #t))))) - (synopsis "Common Lisp port of the Ledger accounting system") + '(#:asd-test-systems '("cl-mimeparse-tests"))) + (native-inputs + (list sbcl-rt)) + (inputs + (list sbcl-cl-ppcre sbcl-parse-number)) + (home-page "https://github.com/mmontone/cl-mimeparse/") + (synopsis "Common Lisp library for parsing MIME types") (description - "CL-Ledger is a Common Lisp port of the Ledger double-entry accounting -system.") - (home-page "https://github.com/ledger/cl-ledger") - (license license:bsd-3)))) + "This package provides a library for parsing MIME types, in the spirit +of http://code.google.com/p/mimeparse/, with a Common Lisp flavor.") + (license license:expat)))) -(define-public cl-ledger - (sbcl-package->cl-source-package sbcl-cl-ledger)) +(define-public cl-mimeparse + (sbcl-package->cl-source-package sbcl-cl-mimeparse)) -(define-public ecl-cl-ledger - (sbcl-package->ecl-package sbcl-cl-ledger)) +(define-public ecl-cl-mimeparse + (sbcl-package->ecl-package sbcl-cl-mimeparse)) -(define-public sbcl-bst - (let ((commit "8545aed0d504df2829ad139566feeabe22305388") +(define-public sbcl-cl-mixed + (let ((commit "4aaff134d3902d93a2a8605c10de4bcfc62d7afa") (revision "0")) (package - (name "sbcl-bst") - (version (git-version "2.0" revision commit)) + (name "sbcl-cl-mixed") + (version (git-version "2.1.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://codeberg.org/glv/bst") + (url "https://github.com/Shirakumo/cl-mixed") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-mixed" version)) (sha256 - (base32 "18ig7rvxcra69437g0i8sxyv7c5dg26jqnx1rc2f9pxmihdprgk8")))) + (base32 "1mrj95lxb1gbxxm89x8gy1ifw2ic1p5wwpapkxcd2jr8abw7zny0")) + (modules '((guix build utils))) + (snippet + ;; Delete bundled libraries. + `(begin + (delete-file-recursively "static"))))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-alexandria sbcl-fiveam)) - (synopsis "Binary search tree for Common Lisp") + (arguments + '(#:asd-systems '("cl-mixed" + "cl-mixed-examples" + "cl-mixed-flac" + "cl-mixed-vorbis" + "cl-mixed-alsa" + "cl-mixed-jack" + "cl-mixed-mpg123" + "cl-mixed-mpt" + "cl-mixed-out123" + "cl-mixed-pulse" + "cl-mixed-sdl2" + "cl-mixed-wav") + #:phases + (modify-phases %standard-phases + (add-after 'unpack 'fix-paths + (lambda* (#:key inputs #:allow-other-keys) + (substitute* "low-level.lisp" + (("libmixed.so.2") + (search-input-file inputs "/lib/libmixed.so.2")))))))) + (inputs + (list libmixed + sbcl-alexandria + sbcl-cffi + sbcl-cl-flac + sbcl-cl-mpg123 + sbcl-cl-out123 + sbcl-cl-vorbis + sbcl-documentation-utils + sbcl-sdl2 + sbcl-static-vectors + sbcl-trivial-features)) + (home-page "https://shirakumo.github.io/cl-mixed/") + (synopsis "Extended audio library for Common Lisp") (description - "BST is a Common Lisp library for working with binary search trees that -can contain any kind of values.") - (home-page "https://codeberg.org/glv/bst") - (license license:gpl3)))) + "This package provides CFFI binding to @code{libmixed} audio library for +Common Lisp with support of other audio formats available on GNU/Linux systems: -(define-public cl-bst - (sbcl-package->cl-source-package sbcl-bst)) +@itemize -(define-public ecl-bst - (sbcl-package->ecl-package sbcl-bst)) +@item @acronym{Alsa, Advanced Linux Sound Architecture} +@item @acronym{Jack, JackAudio toolkit} +@item @acronym{Openmpt, Libopenmpt playback drain for tracker files} +@item @acronym{PulseAudio, PulseAudio based playback drain} +@item Flac (via CL-FLAC) +@item Mpg123 (via CL-MPG123) +@item Ogg/vorbis (via CL-VORBIS) +@item Out123 (via CL-OUT123) +@item WAV -(define-public sbcl-trivial-octet-streams - (let ((commit "bc5d398b18549fd42e9c2a365df28ad865f1b85d") - (revision "0")) +@end itemize") + (license license:zlib)))) + +(define-public cl-mixed + (sbcl-package->cl-source-package sbcl-cl-mixed)) + +(define-public ecl-cl-mixed + (sbcl-package->ecl-package sbcl-cl-mixed)) + +(define-public sbcl-cl-modio + (let ((commit "2fd288af27b574f448357fa6de4b42acf44e2f11") + (revision "1")) (package - (name "sbcl-trivial-octet-streams") - (version (git-version "0.1" revision commit)) + (name "sbcl-cl-modio") + (version (git-version "1.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/sharplispers/trivial-octet-streams") + (url "https://github.com/Shinmera/cl-modio/") (commit commit))) - (file-name (git-file-name "cl-trivial-octet-streams" version)) (sha256 - (base32 "0ysnsarlzynb7jf4b63b6kkxjancxc66jwmn0sb3vxyh87siiv6n")))) + (base32 "0hz87v81pi8kr2c7az30czpdf7v757lkzlsmdcc59p94pipca7m9")) + (file-name (git-file-name "cl-modio" version)))) (build-system asdf-build-system/sbcl) - (home-page "https://github.com/sharplispers/trivial-octet-streams") - (synopsis "In-memory octet streams for Common Lisp") - (description - "TRIVIAL-OCTET-STREAMS is a Common Lisp library implementing in-memory -octet streams analogous to string streams.") - (license license:bsd-3)))) + (inputs + (list sbcl-alexandria + sbcl-zippy + sbcl-jzon + sbcl-cl-ppcre + sbcl-drakma + sbcl-documentation-utils + sbcl-language-codes)) + (synopsis "Client library for the mod.io API") + (description "This is a client library to interact with the +\"mod.io\" (@url{https://mod.io}) platform to manage \"mods\" or extensions +for games and other applications. It covers the full v1 API and includes +convenience methods to make interacting with the API as well as syncing mods +and so on easy.") + (home-page "https://shinmera.github.io/cl-modio/") + (license license:zlib)))) -(define-public cl-trivial-octet-streams - (sbcl-package->cl-source-package sbcl-trivial-octet-streams)) +(define-public cl-modio + (sbcl-package->cl-source-package sbcl-cl-modio)) -(define-public ecl-trivial-octet-streams - (sbcl-package->ecl-package sbcl-trivial-octet-streams)) +(define-public ecl-cl-modio + (sbcl-package->ecl-package sbcl-cl-modio)) -(define-public sbcl-cl-octet-streams +(define-public sbcl-cl-morse (package - (name "sbcl-cl-octet-streams") - (version "1.2") + (name "sbcl-cl-morse") + (version "1.0.0") (source (origin (method git-fetch) (uri (git-reference - (url "https://codeberg.org/glv/cl-octet-streams") + (url "https://github.com/em7/cl-morse") (commit (string-append "v" version)))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-morse" version)) (sha256 - (base32 "1hffh98bv4w5yrchagzwqrc43d2p473pvw7ka4kyyvhrr52dk2f8")))) + (base32 "01sh34nhbsx2dsrb2r1vkd4j8lzm9gjd5jfi8a4cs4m3djjwhh5i")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-fiveam)) - (inputs - (list sbcl-trivial-gray-streams)) - (synopsis "In-memory octet streams for Common Lisp") + (inputs (list sbcl-cl-ppcre)) + (native-inputs (list sbcl-fiveam)) + (home-page "https://github.com/em7/cl-morse") + (synopsis "Morse code translation library for Common Lisp") (description - "CL-octet-streams is a library implementing in-memory octet -streams for Common Lisp. It was inspired by the trivial-octet-streams and -cl-plumbing libraries.") - (home-page "https://codeberg.org/glv/cl-octet-streams") - (license license:gpl3+))) + "@code{cl-morse} is a Morse code translation library for Common Lisp.") + (license license:bsd-3))) -(define-public cl-octet-streams - (sbcl-package->cl-source-package sbcl-cl-octet-streams)) +(define-public cl-morse + (sbcl-package->cl-source-package sbcl-cl-morse)) -(define-public ecl-cl-octet-streams - (sbcl-package->ecl-package sbcl-cl-octet-streams)) +(define-public ecl-cl-morse + (sbcl-package->ecl-package sbcl-cl-morse)) -(define-public sbcl-in-memory-streams - (let ((commit "bb4ce9c8c08479c9904f5d29f2b6187f264dc620") +(define-public sbcl-cl-mount-info + (let ((commit "2024f5037a7f63db3e3587dc9972cd7b9318f06b") (revision "1")) (package - (name "sbcl-in-memory-streams") - (version (git-version "1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://codeberg.org/glv/cl-in-memory-streams") - (commit commit))) - (file-name (git-file-name "cl-in-memory-streams" version)) - (sha256 - (base32 "1fls1jnkf86wimip6f95y496sc4rxpsh2y65lgqsqpi0yda5xl2f")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-fiveam)) - (inputs - (list sbcl-trivial-gray-streams)) - (synopsis "In-memory streams for any element type") - (description - "This Common Lisp library provides an implementation of in-memory input -streams, output streams and io streams for any type of elements.") - (home-page "https://codeberg.org/glv/cl-in-memory-streams") - (license license:gpl3+)))) + (name "sbcl-cl-mount-info") + (version (git-version "0.0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://notabug.org/cage/cl-mount-info.git") + (commit commit))) + (file-name (git-file-name "cl-mount-info" version)) + (sha256 + (base32 "0vza9gj9q42nzb5v8aj22lmn4aqx9vrddsb5a343nbwfz89hbh9x")))) + (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-alexandria sbcl-cffi sbcl-cl-ppcre)) + (home-page "https://notabug.org/cage/cl-mount-info.git") + (synopsis "Library to get information about mounted filesystems") + (description + "CL-MOUNT-INFO is a Common Lisp wrapper around @code{getmntent(3)} and +related C functions to get information about the mounted file system.") + (license license:lgpl3)))) -(define-public cl-in-memory-streams - (sbcl-package->cl-source-package sbcl-in-memory-streams)) +(define-public cl-mount-info + (sbcl-package->cl-source-package sbcl-cl-mount-info)) -(define-public ecl-in-memory-streams - (sbcl-package->ecl-package sbcl-in-memory-streams)) +(define-public ecl-cl-mount-info + (sbcl-package->ecl-package sbcl-cl-mount-info)) -(define-public sbcl-lzlib - (let ((commit "22767ca12d1c1bd59a7ae1f9c5ef7d2e937206bb") - (revision "2")) +(define-public sbcl-cl-mpg123 + (let ((commit "5f042c839d2ea4a2ff2a7b60c839d8633d64161d") + (revision "1")) (package - (name "sbcl-lzlib") - (version (git-version "2.0" revision commit)) + (name "sbcl-cl-mpg123") + (version (git-version "1.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://codeberg.org/glv/cl-lzlib") + (url "https://github.com/Shirakumo/cl-mpg123") (commit commit))) - (file-name (git-file-name "cl-lzlib" version)) + (file-name (git-file-name "cl-mpg123" version)) (sha256 - (base32 "1dxzlkay7aqcs65h2f7j7rl4sdjija60dshlahzyllfw174p9d3m")))) + (base32 "1hl721xaczxck008ax2y3jpkm509ry1sg3lklh2k76764m3ndrjf")) + (modules '((guix build utils))) + (snippet + '(begin + ;; Remove bundled pre-compiled libraries. + (delete-file-recursively "static") + #t)))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-fiveam)) - (inputs - (list lzlib - sbcl-cffi - sbcl-cl-octet-streams - sbcl-lparallel)) (arguments - (list #:phases - #~(modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "src/lzlib.lisp" - (("liblz\\.so") - (search-input-file inputs "/lib/liblz.so")))))))) - (synopsis "Common Lisp library for lzip (de)compression") + `(#: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 Common Lisp library provides functions for lzip (LZMA) -compression/decompression using bindings to the lzlib C library.") - (home-page "https://codeberg.org/glv/cl-lzlib") - (license license:gpl3+)))) + "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 cl-lzlib - (sbcl-package->cl-source-package sbcl-lzlib)) +(define-public cl-mpg123 + (sbcl-package->cl-source-package sbcl-cl-mpg123)) -(define-public ecl-lzlib - (sbcl-package->ecl-package sbcl-lzlib)) +(define-public ecl-cl-mpg123 + (sbcl-package->ecl-package sbcl-cl-mpg123)) -(define-public sbcl-chanl - (let ((commit "56e90a126c78b39bb621a01585e8d3b985238e8c") +(define-public sbcl-cl-murmurhash + ;; No release. + (let ((commit "5433f5e95f1cce63a81259a471150834c6a59364") (revision "1")) (package - (name "sbcl-chanl") - (version (git-version "0.4.1" revision commit)) + (name "sbcl-cl-murmurhash") + (version (git-version "0.0.0" revision commit)) + (home-page "https://github.com/ruricolist/cl-murmurhash/") (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/zkat/chanl") + (url home-page) (commit commit))) (file-name (git-file-name name version)) (sha256 (base32 - "0b1cf6c12qx5cy1fw2z42jgh566rp3l8nv5qf0qqc569s7bgmrh4")))) + "0251r0mpjm0y3qsm4lm7ncvrkxvgwc53spdm1p2mpayhvkkqqsws")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-fiveam)) (inputs - (list sbcl-bordeaux-threads)) - (synopsis "Portable channel-based concurrency for Common Lisp") - (description "Common Lisp library for channel-based concurrency. In -a nutshell, you create various threads sequentially executing tasks you need -done, and use channel objects to communicate and synchronize the state of these -threads.") - (home-page "https://github.com/zkat/chanl") - (license (list license:expat license:bsd-3))))) - -(define-public cl-chanl - (sbcl-package->cl-source-package sbcl-chanl)) - -(define-public ecl-chanl - (sbcl-package->ecl-package sbcl-chanl)) - -(define-public sbcl-cl-store - (let ((commit "c787337a16ea8cf8a06227f35933a4ec774746b3") - (revision "1")) - (package - (name "sbcl-cl-store") - (version (git-version "0.8.11" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/skypher/cl-store") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "194srkg8nrym19c6i7zbnkzshc1qhqa82m53qnkirz9fw928bqxr")))) - (build-system asdf-build-system/sbcl) + (list sbcl-babel)) (native-inputs - (list sbcl-rt)) - (synopsis "Common Lisp library to serialize data") + (list sbcl-fiveam)) + (synopsis "32-bit version of Murmurhash3 for Common Lisp") (description - "CL-STORE is a portable serialization package which should give you the -ability to store all Common Lisp data types into streams.") - (home-page "https://www.common-lisp.net/project/cl-store/") + "This Common Lisp package offers an implementation of the 32-bit +variant of MurmurHash3 (@url{https://github.com/aappleby/smhasher}), a fast +non-crytographic hashing algorithm.") (license license:expat)))) -(define-public cl-store - (sbcl-package->cl-source-package sbcl-cl-store)) - -(define-public ecl-cl-store - (sbcl-package->ecl-package sbcl-cl-store)) +(define-public cl-murmurhash + (sbcl-package->cl-source-package sbcl-cl-murmurhash)) -(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 - (list sbcl-fiveam)) - (inputs - (list sbcl-alexandria 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-cl-murmurhash + (sbcl-package->ecl-package sbcl-cl-murmurhash)) -(define-public ecl-specialization-store +(define-public sbcl-cl-mustache (package - (inherit (sbcl-package->ecl-package sbcl-specialization-store)) - (arguments - ;; TODO: Find why the tests get stuck forever; disable them for now. - `(#:tests? #f)))) + (name "sbcl-cl-mustache") + (version "0.12.1") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/kanru/cl-mustache") + (commit (string-append "v" version)))) + (file-name (git-file-name "cl-mustache" version)) + (sha256 + (base32 "149xbb6wxq1napliwm9cv729hwcgfnjli6y8hingfixz7f10lhks")))) + (build-system asdf-build-system/sbcl) + (home-page "https://github.com/kanru/cl-mustache") + (synopsis "Common Lisp Mustache template renderer") + (description "This is a Common Lisp implementation for the Mustache +template system. More details on the standard are available at +@url{https://mustache.github.io}.") + (license license:expat))) -(define-public cl-specialization-store - (sbcl-package->cl-source-package sbcl-specialization-store)) +(define-public cl-mustache + (sbcl-package->cl-source-package sbcl-cl-mustache)) -(define-public sbcl-cl-gobject-introspection - (let ((commit "83beec4492948b52aae4d4152200de5d5c7ac3e9") - (revision "3")) +(define-public ecl-cl-mustache + (sbcl-package->ecl-package sbcl-cl-mustache)) + +(define-public sbcl-cl-mysql + (let ((commit "ab56c279c1815aec6ca0bfe85164ff7e85cfb6f9") + (revision "1")) (package - (name "sbcl-cl-gobject-introspection") - (version (git-version "0.3" revision commit)) - (home-page "https://github.com/andy128k/cl-gobject-introspection") + (name "sbcl-cl-mysql") + (version (git-version "0.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url home-page) + (url "https://github.com/hackinghat/cl-mysql") (commit commit))) - (file-name (git-file-name "cl-gobject-introspection" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "0xwmj4b3whz12i474g54krp1v6h0fpvsx8lgwpk6rkli9xc71wc3")))) + (base32 "0dg5ynx2ww94d0qfwrdrm7plkn43h64hs4iiq9mj2s1s4ixnp3lr")))) (build-system asdf-build-system/sbcl) - (inputs - (list glib - gobject-introspection - sbcl-alexandria - sbcl-cffi - sbcl-iterate - sbcl-trivial-garbage)) (native-inputs - (list sbcl-fiveam)) + (list sbcl-stefil)) + (inputs + `(("cffi" ,sbcl-cffi) + ("mariadb-lib" ,mariadb "lib"))) (arguments - '(#:phases + `(#:tests? #f ; TODO: Tests require a running server + #:phases (modify-phases %standard-phases (add-after 'unpack 'fix-paths (lambda* (#:key inputs #:allow-other-keys) - (substitute* "src/init.lisp" - (("libgobject-2\\.0\\.so") - (search-input-file inputs "/lib/libgobject-2.0.so")) - (("libgirepository-1\\.0\\.so") - (search-input-file inputs - "/lib/libgirepository-1.0.so")))))))) - (synopsis "Common Lisp bindings to GObject Introspection") + (substitute* "system.lisp" + (("libmysqlclient_r" all) + (string-append (assoc-ref inputs "mariadb-lib") + "/lib/" + all))) + #t))))) + (synopsis "Common Lisp wrapper for MySQL") (description - "This library is a bridge between Common Lisp and GObject -Introspection, which enables Common Lisp programs to access the full interface -of C+GObject libraries without the need of writing dedicated bindings.") - (license (list license:bsd-3 - ;; Tests are under a different license. - license:llgpl))))) + "@code{cl-mysql} is a Common Lisp implementation of a MySQL wrapper.") + (home-page "http://www.hackinghat.com/index.php/cl-mysql") + (license license:expat)))) -(define-public cl-gobject-introspection - (sbcl-package->cl-source-package sbcl-cl-gobject-introspection)) +(define-public cl-mysql + (sbcl-package->cl-source-package sbcl-cl-mysql)) -(define-public ecl-cl-gobject-introspection - (sbcl-package->ecl-package sbcl-cl-gobject-introspection)) +(define-public ecl-cl-mysql + (sbcl-package->ecl-package sbcl-cl-mysql)) -(define-public sbcl-cl-gobject-introspection-wrapper - (let ((commit "2d197cba7e7d734ac8a2e181e5e709e5b218bada") +(define-public sbcl-cl-num-utils + (let ((commit "97a88cd34540acf52e872a82ebfef3da0a34fa12") (revision "1")) (package - (name "sbcl-cl-gobject-introspection-wrapper") - (version (git-version "1.0.0" revision commit)) + (name "sbcl-cl-num-utils") + (version (git-version "0.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/bohonghuang/cl-gobject-introspection-wrapper") + (url "https://github.com/tpapp/cl-num-utils") (commit commit))) - (file-name (git-file-name "cl-gobject-introspection-wrapper" version)) + (file-name (git-file-name "cl-num-utils" version)) (sha256 - (base32 "05np2zs5806ib6qfz7d6knyaz6llxgwvjqavl1fsz5hcga40296s")))) + (base32 "15ihsxxs76xnldmqfsbxybckqjwrxwcpphgghiwzr2mnbqjpdqkh")))) (build-system asdf-build-system/sbcl) (inputs - (list sbcl-alexandria - sbcl-cl-gobject-introspection - sbcl-cl-ppcre)) - (home-page - "https://github.com/bohonghuang/cl-gobject-introspection-wrapper") - (synopsis - "Wrap and call GObject Introspection FFI function in Common Lisp") + (list sbcl-anaphora sbcl-alexandria sbcl-array-operations + sbcl-cl-slice sbcl-let-plus)) + (native-inputs + (list sbcl-clunit)) + (home-page "https://github.com/tpapp/cl-num-utils") + (synopsis "Numerical utilities for Common Lisp") (description - "This library converts the elements from GObject Introspection into -Common Lisp-style definitions, based on cl-gobject-introspection.") - (license license:lgpl3+)))) + "@code{cl-num-utils} implements simple numerical functions for Common +Lisp, including: +@itemize +@item @code{num=}, a comparison operator for floats +@item simple arithmeric functions, like @code{sum} and @code{l2norm} +@item elementwise operations for arrays +@item intervals +@item special matrices and shorthand for their input +@item sample statistics +@item Chebyshev polynomials +@item univariate rootfinding +@end itemize") + (license license:boost1.0)))) -(define-public cl-gobject-introspection-wrapper - (sbcl-package->cl-source-package sbcl-cl-gobject-introspection-wrapper)) +(define-public cl-num-utils + (sbcl-package->cl-source-package sbcl-cl-num-utils)) -(define-public ecl-cl-gobject-introspection-wrapper - (sbcl-package->ecl-package sbcl-cl-gobject-introspection-wrapper)) +(define-public ecl-cl-num-utils + (sbcl-package->ecl-package sbcl-cl-num-utils)) -(define-public sbcl-cl-glib - (let ((commit "9e52827cce1cbb3962536b6a5e628febab593f57") +(define-public sbcl-cl-octet-streams + (package + (name "sbcl-cl-octet-streams") + (version "1.2") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://codeberg.org/glv/cl-octet-streams") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1hffh98bv4w5yrchagzwqrc43d2p473pvw7ka4kyyvhrr52dk2f8")))) + (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-fiveam)) + (inputs + (list sbcl-trivial-gray-streams)) + (synopsis "In-memory octet streams for Common Lisp") + (description + "CL-octet-streams is a library implementing in-memory octet +streams for Common Lisp. It was inspired by the trivial-octet-streams and +cl-plumbing libraries.") + (home-page "https://codeberg.org/glv/cl-octet-streams") + (license license:gpl3+))) + +(define-public cl-octet-streams + (sbcl-package->cl-source-package sbcl-cl-octet-streams)) + +(define-public ecl-cl-octet-streams + (sbcl-package->ecl-package sbcl-cl-octet-streams)) + +(define-public sbcl-cl-online-learning + (let ((commit "87fbef8a340219e853adb3a5bf44a0470da76964") (revision "1")) (package - (name "sbcl-cl-glib") - (version (git-version "1.0.0" revision commit)) + (name "sbcl-cl-online-learning") + (version (git-version "0.5" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/bohonghuang/cl-glib") + (url "https://github.com/masatoi/cl-online-learning") (commit commit))) - (file-name (git-file-name "cl-glib" version)) + (file-name (git-file-name "cl-online-learning" version)) (sha256 - (base32 "0dxa493zdp1p93cahhpp3yaggn3j3kkn90mdw99g4ld7scmiglp4" )))) + (base32 + "1lfq04lnxivx59nq5dd02glyqsqzf3vdn4s9b8wnaln5fs8g2ph9")))) (build-system asdf-build-system/sbcl) - (arguments - '(#:asd-systems '("cl-gio" "cl-glib" "cl-gobject"))) + (native-inputs + (list sbcl-prove)) (inputs - (list glib - gobject-introspection - sbcl-bordeaux-threads - sbcl-cl-gobject-introspection-wrapper)) - (home-page "https://github.com/bohonghuang/cl-glib") - (synopsis "Glib, GIO and Gobject bindings for Common Lisp") - (description "This library provides Glib, GIO and Gobject bindings for -Common Lisp via Gobject Introspection.") - (license license:lgpl3+)))) + `(("cl-libsvm-format" ,sbcl-cl-libsvm-format) + ("cl-store" ,sbcl-cl-store))) + (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.") + (license license:expat)))) -(define-public cl-glib - (sbcl-package->cl-source-package sbcl-cl-glib)) +(define-public cl-online-learning + (sbcl-package->cl-source-package sbcl-cl-online-learning)) -(define-public ecl-cl-glib - (sbcl-package->ecl-package sbcl-cl-glib)) +(define-public ecl-cl-online-learning + (sbcl-package->ecl-package sbcl-cl-online-learning)) -(define-public sbcl-cl-gtk4 - (let ((commit "d116905e7b68508d03681a50b3b24d63e7b111e4") +(define-public sbcl-cl-opengl + (let ((commit "e2d83e0977b7e7ac3f3d348d8ccc7ccd04e74d59") (revision "1")) (package - (name "sbcl-cl-gtk4") - (version (git-version "1.0.0" revision commit)) + (name "sbcl-cl-opengl") + (version (git-version "0.1.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/bohonghuang/cl-gtk4") + (url "https://github.com/3b/cl-opengl") (commit commit))) - (file-name (git-file-name "cl-gtk4" version)) + (file-name (git-file-name "cl-opengl" version)) (sha256 - (base32 "0mprmmvbagnflvhynn51l42nbwr08rld99ls0c48m5lpjn0ja4zc")))) + (base32 "0mhqmll09f079pnd6mgswz9nvr6h5n27d4q7zpmm2igf1v460id7")))) (build-system asdf-build-system/sbcl) (arguments - '(#:asd-systems '("cl-gtk4" "cl-gdk4"))) - ;; propagate because it at least requires the typelib files at runtime - (propagated-inputs (list gtk)) + `(#:asd-systems '("cl-opengl" "cl-glu" "cl-glut") + #:phases + (modify-phases %standard-phases + (add-after 'unpack 'patch-lib-path + (lambda* (#:key inputs #:allow-other-keys) + (substitute* "gl/library.lisp" + (("libGL.so" all) + (search-input-file inputs "/lib/libGL.so"))) + (substitute* "glu/library.lisp" + (("libGLU.so" all) + (search-input-file inputs "/lib/libGLU.so"))) + (substitute* "glut/library.lisp" + (("libglut.so" all) + (search-input-file inputs "/lib/libglut.so")))))))) (inputs - (list gobject-introspection - sbcl-cl-glib - sbcl-cl-gobject-introspection-wrapper)) - (home-page "https://github.com/bohonghuang/cl-gtk4") - (synopsis "GTK4 bindings for Common Lisp") + `(("alexandria" ,sbcl-alexandria) + ("cffi" ,sbcl-cffi) + ("float-features" ,sbcl-float-features) + ("freeglut" ,freeglut) + ("glu" ,glu) + ("mesa" ,mesa))) + (home-page "https://github.com/3b/cl-opengl") + (synopsis "Common Lisp bindings to OpenGL, GLU and GLUT APIs") (description - "This library provides GTK4 bindings for Common Lisp via Gobject -Introspection, in the cl-gtk4 ASDF system.") - (license license:lgpl3)))) + "This package provides a set of bindings and utilities for accessing the +OpenGL (Mesa), GLU and GLUT (FreeGLUT) APIs using CFFI.") + (license license:bsd-3)))) -(define-public cl-gtk4 - (sbcl-package->cl-source-package sbcl-cl-gtk4)) +(define-public cl-opengl + (sbcl-package->cl-source-package sbcl-cl-opengl)) -(define-public ecl-cl-gtk4 - (sbcl-package->ecl-package sbcl-cl-gtk4)) +(define-public ecl-cl-opengl + (sbcl-package->ecl-package sbcl-cl-opengl)) -(define-public sbcl-cl-slug - (let ((commit "ffb229d10f0d3f7f54e706791725225e200bf749") - (revision "1")) +(define-public sbcl-cl-out123 + (let ((commit "41771bfd419e7349ad569f8e6fcd8a26d6f9e5b7") + (revision "2")) (package - (name "sbcl-cl-slug") - (version (git-version "0.4.1" revision commit)) + (name "sbcl-cl-out123") + (version (git-version "1.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/EuAndreh/cl-slug") + (url "https://github.com/Shirakumo/cl-out123") (commit commit))) - (file-name (git-file-name "cl-slug" version)) + (file-name (git-file-name "cl-out123" version)) (sha256 - (base32 "1asdq6xllmsvfw5fky9wblqcx9isac9jrrlkfl7vyxcq1wxrnflx")))) + (base32 "0ahgc5l5lbpl3ini4pn5crh8b7dlr386pxczl0d4h6djhccxzs4w")) + (modules '((guix build utils))) + (snippet + '(begin + ;; Remove bundled pre-compiled libraries. + (delete-file-recursively "static"))))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-prove)) + (arguments + `(#:tests? #f ; No tests + #:phases + (modify-phases %standard-phases + (add-after 'unpack 'fix-paths + (lambda* (#:key inputs #:allow-other-keys) + (substitute* "low-level.lisp" + (("libout123.so") + (search-input-file inputs "/lib/libout123.so")))))))) (inputs - `(("ppcre" ,sbcl-cl-ppcre))) - (home-page "https://github.com/EuAndreh/cl-slug") - (synopsis "Multi-language slug formatter") + (list mpg123 + sbcl-bordeaux-threads + sbcl-cffi + sbcl-documentation-utils + sbcl-trivial-features + sbcl-trivial-garbage)) + (home-page "https://shirakumo.github.io/cl-out123/") + (synopsis "Common Lisp bindings to libout123") (description - "This is a small Common Lisp library to make slugs, mainly for URIs, -from English and beyond.") - (license license:llgpl)))) + "This is a bindings library to @code{libout123} which allows easy +cross-platform audio playback.") + (license license:zlib)))) -(define-public ecl-cl-slug - (sbcl-package->ecl-package sbcl-cl-slug)) +(define-public cl-out123 + (sbcl-package->cl-source-package sbcl-cl-out123)) -(define-public cl-slug - (sbcl-package->cl-source-package sbcl-cl-slug)) +(define-public ecl-cl-out123 + (sbcl-package->ecl-package sbcl-cl-out123)) -(define-public sbcl-string-case - (let ((commit "718c761e33749e297cd2809c7ba3ade1985c49f7") - (revision "0")) +(define-public sbcl-cl-package-locks + (let ((commit "96a358ede7cef416d61d2f699e724fe1d9de602c") + (revision "1")) (package - (name "sbcl-string-case") + (name "sbcl-cl-package-locks") (version (git-version "0.0.2" revision commit)) - (home-page "https://github.com/pkhuong/string-case") (source (origin (method git-fetch) (uri (git-reference - (url home-page) + (url "https://github.com/elliottjohnson/cl-package-locks") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-package-locks" version)) (sha256 - (base32 - "1n5i3yh0h5s636rcnwn7jwqy3rjflikra04lymimhpcshhjsk0md")))) + (base32 "0g3gfljnvpgd66ccd2sqawlkwqx4a0wsdrg5180va61w869cgxqq")))) (build-system asdf-build-system/sbcl) - (synopsis "Efficient string= case in Common Lisp") + (home-page "https://github.com/elliottjohnson/cl-package-locks") + (synopsis "Compatibility layer for dealing with package locks") (description - "@code{string-case} is a Common Lisp macro that generates specialised decision -trees to dispatch on string equality.") - (license license:bsd-3)))) + "This is a Common Lisp library providing a unified way to work with +package locks across supported Common Lisp implementations.") + (license license:expat)))) -(define-public cl-string-case - (sbcl-package->cl-source-package sbcl-string-case)) +(define-public cl-package-locks + (sbcl-package->cl-source-package sbcl-cl-package-locks)) -(define-public ecl-string-case - (sbcl-package->ecl-package sbcl-string-case)) +(define-public ecl-cl-package-locks + (sbcl-package->ecl-package sbcl-cl-package-locks)) -(define-public sbcl-garbage-pools - (let ((commit "9a7cb7f48b04197c0495df3b6d2e8395ad13f790") +(define-public sbcl-cl-pass + (let ((commit "e58e97c0c0588dc742c061208afb9bc31e4dbd34") (revision "1")) (package - (name "sbcl-garbage-pools") - (version (git-version "0.1.2" revision commit)) + (name "sbcl-cl-pass") + (version (git-version "0.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/archimag/garbage-pools") + (url "https://github.com/eudoxia0/cl-pass") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-pass" version)) (sha256 - (base32 "04jqwr6j138him6wc4nrwjzm4lvyj5j31xqab02nkf8h9hmsf5v1")))) + (base32 "05qx4jrkxqbqi72cxgswbpnifbdvp9mh7apc7566v522899bh0hb")))) (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.") + (inputs + (list sbcl-ironclad sbcl-trivial-utf-8 sbcl-split-sequence)) + (native-inputs + (list sbcl-fiveam)) + (home-page "https://github.com/eudoxia0/cl-pass") + (synopsis "Password hashing and verification library") + (description + "@code{cl-pass} is a password hashing and verification library.") (license license:expat)))) -(define-public ecl-garbage-pools - (sbcl-package->ecl-package sbcl-garbage-pools)) +(define-public cl-pass + (sbcl-package->cl-source-package sbcl-cl-pass)) -(define-public cl-garbage-pools - (sbcl-package->cl-source-package sbcl-garbage-pools)) +(define-public ecl-cl-pass + (sbcl-package->ecl-package sbcl-cl-pass)) -(define-public sbcl-global-vars - (let ((commit "c749f32c9b606a1457daa47d59630708ac0c266e") - (revision "0")) +(define-public sbcl-cl-pcg + (let ((commit "8263d85ab0ca17fb05637a4430c2d564456bce8f") + (revision "1")) (package - (name "sbcl-global-vars") + (name "sbcl-cl-pcg") (version (git-version "1.0.0" revision commit)) - (home-page "https://github.com/lmj/global-vars") (source (origin (method git-fetch) (uri (git-reference - (url home-page) + (url "https://github.com/sjl/cl-pcg") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-pcg" version)) (sha256 - (base32 - "06m3xc8l3pgsapl8fvsi9wf6y46zs75cp9zn7zh6dc65v4s5wz3d")))) + (base32 "0s57wvvlvshp1gcp9i9d3qcmqhswnxps3i0y7wbb0v8i1a3p46m4")))) (build-system asdf-build-system/sbcl) - (synopsis "Efficient global variables in Common Lisp") + (native-inputs + (list sbcl-1am)) + (home-page "https://github.com/sjl/cl-pcg") + (synopsis "Permuted congruential generators in Common Lisp") (description - "In Common Lisp, a special variable that is never dynamically bound -typically serves as a stand-in for a global variable. The @code{global-vars} -library provides true global variables that are implemented by some compilers. -An attempt to rebind a global variable properly results in a compiler error. -That is, a global variable cannot be dynamically bound. - -Global variables therefore allow us to communicate an intended usage that -differs from special variables. Global variables are also more efficient than -special variables, especially in the presence of threads.") + "This is a bare-bones Permuted Congruential Generator implementation in +pure Common Lisp.") (license license:expat)))) -(define-public cl-global-vars - (sbcl-package->cl-source-package sbcl-global-vars)) +(define-public cl-pcg + (sbcl-package->cl-source-package sbcl-cl-pcg)) -(define-public ecl-global-vars - (sbcl-package->ecl-package sbcl-global-vars)) +(define-public ecl-cl-pcg + (let ((pkg (sbcl-package->ecl-package sbcl-cl-pcg))) + (package + (inherit pkg) + (arguments + (substitute-keyword-arguments (package-arguments pkg) + ;; Tests are failing on ECL with: + ;; PCG.TEST::TEST-REWINDAn error occurred during initialization: + ;; 40502229875678917802724098623316930025 is not of type + ;; (INTEGER 0 2305843009213693951) + ((#:tests? _ #f) #f)))))) -(define-public sbcl-trivial-file-size - (let ((commit "1c1d672a01a446ba0391dbb4ffc40be3b0476f23") - (revision "0")) +(define-public sbcl-cl-pdf + (let ((commit "ee904a118a0f060279ad9d253a3e8e3997609213") + (revision "3")) (package - (name "sbcl-trivial-file-size") - (version (git-version "0.0.0" revision commit)) - (home-page "https://github.com/ruricolist/trivial-file-size") + (name "sbcl-cl-pdf") + (version (git-version "2.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url home-page) + (url "https://github.com/mbattyani/cl-pdf") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-pdf" version)) (sha256 - (base32 - "17pp86c9zs4y7i1sh7q9gbfw9iqv6655k7fz8qbj9ly1ypgxp4qs")))) + (base32 "0j7hbqv6yzrgx0inqinpw8h22728l53ccciw6iymzz4g92j9fzlq")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-fiveam)) - (synopsis "Size of a file in bytes in Common Lisp") + (inputs + (list sbcl-iterate sbcl-zpb-ttf)) + (arguments + `(#:asd-systems '("cl-pdf" "cl-pdf-parser"))) + (home-page "https://github.com/mbattyani/cl-pdf") + (synopsis "Common Lisp library for generating PDF files") (description - "The canonical way to determine the size of a file in bytes, using Common Lisp, -is to open the file with an element type of (unsigned-byte 8) and then -calculate the length of the stream. This is less than ideal. In most cases -it is better to get the size of the file from its metadata, using a system -call. - -This library exports a single function, file-size-in-octets. It returns the -size of a file in bytes, using system calls when possible.") - (license license:expat)))) + "CL-PDF is a cross-platform Common Lisp library for generating PDF +files.") + (license license:bsd-2)))) -(define-public cl-trivial-file-size - (sbcl-package->cl-source-package sbcl-trivial-file-size)) +(define-public cl-pdf + (sbcl-package->cl-source-package sbcl-cl-pdf)) -(define-public ecl-trivial-file-size - (sbcl-package->ecl-package sbcl-trivial-file-size)) +(define-public ecl-cl-pdf + (sbcl-package->ecl-package sbcl-cl-pdf)) -(define-public sbcl-trivial-macroexpand-all - (let ((commit "933270ac7107477de1bc92c1fd641fe646a7a8a9") +(define-public sbcl-cl-permutation + (let ((commit "20c10e9ca56452d2fafc3ec0984dcdf78b4f4b19") (revision "0")) (package - (name "sbcl-trivial-macroexpand-all") + (name "sbcl-cl-permutation") (version (git-version "0.0.0" revision commit)) - (home-page "https://github.com/cbaggers/trivial-macroexpand-all") (source (origin (method git-fetch) (uri (git-reference - (url home-page) + (url "https://github.com/stylewarning/cl-permutation") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-permutation" version)) (sha256 - (base32 - "191hnn4b5j4i3crydmlzbm231kj0h7l8zj6mzj69r1npbzkas4bd")))) + (base32 "0i932g0k50y24hxizni6zfya4kcw77yk3b0llivm9g50s7fxj9dk")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-fiveam)) - (synopsis "Portable macroexpand-all for Common Lisp") + (native-inputs (list sbcl-fiasco)) + (inputs + (list sbcl-alexandria + sbcl-bordeaux-fft + sbcl-cl-algebraic-data-type + sbcl-cl-cont + sbcl-closer-mop + sbcl-iterate + sbcl-priority-queue)) + (synopsis "Permutations and permutation groups in Common Lisp") (description - "This library provides a macroexpand-all function that calls the -implementation specific equivalent.") - (license license:unlicense)))) + "This is a Commin Lisp library for operating on permutations and +permutation groups.") + (home-page "https://github.com/stylewarning/cl-permutation") + (license license:bsd-3)))) -(define-public cl-trivial-macroexpand-all - (sbcl-package->cl-source-package sbcl-trivial-macroexpand-all)) +(define-public cl-permutation + (sbcl-package->cl-source-package sbcl-cl-permutation)) -(define-public ecl-trivial-macroexpand-all - (sbcl-package->ecl-package sbcl-trivial-macroexpand-all)) +(define-public ecl-cl-permutation + (sbcl-package->ecl-package sbcl-cl-permutation)) -(define-public sbcl-serapeum - (let ((commit "c08442a9757b7fa30ac345cb040e1642f97f6b78") - (revision "12")) +(define-public sbcl-cl-portaudio + (let ((commit "c50cd061c25216a736f684e45101f5c0188a384f") + (revision "1")) (package - (name "sbcl-serapeum") - (version (git-version "0.0.0" revision commit)) - (home-page "https://github.com/ruricolist/serapeum") + (name "sbcl-cl-portaudio") + (version (git-version "1.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url home-page) + (url "https://github.com/filonenko-mikhail/cl-portaudio") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-portaudio" version)) (sha256 - (base32 "1sabd048agvgv7bhbw126rci9hf45fk08zhghcv6an2h6xwmc3qv")))) + (base32 "177c6bgf30caj5qpzfnzhbamax7c5zm2p4911mw7fay94vjs7zyb")))) (build-system asdf-build-system/sbcl) (inputs - (list sbcl-alexandria - sbcl-trivia - sbcl-split-sequence - sbcl-string-case - sbcl-parse-number - sbcl-trivial-garbage - sbcl-bordeaux-threads - sbcl-parse-declarations - sbcl-introspect-environment - sbcl-trivial-cltl2 - sbcl-global-vars - sbcl-trivial-file-size - sbcl-trivial-macroexpand-all)) - (native-inputs - (list sbcl-atomics - sbcl-fiveam - sbcl-local-time)) + (list portaudio sbcl-cffi sbcl-ffa)) (arguments - (list #:phases + (list #:tests? #f ; Tests need access to sound cards + #:phases #~(modify-phases %standard-phases - (add-after 'unpack 'disable-failing-tests - (lambda _ - (substitute* "serapeum.asd" - ;; Guix does not have Quicklisp, and probably never will. - (("\\(:file \"quicklisp\"\\)") ""))))))) - (synopsis "Common Lisp utility library beyond Alexandria") + (add-after 'unpack 'fix-paths + (lambda* (#:key inputs #:allow-other-keys) + (substitute* "src/portaudio.lisp" + (("libportaudio\\.so") + (search-input-file inputs "/lib/libportaudio.so")))))))) + (synopsis "Common Lisp bindings to portaudio") (description - "Serapeum is a conservative library of Common Lisp utilities. It is a -supplement, not a competitor, to Alexandria.") + "This package provides audio input and output functions to Common Lisp +using bindings to the portaudio library.") + (home-page "https://github.com/filonenko-mikhail/cl-portaudio") (license license:expat)))) -(define-public cl-serapeum - (sbcl-package->cl-source-package sbcl-serapeum)) +(define-public cl-portaudio + (sbcl-package->cl-source-package sbcl-cl-portaudio)) -(define-public ecl-serapeum - (sbcl-package->ecl-package sbcl-serapeum)) +(define-public ecl-cl-portaudio + (sbcl-package->ecl-package sbcl-cl-portaudio)) -(define-public sbcl-rutils - (let ((commit "db3c3f4ae897025b5f0cd81042ca147da60ca0c5") - (revision "0")) +(define-public sbcl-cl-posix-mqueue + (let ((commit "8977370c7206d1f62bd1be80f4254af40654b83f") + (revision "1")) (package - (name "sbcl-rutils") - (version (git-version "5.2.1" revision commit)) + (name "sbcl-cl-posix-mqueue") + (version (git-version "0.1.2" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/vseloved/rutils") + (url "https://github.com/xFA25E/cl-posix-mqueue") (commit commit))) - (file-name (git-file-name "rutils" version)) + (file-name (git-file-name "cl-posix-mqueue" version)) (sha256 - (base32 "1d2whscknh1zga2vdqvfqri8wx0gnml3sfqz62igq0ppap6q07y3")))) + (base32 "04519rg8vc782z097dzlb8nx0skab2fy2zd0m60r6mz2nw8xdvh6")))) (build-system asdf-build-system/sbcl) (arguments - `(#:asd-systems '("rutils" "rutilsx") - ;; Tests disabled because of a circular dependency with should-test. - #:tests? #f - #:phases + `(#:phases (modify-phases %standard-phases - (add-after 'unpack 'fix-build - (lambda _ - ;; File faild to load, and we don't use it as tests are - ;; disabled, so let's delete it. - (delete-file "rutilsx-test.asd")))))) + (add-after 'unpack 'patch-librt-path + (lambda* (#:key inputs #:allow-other-keys) + (substitute* "src/spec.lisp" + (("librt.so" all) + (string-append (assoc-ref inputs "glibc") "/lib/" all)))))))) + (native-inputs + `(("cl-ppcre" ,sbcl-cl-ppcre) + ("rove" ,sbcl-rove))) (inputs - `(("closer-mop" ,sbcl-closer-mop) - ("named-readtables" ,sbcl-named-readtables))) - (home-page "https://github.com/vseloved/rutils") - (synopsis "Radical Utilities for Common Lisp") - (description "RUTILS is a syntactic utilities package for Common Lisp.") - (license license:bsd-3)))) + `(("alexandria" ,sbcl-alexandria) + ("babel" ,sbcl-babel) + ("cffi" ,sbcl-cffi) + ("glibc" ,glibc) + ("local-time" ,sbcl-local-time))) + (home-page "https://github.com/xFA25E/cl-posix-mqueue") + (synopsis "Common Lisp binding to POSIX mqueue") + (description + "This package provides Common Lisp bindings to POSIX message queue, an +@acronym{IPC, Inter-Process Communication} method that is easy to use and quick +to setup.") + (license license:gpl3)))) -(define-public cl-rutils - (sbcl-package->cl-source-package sbcl-rutils)) +(define-public cl-posix-mqueue + (sbcl-package->cl-source-package sbcl-cl-posix-mqueue)) -(define-public ecl-rutils - (sbcl-package->ecl-package sbcl-rutils)) +(define-public ecl-cl-posix-mqueue + (sbcl-package->ecl-package sbcl-cl-posix-mqueue)) -(define-public sbcl-arrow-macros - ;; The latest upstream version tag is dated (pushed in 2020), use the latest - ;; commit instead. - (let ((commit "16bdfd31298182099c7d70df4598104e5a38b05e") - (revision "0")) +(define-public sbcl-cl-ppcre + (package + (name "sbcl-cl-ppcre") + (version "2.1.1") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/edicl/cl-ppcre") + (commit (string-append "v" version)))) + (file-name (git-file-name "cl-ppcre" version)) + (sha256 + (base32 "0dwvr29diqzcg5n6jvbk2rnd90i05l7n828hhw99khmqd0kz7xsi")))) + (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-flexi-streams)) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'disable-ppcre-unicode + ;; cl-ppcre and cl-ppcre-unicode are put in different packages + ;; to work around the circular dependency between edicl/cl-ppcre + ;; and edicl/cl-unicode. + (lambda _ + (delete-file "cl-ppcre-unicode.asd") + #t))))) + (synopsis "Portable regular expression library for Common Lisp") + (description "CL-PPCRE is a portable regular expression library for Common +Lisp, which is compatible with perl. It is pretty fast, thread-safe, and +compatible with ANSI-compliant Common Lisp implementations.") + (home-page "http://weitz.de/cl-ppcre/") + (license license:bsd-2))) + +(define-public cl-ppcre + (sbcl-package->cl-source-package sbcl-cl-ppcre)) + +(define-public ecl-cl-ppcre + (sbcl-package->ecl-package sbcl-cl-ppcre)) + +(define-public sbcl-cl-ppcre-unicode + (package (inherit sbcl-cl-ppcre) + (name "sbcl-cl-ppcre-unicode") + (inputs + (list sbcl-cl-ppcre sbcl-cl-unicode)) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'disable-ppcre + ;; cl-ppcre and cl-ppcre-unicode are put in different packages + ;; to work around the circular dependency between edicl/cl-ppcre + ;; and edicl/cl-unicode. + (lambda _ + (delete-file "cl-ppcre.asd") + #t))))))) + +(define-public cl-ppcre-unicode + (sbcl-package->cl-source-package sbcl-cl-ppcre-unicode)) + +(define-public ecl-cl-ppcre-unicode + (sbcl-package->ecl-package sbcl-cl-ppcre-unicode)) + +(define-public sbcl-cl-prevalence + (let ((commit "e6b27640ce89ae5f8af38beb740e319bb6cd2368") + (revision "6")) (package - (name "sbcl-arrow-macros") - (version (git-version "0.2.7" revision commit)) + (name "sbcl-cl-prevalence") + (build-system asdf-build-system/sbcl) + (version (git-version "5" revision commit)) + (home-page "https://github.com/40ants/cl-prevalence") (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/hipeta/arrow-macros") + (url home-page) (commit commit))) - (file-name (git-file-name "arrow-macros" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "0q4vpysk4h9ghs5zmnzzilky9jyz7i8n0x0p98nq528crbrkh6c4")))) - (build-system asdf-build-system/sbcl) - (native-inputs (list sbcl-fiveam)) - (home-page "https://github.com/hipeta/arrow-macros/") - (synopsis "Clojure-like arrow macros in Common Lisp") - (description - "Arrow-macros provides clojure-like arrow macros (ex. ->, ->>) and diamond wands -in swiss-arrows.") - (license license:expat)))) + (base32 + "1lb957ivshgp56phqhvhsmnc4r55x5shvi3mpsan2xsm4hvqspp0")))) + (inputs + (list sbcl-moptilities sbcl-s-sysdeps sbcl-s-xml)) + (native-inputs + (list sbcl-fiveam sbcl-find-port)) + (synopsis "Implementation of object prevalence for Common Lisp") + (description "This Common Lisp library implements object prevalence (see +@url{https://en.wikipedia.org/wiki/System_prevalence}). It allows +for (de)serializing to and from s-exps as well as XML. Serialization of arbitrary +classes and cyclic data structures are supported.") + (license license:llgpl)))) -(define-public cl-arrow-macros - (sbcl-package->cl-source-package sbcl-arrow-macros)) +(define-public cl-prevalence + (sbcl-package->cl-source-package sbcl-cl-prevalence)) -(define-public ecl-arrow-macros - (sbcl-package->ecl-package sbcl-arrow-macros)) +(define-public ecl-cl-prevalence + (sbcl-package->ecl-package sbcl-cl-prevalence)) -(define-public sbcl-arrows - (let ((commit "df7cf0067e0132d9697ac8b1a4f1b9c88d4f5382") - (revision "0")) +(define-public sbcl-cl-progress-bar + (let ((commit "9374170858663c8fe829e9fb5a29bd2cb48d95ae")) (package - (name "sbcl-arrows") - (version (git-version "0.2.0" revision commit)) + (name "sbcl-cl-progress-bar") + (version (git-version "0.0.0" "1" commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://gitlab.com/Harleqin/arrows.git") + (url "https://github.com/sirherrbatka/cl-progress-bar/") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 - "042k9vkssrqx9nhp14wdzm942zgdxvp35mba0p2syz98i75im2yy")))) + (base32 "1ldb4qhmx431n3lsq71ynwb9ybazbfqd55icjbhi06mj52ngndir")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-hu.dwim.stefil)) - (synopsis "Clojure-like arrow macros for Common Lisp") + (inputs + (list sbcl-bordeaux-threads sbcl-documentation-utils-extensions)) + (home-page "https://github.com/sirherrbatka/cl-progress-bar/") + (synopsis "Progress bars in Common Lisp") (description - "This library implements the @code{->} and @code{->>} macros from -Clojure, as well as several expansions on the idea.") - (home-page "https://gitlab.com/Harleqin/arrows") - (license license:public-domain)))) + "This library provides almost the same code as used inside Quicklisp +for drawning progress bars") + (license license:expat)))) -(define-public cl-arrows - (sbcl-package->cl-source-package sbcl-arrows)) +(define-public cl-progress-bar + (sbcl-package->cl-source-package sbcl-cl-progress-bar)) -(define-public ecl-arrows - (sbcl-package->ecl-package sbcl-arrows)) +(define-public ecl-cl-progress-bar + (sbcl-package->ecl-package sbcl-cl-progress-bar)) -(define-public sbcl-simple-parallel-tasks - (let ((commit "ce7b60f788d8f68dfb69b24aac54c0e3b63379a6") +(define-public sbcl-cl-project + (let ((commit "151107014e534fc4666222d57fec2cc8549c8814") (revision "1")) (package - (name "sbcl-simple-parallel-tasks") - (version (git-version "1.0" revision commit)) + (name "sbcl-cl-project") + (version (git-version "0.3.1" revision commit)) + (home-page "https://github.com/fukamachi/cl-project") (source (origin (method git-fetch) (uri (git-reference - (url "https://codeberg.org/glv/simple-parallel-tasks") + (url home-page) (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 "0gvbpyff4siifp3cp86cpr9ksmakn66fx21f3h0hpn647zl07nj7")))) + (base32 "1rmh6s1ncv8s2yrr14ja9wisgg745sq6xibqwb341ikdicxdp26y")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-fiveam)) (inputs - (list sbcl-chanl)) - (synopsis "Common Lisp library to evaluate some forms in parallel") - (description "This is a simple Common Lisp library to evaluate some -forms in parallel.") - (home-page "https://codeberg.org/glv/simple-parallel-tasks") - (license license:gpl3)))) + `(("cl-emb" ,sbcl-cl-emb) + ("cl-ppcre" ,sbcl-cl-ppcre) + ("local-time" ,sbcl-local-time) + ("prove" ,sbcl-prove))) + (arguments + ;; Tests depend on caveman, which in turns depends on cl-project. + '(#:tests? #f)) + (synopsis "Generate a skeleton for modern Common Lisp projects") + (description "This library provides a modern project skeleton generator. +In contract with other generators, CL-Project generates one package per file +and encourages unit testing by generating a system for unit testing, so you +can begin writing unit tests as soon as the project is generated.") + (license license:llgpl)))) -(define-public cl-simple-parallel-tasks - (sbcl-package->cl-source-package sbcl-simple-parallel-tasks)) +(define-public cl-project + (sbcl-package->cl-source-package sbcl-cl-project)) -(define-public ecl-simple-parallel-tasks - (sbcl-package->ecl-package sbcl-simple-parallel-tasks)) +(define-public ecl-cl-project + (sbcl-package->ecl-package sbcl-cl-project)) -(define-public sbcl-cl-heap +(define-public sbcl-cl-punch (package - (name "sbcl-cl-heap") - (version "0.1.6") + (name "sbcl-cl-punch") + (version "0.2") (source (origin - (method url-fetch) - (uri (string-append "https://common-lisp.net/project/cl-heap/releases/" - "cl-heap_" version ".tar.gz")) + (method git-fetch) + (uri (git-reference + (url "https://github.com/windymelt/cl-punch") + (commit (string-append "v" version)))) + (file-name (git-file-name "cl-punch" version)) (sha256 - (base32 - "163hb07p2nxz126rpq3cj5dyala24n0by5i5786n2qcr1w0bak4i")))) + (base32 "1vmbaz9y9lq4wvi8mfbyif8vc9yfk2i0qd3ysbzl152wx32dbzs3")))) (build-system asdf-build-system/sbcl) (native-inputs - (list sbcl-xlunit)) - (arguments - '(#:asd-test-systems '("cl-heap-tests"))) - (synopsis "Heap and priority queue data structures for Common Lisp") + (list sbcl-prove)) + (inputs + (list sbcl-cl-syntax)) + (home-page "https://github.com/windymelt/cl-punch") + (synopsis "Anonymous lambda literal in Common Lisp, respecting Scala") (description - "CL-HEAP provides various implementations of heap data structures (a -binary heap and a Fibonacci heap) as well as an efficient priority queue.") - (home-page "https://common-lisp.net/project/cl-heap/") - (license license:gpl3+))) + "CL-PUNCH is a Scala-like anonymous lambda literal.") + (license license:expat ))) -(define-public cl-heap - (sbcl-package->cl-source-package sbcl-cl-heap)) +(define-public cl-punch + (sbcl-package->cl-source-package sbcl-cl-punch)) -(define-public ecl-cl-heap - (sbcl-package->ecl-package sbcl-cl-heap)) +(define-public ecl-cl-punch + (sbcl-package->ecl-package sbcl-cl-punch)) -(define-public sbcl-curry-compose-reader-macros - (let ((commit "beaa92dedf392726c042184bfd6149fa8d9e6ac2") - (revision "0")) +(define-public sbcl-cl-qprint + (let ((commit "bfe398551cbfb7ca84a9ba59a26a1116ac5c06eb") + (revision "1")) (package - (name "sbcl-curry-compose-reader-macros") - (version (git-version "1.0.0" revision commit)) + (name "sbcl-cl-qprint") + (version (git-version "0.9.0" revision commit)) (source (origin (method git-fetch) - (uri - (git-reference - (url "https://github.com/eschulte/curry-compose-reader-macros") - (commit commit))) + (uri (git-reference + (url "https://github.com/eugeneia/cl-qprint/") + (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 - "0rv9bl8xrad5wfcg5zs1dazvnpmvqz6297lbn8bywsrcfnlf7h98")))) + (base32 "099h0rrdzxnlmn8avi72mg2dl0kccp7w01b2p9nwyy4b8yr32cir")))) (build-system asdf-build-system/sbcl) (inputs - (list sbcl-alexandria sbcl-named-readtables)) - (synopsis "Reader macros for partial application and composition") + (list sbcl-flexi-streams)) + (home-page "https://github.com/eugeneia/cl-qprint/") + (synopsis "Implementation of the quoted-printable encoding") (description - "This Common Lisp library provides reader macros for concise expression -of function partial application and composition.") - (home-page "https://eschulte.github.io/curry-compose-reader-macros/") - (license license:public-domain)))) + "This Common Lisp library implements the quoted-printable encoding as +described in RFC 2045 (see @url{http://tools.ietf.org/html/rfc2045}).") + (license license:lgpl2.1)))) -(define-public cl-curry-compose-reader-macros - (sbcl-package->cl-source-package sbcl-curry-compose-reader-macros)) +(define-public cl-qprint + (sbcl-package->cl-source-package sbcl-cl-qprint)) -(define-public ecl-curry-compose-reader-macros - (sbcl-package->ecl-package sbcl-curry-compose-reader-macros)) +(define-public ecl-cl-qprint + (sbcl-package->ecl-package sbcl-cl-qprint)) -(define-public sbcl-yason +(define-public sbcl-cl-qrencode (package - (name "sbcl-yason") - (version "0.8.4") + (name "sbcl-cl-qrencode") + (version "0.1.2") (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/phmarek/yason") + (url "https://github.com/jnjcc/cl-qrencode") (commit (string-append "v" version)))) - (file-name (git-file-name "cl-yason" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "0d22sw7nf2ygqm56ilybg7bza63cv43pc4184r8rvsjz2in37n51")))) + (base32 "1l5k131dchbf6cj8a8xqa731790p01p3qa1kdy2wa9dawy3ymkxr")))) (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-lisp-unit)) (inputs - (list sbcl-alexandria sbcl-trivial-gray-streams)) - (synopsis "Common Lisp JSON parser/encoder") + (list sbcl-zpng)) + (synopsis "QR code encoder for Common Lisp") (description - "YASON is a Common Lisp library for encoding and decoding data in the -JSON interchange format.") - (home-page "https://github.com/phmarek/yason") - (license license:bsd-3))) + "This Common Lisp library provides function to make QR codes and to save +them as PNG files.") + (home-page "https://github.com/jnjcc/cl-qrencode") + (license license:gpl2+))) -(define-public cl-yason - (sbcl-package->cl-source-package sbcl-yason)) +(define-public cl-qrencode + (sbcl-package->cl-source-package sbcl-cl-qrencode)) -(define-public ecl-yason - (sbcl-package->ecl-package sbcl-yason)) +(define-public ecl-cl-qrencode + (sbcl-package->ecl-package sbcl-cl-qrencode)) -(define-public sbcl-graph - (let ((commit "78bf9ec930d8eae4f0861b5be76765fb1e45e24f") - (revision "0")) - (package - (name "sbcl-graph") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri - (git-reference - (url "https://github.com/eschulte/graph") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "1qpij4xh8bqwc2myahpilcbh916v7vg0acz2fij14d3y0jm02h0g")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-stefil)) - (inputs - `(("alexandria" ,sbcl-alexandria) - ("cl-heap" ,sbcl-cl-heap) - ("cl-ppcre" ,sbcl-cl-ppcre) - ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros) - ("metabang-bind" ,sbcl-metabang-bind) - ("named-readtables" ,sbcl-named-readtables) - ("yason" ,sbcl-yason))) - (arguments - '(#:asd-systems '("graph" - "graph/dot" - "graph/json"))) - (synopsis "Graph data structure and algorithms for Common Lisp") - (description - "The GRAPH Common Lisp library provides a data structures to represent -graphs, as well as some graph manipulation and analysis algorithms (shortest -path, maximum flow, minimum spanning tree, etc.).") - (home-page "https://eschulte.github.io/graph/") - (license license:gpl3+)))) +(define-public sbcl-cl-randist + (package + (name "sbcl-cl-randist") + (version "0.4.2") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/lvaruzza/cl-randist") + (commit "f088a54b540a7adefab7c04094a6103f9edda3d0"))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "0l8hyd6nbxb7f50vyxz3rbbm7kgr1fnadc40jywy4xj5vi5kpj5g")))) + (build-system asdf-build-system/sbcl) + (synopsis "Random distributions for Common Lisp") + (description + "Manual translation from C to Common Lisp of some random number +generation functions from the GSL library.") + (home-page "https://github.com/lvaruzza/cl-randist") + (license license:bsd-2) + (arguments + `(#:tests? #f)))) -(define-public cl-graph - (sbcl-package->cl-source-package sbcl-graph)) +(define-public cl-randist + (sbcl-package->cl-source-package sbcl-cl-randist)) -(define-public ecl-graph - (sbcl-package->ecl-package sbcl-graph)) +(define-public ecl-cl-randist + (sbcl-package->ecl-package sbcl-cl-randist)) -(define-public sbcl-trivial-indent - (let ((commit "f25275094b80df8aa158af46db980bbc3ce2f88b") +(define-public sbcl-cl-random + (let ((commit "5bb65911037f95a4260bd29a594a09df3849f4ea") (revision "1")) (package - (name "sbcl-trivial-indent") - (version (git-version "1.0.0" revision commit)) + (name "sbcl-cl-random") + (version (git-version "0.0.1" revision commit)) (source (origin (method git-fetch) - (uri - (git-reference - (url "https://github.com/Shinmera/trivial-indent") - (commit commit))) - (file-name (git-file-name "cl-trivial-indent" version)) + (uri (git-reference + (url "https://github.com/tpapp/cl-random") + (commit commit))) + (file-name (git-file-name "cl-random" version)) (sha256 - (base32 "1zg8cyy1xqpcjrxxqz5zb5xixhwcszkv4p2vq305lb2rka6f3dyx")))) + (base32 "0jn80xphyvyp2v72acr6b8a2f6dw06myr5vrjfl14brsvks7wr89")))) (build-system asdf-build-system/sbcl) - (synopsis - "Simple Common Lisp library to allow indentation hints for SWANK") + (inputs + (list sbcl-alexandria + sbcl-anaphora + sbcl-array-operations + sbcl-cl-num-utils + sbcl-cl-rmath + sbcl-cl-slice + sbcl-gsll + sbcl-let-plus + sbcl-lla)) + (native-inputs + (list sbcl-clunit)) + (home-page "https://github.com/tpapp/cl-random") + (synopsis "Random variates for Common Lisp") (description - "This library allows you to define custom indentation hints for your -macros if the one recognised by SLIME automatically produces unwanted -results.") - (home-page "https://shinmera.github.io/trivial-indent/") - (license license:zlib)))) + "@code{cl-random} is a library for generating random draws from various +commonly used distributions, and for calculating statistical functions, such as +density, distribution and quantiles for these distributions.") + (license license:expat)))) -(define-public cl-trivial-indent - (sbcl-package->cl-source-package sbcl-trivial-indent)) +(define-public cl-random + (sbcl-package->cl-source-package sbcl-cl-random)) -(define-public ecl-trivial-indent - (sbcl-package->ecl-package sbcl-trivial-indent)) +(define-public ecl-cl-random + (sbcl-package->ecl-package sbcl-cl-random)) -(define-public sbcl-data-format-validation - (let ((commit "95d44766e829582598f9dcdc5c23719c462d5bfb") +(define-public sbcl-cl-random-forest + (let ((commit "fedb36ce99bb6f4d7e3a7dd6d8b058f331308f91") (revision "1")) (package - (name "sbcl-data-format-validation") - (version (git-version "0.2.0" revision commit)) + (name "sbcl-cl-random-forest") + (version (git-version "0.1" revision commit)) (source (origin (method git-fetch) - (uri - (git-reference - (url "https://github.com/willijar/cl-data-format-validation/") - (commit commit))) - (file-name (git-file-name "data-format-validation" version)) + (uri (git-reference + (url "https://github.com/masatoi/cl-random-forest") + (commit commit))) + (file-name (git-file-name name version)) (sha256 (base32 - "0zmk47xmicyqvp1impn8kgh5373ysmx3gfpqcvbi9r31qsir2nqa")))) + "0wqh4dxy5hrvm14jgyfypwhdw35f24rsksid4blz5a6l2z16rlmq")))) (build-system asdf-build-system/sbcl) + (native-inputs + `(("prove" ,sbcl-prove) + ("trivial-garbage" ,sbcl-trivial-garbage))) (inputs - (list sbcl-cl-ppcre)) - (synopsis "Validation and conversion between user and internal data") - (description - "@code{data-format-validation} is a library for Common Lisp providing a -consistent regular interface for converting (and validating) external data (in -the form of strings usually) into internal data types and for formatting -internal data back into external presentable strings, all according to a -conversion or type specification.") - (home-page "http://www.jarw.org.uk/lisp/cl-data-format-validation.html") - (license license:gpl3)))) - -(define-public sbcl-cl-docutils - (let ((commit "756b5ad42360e84d8225fa69815bdd1623ceaa40") - (revision "1")) - (package - (name "sbcl-cl-docutils") - (version (git-version "0.1.1" revision commit)) - (source - (origin - (method git-fetch) - (uri - (git-reference - (url "https://github.com/willijar/cl-docutils/") - (commit commit))) - (file-name (git-file-name "cl-docutils" version)) - (sha256 - (base32 - "132bxlj0jlhiabi29mygmkcbbgyb5s1yz1xdfhm3pgrf9f8605gg")))) - (build-system asdf-build-system/sbcl) + `(("alexandria" ,sbcl-alexandria) + ("cl-libsvm-format" ,sbcl-cl-libsvm-format) + ("cl-online-learning" ,sbcl-cl-online-learning) + ("lparallel" ,sbcl-lparallel))) (arguments - '(#:asd-systems '("docutils"))) - (inputs - (list sbcl-cl-ppcre - sbcl-data-format-validation - sbcl-trivial-gray-streams)) - (synopsis "Document utilities and Restructured text parser") + `(#:tests? #f)) ; The tests download data from the Internet + (synopsis "Random Forest and Global Refinement for Common Lisp") (description - "@code{cl-docutils} is a Common Lisp implementation of the Docutils text -processing system for processing plaintext into presentational formats such as -HTML and LaTeX. It is based upon the Python Docutils reference implementation -but uses Common Lisp idioms making it easier to extend and more flexible. As -with the reference implementation it includes a parser for the reStructured -text plaintext markup syntax which is suitable for marking up documentation -and for use as user markup for collaborative web sites. It is successfully -used to support a higher education peer-review assessment and online tutorial -system.") - (home-page "http://www.jarw.org.uk/lisp/cl-docutils.html") - (license license:gpl3)))) + "CL-random-forest is an implementation of Random Forest for multiclass +classification and univariate regression written in Common Lisp. It also +includes an implementation of Global Refinement of Random Forest.") + (home-page "https://github.com/masatoi/cl-random-forest") + (license license:expat)))) -(define-public cl-docutils - (sbcl-package->cl-source-package sbcl-cl-docutils)) +(define-public cl-random-forest + (sbcl-package->cl-source-package sbcl-cl-random-forest)) -(define-public ecl-cl-docutils - (sbcl-package->ecl-package sbcl-cl-docutils)) +(define-public ecl-cl-random-forest + (sbcl-package->ecl-package sbcl-cl-random-forest)) -(define-public sbcl-documentation-utils - (let ((commit "98630dd5f7e36ae057fa09da3523f42ccb5d1f55") +(define-public sbcl-cl-raylib + (let ((commit "985ceebef4cb56c651cddc23bd71812f2be38c2d") (revision "0")) (package - (name "sbcl-documentation-utils") - (version (git-version "1.2.0" revision commit)) - (source - (origin - (method git-fetch) - (uri - (git-reference - (url "https://github.com/Shinmera/documentation-utils") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "098qhkqskmmrh4wix34mawf7p5c87yql28r51r75yjxj577k5idq")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-trivial-indent)) - (synopsis "Few simple tools to document Common Lisp libraries") - (description - "This is a small library to help you with managing the Common Lisp -docstrings for your library.") - (home-page "https://shinmera.github.io/documentation-utils/") - (license license:zlib)))) - -(define-public cl-documentation-utils - (sbcl-package->cl-source-package sbcl-documentation-utils)) - -(define-public ecl-documentation-utils - (sbcl-package->ecl-package sbcl-documentation-utils)) - -(define-public sbcl-documentation-utils-extensions - (let ((commit "f67f8a05d583174662a594b79356b201c1d9d750")) - (package - (name "sbcl-documentation-utils-extensions") - (version (git-version "0.0.0" "1" commit)) + (name "sbcl-cl-raylib") + (version (git-version "0.0.1" revision commit)) (source (origin (method git-fetch) - (uri - (git-reference - (url "https://github.com/sirherrbatka/documentation-utils-extensions/") - (commit commit))) - (file-name (git-file-name name version)) + (uri (git-reference + (url "https://github.com/longlene/cl-raylib") + (commit commit))) + (file-name (git-file-name "cl-raylib" version)) (sha256 - (base32 - "0pn45c9rbxlnhn5nvhqz6kyv0nlirwxpg4j27niwdq80yxzsn51f")))) + (base32 "1kighj35g6dn426mhr2ppz3gm49v1q4n42ydn619pclrqwyrnc2z")))) (build-system asdf-build-system/sbcl) + (arguments + `(#:tests? #f ; no tests https://github.com/longlene/cl-raylib/issues/40 + #:phases + (modify-phases %standard-phases + (add-after 'unpack 'fix-paths + (lambda* (#:key inputs #:allow-other-keys) + (substitute* "src/library.lisp" + (("libraylib\\.so") + (search-input-file inputs "/lib/libraylib.so")))))))) (inputs - (list sbcl-documentation-utils)) - (home-page "https://github.com/sirherrbatka/documentation-utils-extensions") - (synopsis "Set of extensions for documentation-utils") - (description - "Use @code{rich-formatter} to format documentation with sections @code{:syntax}, -@code{:arguments}, @code{:examples}, @code{:description}, @code{:returns}, -@code{:side-effects}, @code{:thread-safety}, @code{:affected-by}, -@code{:see-also} and @code{:notes}. Gather unformatted input by using -@code{rich-aggregating-formatter} and @code{*DOCUMENTATION*} variable. Find -gathered documentation with find-documentation function. Execute code stored -in documentation with @code{execute-documentation}. See the examples in the -@code{src/documentation.lisp} file. See the @code{documentation-utils} system -for more information.") + (list raylib + sbcl-3d-matrices + sbcl-3d-vectors + sbcl-alexandria + sbcl-cffi)) + (home-page "https://github.com/longlene/cl-raylib") + (synopsis "Common Lisp bindings to raylib") + (description "This package provides Common Lisp CFFI bindings to the +Raylib game development library.") (license license:expat)))) -(define-public cl-documentation-utils-extensions - (sbcl-package->cl-source-package sbcl-documentation-utils-extensions)) +(define-public cl-raylib + (sbcl-package->cl-source-package sbcl-cl-raylib)) -(define-public ecl-documentation-utils-extensions - (sbcl-package->ecl-package sbcl-documentation-utils-extensions)) +(define-public ecl-cl-raylib + (sbcl-package->ecl-package sbcl-cl-raylib)) -(define-public sbcl-charje.documentation +(define-public sbcl-cl-rdkafka (package - (name "sbcl-charje.documentation") - (version "0.0.0") + (name "sbcl-cl-rdkafka") + (version "1.1.0") (source (origin (method git-fetch) (uri (git-reference - (url "https://git.sr.ht/~charje/documentation") + (url "https://github.com/SahilKang/cl-rdkafka") (commit (string-append "v" version)))) + (file-name (git-file-name name version)) (sha256 (base32 - "149r9qdz5dyxsamhf5miaa9njr7kn7nc0ic448k133rs3nnwagqc")) - (file-name (git-file-name "cl-charje.documentation" version)))) + "0z2g0k0xy8k1p9g93h8dy9wbygaq7ziwagm4yz93zk67mhc0b84v")))) (build-system asdf-build-system/sbcl) + (arguments + `(#:tests? #f ; Attempts to connect to locally running Kafka + #:phases + (modify-phases %standard-phases + (add-after 'unpack 'fix-paths + (lambda* (#:key inputs #:allow-other-keys) + (substitute* "src/low-level/librdkafka-bindings.lisp" + (("librdkafka" all) + (string-append (assoc-ref inputs "librdkafka") "/lib/" + all)))))))) (inputs - (list sbcl-alexandria)) - (home-page "https://git.sr.ht/~charje/documentation") - (synopsis "Docstring parsing library for Common Lisp") - (description "Charje.documentation can used to parse Common Lisp -docstrings the charje way, or it can be used to create custom docstring -parsers. Docstring parsers are composed using mixin classes and -initialization methods.") - (license license:agpl3+))) + `(("bordeaux-threads" ,sbcl-bordeaux-threads) + ("cffi" ,sbcl-cffi) + ("librdkafka" ,librdkafka) + ("lparallel" ,sbcl-lparallel) + ("trivial-garbage" ,sbcl-trivial-garbage))) + (home-page "https://github.com/SahilKang/cl-rdkafka") + (synopsis "Common Lisp client library for Apache Kafka") + (description "A Common Lisp client library for Apache Kafka.") + (license license:gpl3))) -(define-public cl-charje.documentation - (sbcl-package->cl-source-package sbcl-charje.documentation)) +(define-public cl-rdkafka + (sbcl-package->cl-source-package sbcl-cl-rdkafka)) -(define-public ecl-charje.documentation - (sbcl-package->ecl-package sbcl-charje.documentation)) +(define-public ecl-cl-rdkafka + (sbcl-package->ecl-package sbcl-cl-rdkafka)) -(define-public sbcl-staple - (let ((commit "0ee8e25fe6fe8fa83b2a6c93d4febd468c3eaa4e") +(define-public sbcl-cl-readline + (let ((commit "8438c9ebd92ccc95ebab9cc9cbe6c72d44fccc58") (revision "1")) (package - (name "sbcl-staple") - (version (git-version "2.0.0" revision commit)) + (name "sbcl-cl-readline") + (version (git-version "0.1.2" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/Shinmera/staple/") + (url "https://github.com/vindarel/cl-readline") (commit commit))) + (file-name (git-file-name "cl-readline" version)) (sha256 - (base32 "0qf0if7py3n4rszg25lcavpsqikfz6k5dvcmh5q67y8x5r12i5m7")) - (file-name (git-file-name "staple" version)))) + (base32 "14iskvqfw71ssaav483vmqw62lrpznysjs800gjjppxs785p1fa0")))) (build-system asdf-build-system/sbcl) - (arguments - '(#:asd-systems '("staple-package-recording" - "staple-code-parser" - "staple" - "staple-markdown" - "staple-markless" - "staple-restructured-text"))) (inputs - (list sbcl-3bmd - sbcl-babel - sbcl-cl-docutils - sbcl-cl-markless - sbcl-cl-ppcre - sbcl-clip - sbcl-concrete-syntax-tree - sbcl-definitions - sbcl-documentation-utils - sbcl-eclector - sbcl-language-codes - sbcl-pathname-utils)) - (synopsis "Generate documentation about Lisp projects through an HTML template") - (description "Staple is a documentation system. It provides you with a -way to generate standalone documentation accumulated from various sources such -as readmes, documentation files, and docstrings.") - (home-page "https://Shinmera.github.io/staple/") - (license license:zlib)))) + `(("alexandria" ,sbcl-alexandria) + ("cffi" ,sbcl-cffi) + ("readline" ,readline))) + (arguments + '(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'fix-paths + (lambda* (#:key inputs #:allow-other-keys) + (substitute* "cl-readline.lisp" + (("libreadline.so") + (string-append (assoc-ref inputs "readline") + "/lib/libreadline.so")))))))) + (home-page "https://github.com/vindarel/cl-readline") + (synopsis "Common Lisp bindings to the GNU Readline library") + (description + "The Readline library provides a set of functions for use by +applications that allow users to edit command lines as they are typed in. +Both Emacs and vi editing modes are available. The Readline library includes +additional functions to maintain a list of previously-entered command lines, to +recall and perhaps reedit those lines, and perform csh-like history expansion on +previous commands.") + (license license:gpl3+)))) -(define-public cl-staple - (sbcl-package->cl-source-package sbcl-staple)) +(define-public cl-readline + (sbcl-package->cl-source-package sbcl-cl-readline)) -(define-public ecl-staple - (sbcl-package->ecl-package sbcl-staple)) +(define-public ecl-cl-readline + (sbcl-package->ecl-package sbcl-cl-readline)) -(define-public sbcl-helambdap - (let ((commit "5bf65f57a36ee094cadb096caca6e90eb3ba46c4") +(define-public sbcl-cl-redis + (let ((commit "7d592417421cf7cd1cffa96043b457af0490df7d") (revision "0")) (package - (name "sbcl-helambdap") - (version (git-version "20220103" revision commit)) + (name "sbcl-cl-redis") + (version (git-version "2.3.8" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://git.code.sf.net/p/helambdap/code") + (url "https://github.com/vseloved/cl-redis") (commit commit))) - (file-name (git-file-name "cl-helambdap" version)) + (file-name (git-file-name "cl-redis" version)) (sha256 - (base32 "1kzapbf9l2bw8i9m9sxv0dfnkksrxq81d5hbn34pm25abk0i937j")))) + (base32 "0x5ahxb5cx37biyn3cjycshhm1rr9p5cf1a9l5hd1n1xjxm2f8vi")))) (build-system asdf-build-system/sbcl) + (arguments + '(#:phases + (modify-phases %standard-phases + (add-before 'check 'start-redis + (lambda _ + (system "redis-server --port 6379 &")))))) + (native-inputs + `(("bordeaux-threads" ,sbcl-bordeaux-threads) + ("flexi-streams" ,sbcl-flexi-streams) + ("redis" ,redis) + ("should-test" ,sbcl-should-test))) (inputs - (list sbcl-cl-fad - sbcl-clad - sbcl-split-sequence - sbcl-xhtmlambda)) - (synopsis "Common Lisp documentation system") - (description "HELambdap is a Common Lisp documentation system which -strives to be simple to use, yet easily customizable.") - (home-page "https://helambdap.sourceforge.net") + `(("babel" ,sbcl-babel) + ("cl-ppcre" ,sbcl-cl-ppcre) + ("flexi-streams" ,sbcl-flexi-streams) + ("rutils" ,sbcl-rutils) + ("usocket" ,sbcl-usocket))) + (home-page "https://github.com/vseloved/cl-redis") + (synopsis "Common Lisp client for Redis") + (description "This is a Common Lisp wrapper for interacting with the +Redis data structure store.") (license license:expat)))) -(define-public cl-helambdap - (sbcl-package->cl-source-package sbcl-helambdap)) +(define-public cl-redis + (sbcl-package->cl-source-package sbcl-cl-redis)) -(define-public sbcl-form-fiddle - (let ((commit "e0c23599dbb8cff3e83e012f3d86d0764188ad18") - (revision "0")) +(define-public ecl-cl-redis + (let ((pkg (sbcl-package->ecl-package sbcl-cl-redis))) (package - (name "sbcl-form-fiddle") - (version (git-version "1.1.0" revision commit)) + (inherit pkg) + (arguments + (substitute-keyword-arguments (package-arguments pkg) + ;; Tests are failing on ECL with: + ;; Test L-COMMANDS: An error occurred during initialization: + ;; Protocol not found: "tcp". + ((#:tests? _ #f) #f)))))) + +(define-public sbcl-cl-reexport + (let ((commit "03ad7a0e7307e510b3b25a622d3c5f8a077879b4") + (revision "2")) + (package + (name "sbcl-cl-reexport") + (build-system asdf-build-system/sbcl) + (version (git-version "0.1" revision commit)) + (home-page "https://github.com/takagi/cl-reexport") (source (origin (method git-fetch) - (uri - (git-reference - (url "https://github.com/Shinmera/form-fiddle") - (commit commit))) - (file-name (git-file-name name version)) + (uri (git-reference + (url "https://github.com/takagi/cl-reexport") + (commit commit))) + (file-name (git-file-name "cl-reexport" version)) (sha256 (base32 - "041iznc9mpfyrl0sv5893ys9pbb2pvbn9g3clarqi7gsfj483jln")))) - (build-system asdf-build-system/sbcl) + "02la6z3ickhmh2m87ymm2ijh9nkn7l6slskj99l8a1rhps394qqc")))) (inputs - (list sbcl-documentation-utils)) - (synopsis "Utilities to destructure Common Lisp lambda forms") + (list sbcl-alexandria)) + (native-inputs + (list sbcl-prove)) + (synopsis "Reexport external symbols in other Common Lisp packages") (description - "Often times we need to destructure a form definition in a Common Lisp -macro. This library provides a set of simple utilities to help with that.") - (home-page "https://shinmera.github.io/form-fiddle/") - (license license:zlib)))) + "Cl-reexport makes a package reexport symbols which are external +symbols in other Common Lisp packages. This functionality is intended to be +used with (virtual) hierarchical packages.") + (license license:llgpl)))) -(define-public cl-form-fiddle - (sbcl-package->cl-source-package sbcl-form-fiddle)) +(define-public cl-reexport + (sbcl-package->cl-source-package sbcl-cl-reexport)) -(define-public ecl-form-fiddle - (sbcl-package->ecl-package sbcl-form-fiddle)) +(define-public ecl-cl-reexport + (sbcl-package->ecl-package sbcl-cl-reexport)) -(define-public sbcl-array-utils - (let ((commit "29da8fccf6093fe8f8c7b2daef7de1a428ef1834") - (revision "0")) +(define-public sbcl-cl-rmath + (let ((commit "f6add1edda31547691d08e36ccf6c17305161aca") + (revision "1")) (package - (name "sbcl-array-utils") - (version (git-version "1.2.0" revision commit)) + (name "sbcl-cl-rmath") + (version (git-version "0.0.1" revision commit)) (source (origin (method git-fetch) - (uri - (git-reference - (url "https://github.com/Shinmera/array-utils") - (commit commit))) - (file-name (git-file-name "cl-array-utils" version)) + (uri (git-reference + (url "https://github.com/tpapp/cl-rmath") + (commit commit))) + (file-name (git-file-name "cl-rmath" version)) (sha256 - (base32 "1d66s2inb9hpw27hdb20x27dychmpn1mn35v0mlsib848qdz87az")))) + (base32 "1ld8vbpy10paymx2hn0mcgd21i7cjhdrayln1jx0kayqxm12mmk4")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-parachute)) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'fix-paths + (lambda* (#:key inputs #:allow-other-keys) + (substitute* "cl-rmath.lisp" + (("\\(cffi:define-foreign-library librmath" all) + (string-append all "\n" + " (:unix \"" + (assoc-ref inputs "librmath") + "/lib/libRmath.so\")")))))))) (inputs - (list sbcl-documentation-utils)) - (synopsis "Tiny collection of array and vector utilities for Common Lisp") + `(("cffi" ,sbcl-cffi) + ("librmath" ,rmath-standalone))) + (home-page "https://github.com/tpapp/cl-rmath") + (synopsis "Common Lisp wrapper for libRmath") (description - "A miniature toolkit that contains some useful shifting/popping/pushing -functions for arrays and vectors. Originally from Plump.") - (home-page "https://shinmera.github.io/array-utils/") - (license license:zlib)))) + "@code{cl-rmath} is a simple, autogenerated foreign interface for the +standalone R API @code{libRmath}. There has been no effort to provide a +high-level interface for the original library, instead, this library is meant +to serve as a building block for such an interface.") + (license license:boost1.0)))) -(define-public cl-array-utils - (sbcl-package->cl-source-package sbcl-array-utils)) +(define-public cl-rmath + (sbcl-package->cl-source-package sbcl-cl-rmath)) -(define-public ecl-array-utils - (sbcl-package->ecl-package sbcl-array-utils)) +(define-public ecl-cl-rmath + (sbcl-package->ecl-package sbcl-cl-rmath)) -(define-public sbcl-lass - (let ((commit "1f2418dbf2d8d6f5892171057616b2ca9d6e5008") +(define-public sbcl-cl-slice + (let ((commit "c531683f287216aebbb0affbe090611fa1b5d697") (revision "1")) (package - (name "sbcl-lass") - (version (git-version "0.6.0" revision commit)) + (name "sbcl-cl-slice") + (version (git-version "0.1.0" revision commit)) (source (origin (method git-fetch) - (uri - (git-reference - (url "https://github.com/Shinmera/LASS") - (commit commit))) - (file-name (git-file-name "cl-lass" version)) + (uri (git-reference + (url "https://github.com/tpapp/cl-slice") + (commit commit))) + (file-name (git-file-name "cl-slice" version)) (sha256 - (base32 "1wax2kykc9ff0sk2linp9v8fcsm5ay6idpq365vivady9fh504r5")))) + (base32 "1ybznf4y5lda6bn163jcvj281qzhm24dfcwhbgxmm5n6f27gdccl")))) (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-clunit)) (inputs - (list sbcl-cl-base64 sbcl-trivial-indent sbcl-trivial-mimes)) - (synopsis "LASS (Lisp Augmented Style Sheets) compiles Lisp to CSS") + (list sbcl-alexandria sbcl-anaphora sbcl-let-plus)) + (home-page "https://github.com/tpapp/cl-slice") + (synopsis "Array slices for Common Lisp") (description - "With lispy syntax, shortcuts, and improvements, LASS aims to help you -out in writing CSS quick and easy. LASS was largely inspired by SASS. LASS -supports two modes, one being directly in your lisp code, the other in pure -LASS files.") - (home-page "https://shinmera.github.io/LASS/") - (license license:zlib)))) + "This package provides a DSL for array slices in Common Lisp.") + (license license:expat)))) -(define-public cl-lass - (sbcl-package->cl-source-package sbcl-lass)) +(define-public cl-slice + (sbcl-package->cl-source-package sbcl-cl-slice)) -(define-public ecl-lass - (sbcl-package->ecl-package sbcl-lass)) +(define-public ecl-cl-slice + (sbcl-package->ecl-package sbcl-cl-slice)) -(define-public sbcl-xhtmlambda - (let ((commit "c86376bccebf77ca428e8033df2ba7d8450ea1e8") - (revision "0")) +(define-public sbcl-cl-slug + (let ((commit "ffb229d10f0d3f7f54e706791725225e200bf749") + (revision "1")) (package - (name "sbcl-xhtmlambda") - (version - ;; The source repository doesn't provide any version nor revision, but - ;; a timestamp - (git-version "2022-01-21" revision commit)) + (name "sbcl-cl-slug") + (version (git-version "0.4.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://gitlab.common-lisp.net/xhtmlambda/XHTMLambda") + (url "https://github.com/EuAndreh/cl-slug") (commit commit))) - (file-name (git-file-name "cl-xhtmlambda" version)) + (file-name (git-file-name "cl-slug" version)) (sha256 - (base32 "0narbzz06ry1wn048avm1fwihvnjvvc4wfcv5hmdazkilpvnqz2y")))) + (base32 "1asdq6xllmsvfw5fky9wblqcx9isac9jrrlkfl7vyxcq1wxrnflx")))) (build-system asdf-build-system/sbcl) - (inputs (list sbcl-cl-unicode)) - (synopsis "(X)HTML library for Common Lisp") + (native-inputs + (list sbcl-prove)) + (inputs + `(("ppcre" ,sbcl-cl-ppcre))) + (home-page "https://github.com/EuAndreh/cl-slug") + (synopsis "Multi-language slug formatter") (description - "(X)HTMLambda is yet another (X)HTML library which -emphasizes programmability and user-friendliness. Each (X)HTML element is a -structured object and pretty-printing of (X)HTML trees is well defined to -provide properly indented human-readable output even for complex recursive -arrangements.") - (home-page "https://xhtmlambda.common-lisp.dev/") - (license license:expat)))) + "This is a small Common Lisp library to make slugs, mainly for URIs, +from English and beyond.") + (license license:llgpl)))) -(define-public cl-xhtmlambda - (sbcl-package->cl-source-package sbcl-xhtmlambda)) +(define-public cl-slug + (sbcl-package->cl-source-package sbcl-cl-slug)) -(define-public sbcl-clad - (let ((commit "1ff6f417d4ee3836d1edd96923d4b03f3cafa849") +(define-public ecl-cl-slug + (sbcl-package->ecl-package sbcl-cl-slug)) + +(define-public sbcl-cl-smtp + (let ((commit "ed47d326fad867ee11323fa3a0f307b5d40e8f2b") (revision "0")) (package - (name "sbcl-clad") - (version - ;; There's no version, but there's a timestamp - (git-version "2023-01-21" revision commit)) + (name "sbcl-cl-smtp") + (version (git-version "20191031.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://gitlab.common-lisp.net/mantoniotti/CLAD") + (url "https://gitlab.common-lisp.net/cl-smtp/cl-smtp") (commit commit))) - (file-name (git-file-name "cl-clad" version)) + (file-name (git-file-name "cl-smtp" version)) (sha256 - (base32 "184mhdq7pxd6hd4rzv8z4lfbwnkyhgm5bdn3xsqaav2j0d1dqm6i")) - (modules '((guix build utils))) - (snippet - ;; Delete compiled ABCL files. - '(begin - (delete-file "clad-package.abcl") - (delete-file "clad.abcl"))))) + (base32 "0vjjfapcrdc5671jz2d24h8zvpz7skq1x6pi9fvw6ls5sgms6fr0")))) (build-system asdf-build-system/sbcl) - (synopsis "Library providing standard locations on the file system") - (description - "The Common Lisp Application Directories (CLAD) library is -a simple API collection that provides access to a set of @emph{standard} -Common Lisp folders on a per-application or per-library basis.") - (home-page "https://gitlab.common-lisp.net/mantoniotti/CLAD") - (license license:expat)))) ;the mit-modern-variant is used + (inputs + (list sbcl-cl+ssl + sbcl-cl-base64 + sbcl-flexi-streams + sbcl-trivial-gray-streams + sbcl-usocket)) + (home-page "https://gitlab.common-lisp.net/cl-smtp/cl-smtp") + (synopsis "Simple Common Lisp SMTP client") + (description "This package provides a client for SMTP.") + (license license:llgpl)))) -(define-public cl-clad - (sbcl-package->cl-source-package sbcl-clad)) +(define-public cl-smtp + (sbcl-package->cl-source-package sbcl-cl-smtp)) -(define-public sbcl-plump - (let ((commit "0c3e0b57b43b6e0c5794b6a902f1cf5bee2a2927") - (revision "3")) +(define-public ecl-cl-smtp + (sbcl-package->ecl-package sbcl-cl-smtp)) + +(define-public sbcl-cl-spark + (let ((commit "4e34bcebdcf8e45265986eb43ad4ad03bb41a581") + (revision "1")) (package - (name "sbcl-plump") - (version (git-version "2.0.0" revision commit)) + (name "sbcl-cl-spark") + (version (git-version "0.1.13" revision commit)) (source (origin (method git-fetch) - (uri - (git-reference - (url "https://github.com/Shinmera/plump") - (commit commit))) - (file-name (git-file-name "cl-plump" version)) + (uri (git-reference + (url "https://github.com/tkych/cl-spark") + (commit commit))) + (file-name (git-file-name "cl-spark" version)) (sha256 - (base32 "1fyb66pqvr1iy31ah9638ihs8cax17zkxk0zq14jy7x5l9rq1qlf")))) + (base32 "0my1fsgi2rjaqkpk934f2bjy63pmnj7faza3fzvnk6k3l66y19nk")))) (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-array-utils sbcl-documentation-utils)) - (synopsis "Lenient XML / XHTML / HTML parser for Common Lisp") - (description - "Plump is a parser for HTML/XML-like documents, focusing on being -lenient towards invalid markup. It can handle things like invalid attributes, -bad closing tag order, unencoded entities, inexistent tag types, self-closing -tags and so on. It parses documents to a class representation and offers a -small set of DOM functions to manipulate it. It can be extended to parse to -your own classes.") - (home-page "https://shinmera.github.io/plump/") - (license license:zlib)))) + (native-inputs + (list sbcl-fiveam)) + (synopsis "Common Lisp library to make histograms") + (description "This is a Common Lisp library to make histograms using +UTF-8 block characters.") + (home-page "https://github.com/tkych/cl-spark") + (license license:expat)))) -(define-public cl-plump - (sbcl-package->cl-source-package sbcl-plump)) +(define-public cl-spark + (sbcl-package->cl-source-package sbcl-cl-spark)) -(define-public ecl-plump - (sbcl-package->ecl-package sbcl-plump)) +(define-public ecl-cl-spark + (sbcl-package->ecl-package sbcl-cl-spark)) -(define-public sbcl-plump-sexp - (let ((commit "bbcf75e9ecda8fe7603098ab8c15828407bb4f08") - (revision "0")) +(define-public sbcl-cl-speedy-queue + (let ((commit "0425c7c62ad3b898a5ec58cd1b3e74f7d91eec4b") + (revision "1")) (package - (name "sbcl-plump-sexp") - (version (git-version "0.1.0" revision commit)) + (name "sbcl-cl-speedy-queue") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) - (uri - (git-reference - (url "https://github.com/Shinmera/plump-sexp") - (commit commit))) - (file-name (git-file-name "cl-plump-sexp" version)) + (uri (git-reference + (url "https://github.com/zkat/cl-speedy-queue") + (commit commit))) + (file-name (git-file-name "cl-speedy-queue" version)) (sha256 - (base32 - "0zm9h0assjb8766z2v6l1k1s60y90y6f8smrl1dczwqlvc8xyln5")))) + (base32 "0czhnvxn9lvbjz9h1lb7y18nqrsq3drq5icd3lqdaa07362alriq")))) (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-plump)) - (synopsis "Convert S-expressions into a Plump DOM and back") + (home-page "https://github.com/zkat/cl-speedy-queue") + (synopsis "Lightweight optimized queue for Common Lisp") (description - "The Plump-SEXP library is a backend for Plump which can convert -between S-expressions and the Plump DOM.") - (home-page "https://github.com/Shinmera/plump-sexp") - (license license:zlib)))) + "This is a lightweight, non-consing, optimized queue implementation for +Common Lisp.") + (license license:expat)))) -(define-public cl-plump-sexp - (sbcl-package->cl-source-package sbcl-plump-sexp)) +(define-public cl-speedy-queue + (sbcl-package->cl-source-package sbcl-cl-speedy-queue)) -(define-public ecl-plump-sexp - (sbcl-package->ecl-package sbcl-plump-sexp)) +(define-public ecl-cl-speedy-queue + (sbcl-package->ecl-package sbcl-cl-speedy-queue)) -;;; Split the antik package in two to work around the circular dependency -;;; between antik/antik and antik/gsll. -(define-public sbcl-antik-base - (let ((commit "e4711a69b3d6bf37b5727af05c3cfd03e8428ba3") - (revision "1")) +(define-public sbcl-cl-sqlite + (package + (name "sbcl-cl-sqlite") + (version "0.2.1") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/dmitryvk/cl-sqlite") + (commit version))) + (file-name (git-file-name "cl-sqlite" version)) + (sha256 + (base32 + "08iv7b4m0hh7qx2cvq4f510nrgdld0vicnvmqsh9w0fgrcgmyg4k")))) + (build-system asdf-build-system/sbcl) + (inputs + `(("iterate" ,sbcl-iterate) + ("cffi" ,sbcl-cffi) + ("sqlite" ,sqlite))) + (native-inputs + `(("fiveam" ,sbcl-fiveam) + ("bordeaux-threads" ,sbcl-bordeaux-threads))) + (arguments + `(#:asd-systems '("sqlite") + #:phases + (modify-phases %standard-phases + (add-after 'unpack 'fix-paths + (lambda* (#:key inputs #:allow-other-keys) + (substitute* "sqlite-ffi.lisp" + (("libsqlite3" all) (string-append + (assoc-ref inputs "sqlite")"/lib/" all)))))))) + (home-page "https://common-lisp.net/project/cl-sqlite/") + (synopsis "Common Lisp binding for SQLite") + (description + "The @command{cl-sqlite} package is an interface to the SQLite embedded +relational database engine.") + (license license:public-domain))) + +(define-public cl-sqlite + (sbcl-package->cl-source-package sbcl-cl-sqlite)) + +(define-public ecl-cl-sqlite + (sbcl-package->ecl-package sbcl-cl-sqlite)) + +(define-public sbcl-cl+ssl + (let ((commit "17d5cdd65405f1d26e26f3e875e70027d0c8eedb") + (revision "6")) (package - (name "sbcl-antik-base") + (name "sbcl-cl+ssl") (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://gitlab.common-lisp.net/antik/antik.git") + (url "https://github.com/cl-plus-ssl/cl-plus-ssl") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl+ssl" version)) (sha256 - (base32 - "047ga2c38par2xbgg4qx6hwv06qhf1c1f67as8xvir6s80lip1km")))) + (base32 "0v0kx2m5355jkdshmj0z923c5rlvdl2n11rb3hjbv3kssdfsbs0s")))) (build-system asdf-build-system/sbcl) - (inputs - `(("alexandria" ,sbcl-alexandria) - ("cffi" ,sbcl-cffi) - ("cl-ppcre" ,sbcl-cl-ppcre) - ("drakma" ,sbcl-drakma) - ("fare-utils" ,sbcl-fare-utils) - ("iterate" ,sbcl-iterate) - ("metabang-bind" ,sbcl-metabang-bind) - ("named-readtables" ,sbcl-named-readtables) - ("split-sequence" ,sbcl-split-sequence) - ("static-vectors" ,sbcl-static-vectors) - ("trivial-garbage" ,sbcl-trivial-garbage) - ("trivial-utf-8" ,sbcl-trivial-utf-8))) - (native-inputs - (list sbcl-lisp-unit)) (arguments - '(#:asd-systems '("antik-base" - "foreign-array") - #:phases + '(#:phases (modify-phases %standard-phases - (add-after 'unpack 'fix-build + (add-after 'unpack 'fix-paths + (lambda* (#:key inputs #:allow-other-keys) + (substitute* "src/reload.lisp" + (("libssl.so" all) + (string-append + (assoc-ref inputs "openssl") "/lib/" all)) + (("libcrypto.so" all) + (string-append + (assoc-ref inputs "openssl") "/lib/" all))))) + (add-after 'fix-paths 'fix-tests (lambda _ - (for-each delete-file - '("antik.asd" - "physical-dimension.asd" - "science-data.asd")) - #t))))) - (synopsis "Scientific and engineering computation in Common Lisp") + ;; Disable coverall support in tests because of a circular + ;; dependency: cl+ssl -> cl-coverall -> dexador + ;; -> clack -> hunchentoot -> cl+ssl + (substitute* "cl+ssl.test.asd" + (("\\(:feature \\(:or :sbcl :ccl\\) :cl-coveralls\\)") + ""))))))) + (native-inputs + (list ;sbcl-cl-coveralls + sbcl-fiveam + sbcl-trivial-sockets)) + (inputs + (list openssl + sbcl-alexandria + sbcl-bordeaux-threads + sbcl-cffi + sbcl-flexi-streams + sbcl-trivial-features + sbcl-trivial-garbage + sbcl-trivial-gray-streams + sbcl-usocket)) + (home-page "https://common-lisp.net/project/cl-plus-ssl/") + (synopsis "Common Lisp bindings to OpenSSL") (description - "Antik provides a foundation for scientific and engineering -computation in Common Lisp. It is designed not only to facilitate -numerical computations, but to permit the use of numerical computation -libraries and the interchange of data and procedures, whether -foreign (non-Lisp) or Lisp libraries. It is named after the -Antikythera mechanism, one of the oldest examples of a scientific -computer known.") - (home-page "https://common-lisp.net/project/antik/") - (license license:gpl3)))) + "This library is a fork of SSL-CMUCL. The original SSL-CMUCL source +code was written by Eric Marsden and includes contributions by Jochen Schmidt. +Development into CL+SSL was done by David Lichteblau.") + (license license:expat)))) -(define-public cl-antik-base - (sbcl-package->cl-source-package sbcl-antik-base)) +(define-public cl-cl+ssl + (sbcl-package->cl-source-package sbcl-cl+ssl)) -(define-public ecl-antik-base - (let ((pkg (sbcl-package->ecl-package sbcl-antik-base))) +(define-public ecl-cl+ssl + ;; The trivial-sockets system used for the tests doesn't support ECL, so we + ;; remove it from native-inputs and disable the tests. + (let ((pkg (sbcl-package->ecl-package sbcl-cl+ssl))) (package (inherit pkg) + (native-inputs + (modify-inputs (package-native-inputs pkg) + (delete "sbcl-trivial-sockets"))) (arguments (substitute-keyword-arguments (package-arguments pkg) - ((#:phases phases) - `(modify-phases ,phases - (add-after 'unpack 'fix-readtable - (lambda _ - (substitute* "input-output/readtable.lisp" - (("#-ccl") - "#-(or ccl ecl)")) - #t))))))))) + ((#:tests? _ #f) #f)))))) -(define-public sbcl-gsll - (let ((commit "1a8ada22f9cf5ed7372d352b2317f4ccdb6ab308") +(define-public sbcl-cl-steamworks + (let ((commit "9d6a4de653a8cc256ae35e0298912b518aa92ba3") (revision "1")) (package - (name "sbcl-gsll") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-cl-steamworks") + (version (git-version "1.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://gitlab.common-lisp.net/antik/gsll.git") + (url "https://github.com/Shinmera/cl-steamworks/") (commit commit))) - (file-name (git-file-name name version)) (sha256 - (base32 - "0z5nypfk26hxihb08p085644afawicrgb4xvadh3lmrn46qbjfn4")))) + (base32 "1fzj3rlqw1kwdlmh0ga0y71p2n1adflcamzx4yp9kga552c1db5j")) + (file-name (git-file-name "cl-steamworks" version)))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-lisp-unit)) (inputs - `(("alexandria" ,sbcl-alexandria) - ("antik-base" ,sbcl-antik-base) - ("cffi" ,sbcl-cffi) - ("gsl" ,gsl) - ("metabang-bind" ,sbcl-metabang-bind) - ("trivial-features" ,sbcl-trivial-features) - ("trivial-garbage" ,sbcl-trivial-garbage))) - (arguments - `(#:tests? #f - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-cffi-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "gsll.asd" - ((":depends-on \\(#:foreign-array") - ":depends-on (#:foreign-array #:cffi-libffi")) - (substitute* "init/init.lisp" - (("libgslcblas.so" all) - (string-append - (assoc-ref inputs "gsl") "/lib/" all))) - (substitute* "init/init.lisp" - (("libgsl.so" all) - (string-append - (assoc-ref inputs "gsl") "/lib/" all)))))))) - (synopsis "GNU Scientific Library for Lisp") - (description - "The GNU Scientific Library for Lisp (GSLL) allows the use of the -GNU Scientific Library (GSL) from Common Lisp. This library provides a -full range of common mathematical operations useful to scientific and -engineering applications. The design of the GSLL interface is such -that access to most of the GSL library is possible in a Lisp-natural -way; the intent is that the user not be hampered by the restrictions -of the C language in which GSL has been written. GSLL thus provides -interactive use of GSL for getting quick answers, even for someone not -intending to program in Lisp.") - (home-page "https://common-lisp.net/project/gsll/") - (license license:gpl3)))) - -(define-public cl-gsll - (sbcl-package->cl-source-package sbcl-gsll)) - -(define-public ecl-gsll - (sbcl-package->ecl-package sbcl-gsll)) + (list sbcl-alexandria + sbcl-babel + sbcl-cffi + sbcl-documentation-utils + sbcl-float-features + sbcl-trivial-features + sbcl-trivial-garbage + sbcl-trivial-gray-streams)) + (synopsis "Wrapper for the Valve SteamWorks API") + (description "This is a wrapper library to allow you to interface with +the Valve SteamWorks API.") + (home-page "https://shinmera.github.io/cl-steamworks/") + (license license:zlib)))) -(define-public sbcl-antik - (package - (inherit sbcl-antik-base) - (name "sbcl-antik") - (inputs - `(("antik-base" ,sbcl-antik-base) - ("gsll" ,sbcl-gsll))) - (arguments - '(#:asd-systems '("antik" - "science-data") - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-build - (lambda _ - (for-each delete-file - '("antik-base.asd" - "foreign-array.asd")) - #t))))))) +(define-public cl-steamworks + (sbcl-package->cl-source-package sbcl-cl-steamworks)) -(define-public cl-antik - (sbcl-package->cl-source-package sbcl-antik)) +(define-public ecl-cl-steamworks + (sbcl-package->ecl-package sbcl-cl-steamworks)) -(define-public sbcl-cl-interpol - (let ((commit "70a1137f41dd8889004dbab9536b1adeac2497aa") +(define-public sbcl-cl-store + (let ((commit "c787337a16ea8cf8a06227f35933a4ec774746b3") (revision "1")) (package - (name "sbcl-cl-interpol") - (version (git-version "0.2.7" revision commit)) + (name "sbcl-cl-store") + (version (git-version "0.8.11" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/edicl/cl-interpol") + (url "https://github.com/skypher/cl-store") (commit commit))) - (file-name (git-file-name "cl-interpol" version)) + (file-name (git-file-name name version)) (sha256 (base32 - "1kr00zf62m7la7rxa2m5w49r9cyzamc106hvjcc8ffmi7a4jw490")))) + "194srkg8nrym19c6i7zbnkzshc1qhqa82m53qnkirz9fw928bqxr")))) (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-cl-unicode sbcl-named-readtables)) (native-inputs - (list sbcl-flexi-streams)) - (synopsis "String interpolation for Common Lisp") + (list sbcl-rt)) + (synopsis "Common Lisp library to serialize data") (description - "CL-INTERPOL is a library for Common Lisp which modifies the -reader so that you can have interpolation within strings similar to -Perl or Unix Shell scripts. It also provides various ways to insert -arbitrary characters into literal strings even if your editor/IDE -doesn't support them.") - (home-page "https://edicl.github.io/cl-interpol/") - (license license:bsd-3)))) + "CL-STORE is a portable serialization package which should give you the +ability to store all Common Lisp data types into streams.") + (home-page "https://www.common-lisp.net/project/cl-store/") + (license license:expat)))) -(define-public cl-interpol - (sbcl-package->cl-source-package sbcl-cl-interpol)) +(define-public cl-store + (sbcl-package->cl-source-package sbcl-cl-store)) -(define-public ecl-cl-interpol - (sbcl-package->ecl-package sbcl-cl-interpol)) +(define-public ecl-cl-store + (sbcl-package->ecl-package sbcl-cl-store)) -(define-public sbcl-symbol-munger - (let ((commit "e96558e8315b8eef3822be713354787b2348b25e") - (revision "2")) +(define-public sbcl-cl-str + (package + (name "sbcl-cl-str") + (version "0.19") + (home-page "https://github.com/vindarel/cl-str") + (source (origin + (method git-fetch) + (uri (git-reference + (url home-page) + (commit version))) + (sha256 + (base32 "1jyza2jhn7w6fl4w87pv0m87z5ia48m6dqw12k0mdh7l3mgjq839")) + (file-name (git-file-name name version)))) + (build-system asdf-build-system/sbcl) + (inputs + `(("cl-ppcre" ,sbcl-cl-ppcre) + ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode) + ("cl-change-case" ,sbcl-cl-change-case))) + (native-inputs + (list sbcl-prove)) + (arguments + `(#:asd-systems '("str"))) + (synopsis "Modern, consistent and terse Common Lisp string manipulation library") + (description "A modern and consistent Common Lisp string manipulation +library that focuses on modernity, simplicity and discoverability: +@code{(str:trim s)} instead of @code{(string-trim '(#\\Space ...) s)}), or +@code{str:concat strings} instead of an unusual format construct; one +discoverable library instead of many; consistency and composability, where +@code{s} is always the last argument, which makes it easier to feed pipes and +arrows.") + (license license:expat))) + +(define-public cl-str + (sbcl-package->cl-source-package sbcl-cl-str)) + +(define-public ecl-cl-str + (sbcl-package->ecl-package sbcl-cl-str)) + +(define-public sbcl-cl-strftime + ;; No release. + (let ((commit "21cb57f2595faa26d687893963f24ec41822b63c")) (package - (name "sbcl-symbol-munger") - (version (git-version "0.0.1" revision commit)) + (name "sbcl-cl-strftime") + (version (git-version "0.0.0" "1" commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/AccelerationNet/symbol-munger") + (url "https://github.com/ruricolist/cl-strftime/") (commit commit))) - (file-name (git-file-name "cl-symbol-munger" version)) + (file-name (git-file-name name version)) (sha256 - (base32 - "16fshnxp9212503z1vjlmx5pafv14bzpihn486x1ljakqjigfnfz")))) + (base32 "00c8hq7vzgb89ab3q7mrp60x743kiqmsk1g51ynhxlqhph2bnslf")))) (build-system asdf-build-system/sbcl) (inputs - `(("alexandria" ,sbcl-alexandria) - ("iterate" ,sbcl-iterate))) - (arguments - ;; There is a cyclical dependency between symbol-munger and lisp-unit2. - ;; See https://github.com/AccelerationNet/symbol-munger/issues/4 - '(#:tests? #f)) - (synopsis - "Capitalization and spacing conversion functions for Common Lisp") + (list sbcl-alexandria sbcl-local-time sbcl-cl-ppcre sbcl-serapeum)) + (native-inputs + (list sbcl-fiveam sbcl-cffi)) + (home-page "https://github.com/ruricolist/cl-strftime") + (synopsis "Common Lisp compiler for the strftime language") (description - "This is a Common Lisp library to change the capitalization and spacing -of a string or a symbol. It can convert to and from Lisp, english, underscore -and camel-case rules.") - (home-page "https://github.com/AccelerationNet/symbol-munger") - ;; The package declares a BSD license, but all of the license - ;; text is MIT. - ;; See https://github.com/AccelerationNet/symbol-munger/issues/5 + "CL-STRFTIME is a Common Lisp compiler for the strftime “language.”") (license license:expat)))) -(define-public cl-symbol-munger - (sbcl-package->cl-source-package sbcl-symbol-munger)) +(define-public cl-strftime + (sbcl-package->cl-source-package sbcl-cl-strftime)) -(define-public ecl-symbol-munger - (sbcl-package->ecl-package sbcl-symbol-munger)) +(define-public ecl-cl-strftime + (sbcl-package->ecl-package sbcl-cl-strftime)) -(define-public sbcl-cl-csv - (let ((commit "68ecb5d816545677513d7f6308d9e5e8d2265651") - (revision "2")) +(define-public sbcl-cl-string-match + (let ((revision "1") + (changeset "5048480a61243e6f1b02884012c8f25cdbee6d97")) (package - (name "sbcl-cl-csv") - (version (git-version "1.0.6" revision commit)) + (name "sbcl-cl-string-match") + (version (git-version "0" revision changeset)) (source (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/AccelerationNet/cl-csv") - (commit commit))) - (file-name (git-file-name name version)) + (method hg-fetch) + (uri (hg-reference + (url "https://github.com/vityok/cl-string-match") + (changeset changeset))) (sha256 (base32 - "0gcmlbwx5m3kwgk12qi80w08ak8fgdnvyia429fz6gnxmhg0k54x")))) + "01wn5qx562w43ssy92xlfgv79w7p0nv0wbl76mpmba131n9ziq2y")) + (file-name (git-file-name "cl-string-match" version)))) (build-system asdf-build-system/sbcl) - (arguments - ;; See: https://github.com/AccelerationNet/cl-csv/pull/34 - `(#:tests? #f)) (inputs `(("alexandria" ,sbcl-alexandria) - ("cl-interpol" ,sbcl-cl-interpol) - ("iterate" ,sbcl-iterate))) + ("babel" ,sbcl-babel) + ("iterate" ,sbcl-iterate) + ("jpl-queues" ,sbcl-jpl-queues) + ("jpl-util" ,sbcl-jpl-util) + ("mgl-pax" ,sbcl-mgl-pax) + ("parse-float" ,sbcl-parse-float) + ("proc-parse" ,sbcl-proc-parse) + ("yacc" ,sbcl-cl-yacc))) + ;; TODO: Tests are not evaluated properly. (native-inputs - (list sbcl-lisp-unit2)) - (synopsis "Common lisp library for comma-separated values") + ;; For testing: + (list sbcl-lisp-unit)) + (arguments + `(#:tests? #f + #:phases + (modify-phases %standard-phases + (add-after 'unpack 'fix-dependency + (lambda _ + (substitute* "cl-string-match.asd" + ((":mgl-pax") + ":mgl-pax/document"))))))) + (synopsis "Set of utilities to manipulate strings in Common Lisp") (description - "This is a Common Lisp library providing functions to read/write CSV -from/to strings, streams and files.") - (home-page "https://github.com/AccelerationNet/cl-csv") + "@command{cl-strings} is a small, portable, dependency-free set of +utilities that make it even easier to manipulate text in Common Lisp. It has +100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.") + (home-page "https://github.com/vityok/cl-string-match") (license license:bsd-3)))) -(define-public cl-csv - (sbcl-package->cl-source-package sbcl-cl-csv)) +(define-public cl-string-match + (sbcl-package->cl-source-package sbcl-cl-string-match)) -(define-public ecl-cl-csv - (sbcl-package->ecl-package sbcl-cl-csv)) +(define-public ecl-cl-string-match + (sbcl-package->ecl-package sbcl-cl-string-match)) -(define-public sbcl-external-program - (let ((commit "5888b8f1fd3953feeeacecbba4384ddda584a749") - (revision "1")) +(define-public sbcl-cl-strings + (let ((revision "1") + (commit "93ec4177fc51f403a9f1ef0a8933f36d917f2140")) (package - (name "sbcl-external-program") - (version (git-version "0.0.6" revision commit)) + (name "sbcl-cl-strings") + (version (git-version "0.0.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/sellout/external-program") + (url "https://github.com/diogoalexandrefranco/cl-strings") (commit commit))) - (file-name (git-file-name name version)) (sha256 - (base32 - "0vww1x3yilb3bjwg6k184vaj4vxyxw4vralhnlm6lk4xac67kc9z")))) + (base32 "1j8hs54fn0wsf5zfzhhgiva47n9hsmfa74iinahz6nmcs8iy75aj")) + (file-name (git-file-name "cl-strings" version)))) (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-trivial-features)) - (native-inputs - (list sbcl-fiveam)) - (synopsis "Common Lisp library for running external programs") + (synopsis "Set of utilities to manipulate strings in Common Lisp") (description - "EXTERNAL-PROGRAM enables running programs outside the Lisp -process. It is an attempt to make the RUN-PROGRAM functionality in -implementations like SBCL and CCL as portable as possible without -sacrificing much in the way of power.") - (home-page "https://github.com/sellout/external-program") - (license license:llgpl)))) + "@command{cl-strings} is a small, portable, dependency-free set of +utilities that make it even easier to manipulate text in Common Lisp. It has +100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.") + (home-page "https://github.com/diogoalexandrefranco/cl-strings") + (license license:expat)))) -(define-public cl-external-program - (sbcl-package->cl-source-package sbcl-external-program)) +(define-public cl-strings + (sbcl-package->cl-source-package sbcl-cl-strings)) -(define-public ecl-external-program - (sbcl-package->ecl-package sbcl-external-program)) +(define-public ecl-cl-strings + (sbcl-package->ecl-package sbcl-cl-strings)) -(define-public sbcl-cl-ana - (let ((commit "848185eed1ed65bab3a124870c122f761ce0d87e") - (revision "2")) +(define-public sbcl-cl-svg + (let ((commit "1e988ebd2d6e2ee7be4744208828ef1b59e5dcdc") + (revision "1")) (package - (name "sbcl-cl-ana") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-cl-svg") + (version (git-version "0.0.3" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/ghollisjr/cl-ana") + (url "https://github.com/wmannis/cl-svg") (commit commit))) - (file-name (git-file-name "cl-ana" version)) + (file-name (git-file-name "cl-svg" version)) (sha256 - (base32 "026agqsxq3pg2k9jmy2wysil2z0yn5rykzzhr8rqxsspdwz51z1y")))) + (base32 "11rmzimy6j7ln7q5y1h2kw1225rsfb6fpn89qjcq7h5lc8fay0wz")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list openmpi ;; for hdf-cffi - pkg-config - sbcl-cl-fad)) - (inputs - (list gsl - hdf5-parallel-openmpi - libffi - sbcl-antik - sbcl-cffi - sbcl-cl-csv - sbcl-closer-mop - sbcl-external-program - sbcl-gsll - sbcl-iterate - sbcl-alexandria - sbcl-split-sequence)) - (propagated-inputs - (list gnuplot)) ;; for gnuplot-interface - (arguments - (list #:phases - #~(modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "hdf-cffi/src/library.lisp" - (("libhdf5.so") - (search-input-file inputs "/lib/libhdf5.so"))) - (substitute* (list "gsl-cffi/gsl-cffi.lisp" - "spline/spline.lisp") - (("libgsl.so") - (search-input-file inputs "/lib/libgsl.so"))))) - (add-after 'fix-paths 'fix-newer-hdf5-compatibility - (lambda _ - (substitute* (list "hdf-cffi/src/h5-grovel.lisp" - "hdf-cffi/src/h5a-grovel.lisp" - "hdf-cffi/src/h5d-grovel.lisp" - "hdf-cffi/src/h5f-grovel.lisp" - "hdf-cffi/src/h5g-grovel.lisp" - "hdf-cffi/src/h5i-grovel.lisp" - "hdf-cffi/src/h5l-grovel.lisp" - "hdf-cffi/src/h5o-grovel.lisp" - "hdf-cffi/src/h5p-grovel.lisp" - "hdf-cffi/src/h5pl-grovel.lisp" - "hdf-cffi/src/h5r-grovel.lisp" - "hdf-cffi/src/h5s-grovel.lisp" - "hdf-cffi/src/h5t-grovel.lisp" - "hdf-cffi/src/h5z-grovel.lisp") - (("_H5private_H") - "H5private_H"))))))) - (synopsis "Common Lisp data analysis library") + (home-page "https://github.com/wmannis/cl-svg") + (synopsis "Write SVG file format") (description - "CL-ANA is a data analysis library in Common Lisp providing tabular and -binned data analysis along with nonlinear least squares fitting and -visualization.") - (home-page "https://github.com/ghollisjr/cl-ana") - (license license:gpl3)))) + "This package provides the @code{CL-SVG} Common Lisp system to produce +Scalable Vector Graphics files.") + (license license:expat)))) -(define-public cl-ana - (sbcl-package->cl-source-package sbcl-cl-ana)) +(define-public cl-svg + (sbcl-package->cl-source-package sbcl-cl-svg)) -(define-public sbcl-eazy-gnuplot - (let ((commit "2eb900fe2557e6c066a9851c166e572c25bc0996") - (revision "0")) +(define-public ecl-cl-svg + (sbcl-package->ecl-package sbcl-cl-svg)) + +(define-public sbcl-cl-sxml + (let ((commit "e5542b1d9bd6cee03ae27547d00660ccfbb60109") + (revision "1")) (package - (name "sbcl-eazy-gnuplot") - (version (git-version "0.2.0" revision commit)) + (name "sbcl-cl-sxml") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/guicho271828/eazy-gnuplot") + (url "https://github.com/eadmund/cl-sxml") (commit commit))) - (file-name (git-file-name "cl-eazy-gnuplot" version)) + (file-name (git-file-name "cl-sxml" version)) (sha256 - (base32 "0mpkx1z52riahydzvqv7kk15p0pv2k7k5a7j65fg571kcxmssx8s")) - (patches (search-patches "sbcl-eazy-gnuplot-skip-path-check.patch")))) + (base32 "1105s9whidq1lf0lli2wdhcfcs5gwzxa0h1x3izx4mp2p7psvciz")))) (build-system asdf-build-system/sbcl) + (inputs (list sbcl-cxml)) (native-inputs - (list sbcl-fiveam)) - (inputs - (list gnuplot - sbcl-alexandria - sbcl-iterate - sbcl-trivia)) - (arguments - `(#:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda _ - (substitute* "src/package.lisp" - (("\"gnuplot\"") - (string-append "\"" (which "gnuplot") "\"")))))))) - (home-page "https://github.com/guicho271828/eazy-gnuplot") - (synopsis "Common Lisp interface to gnuplot") + (list sbcl-fiveam + sbcl-flexi-streams)) + (home-page "https://github.com/eadmund/cl-sxml") + (synopsis "SXML parsing for Common Lisp") (description - "Eazy-Gnuplot is a Common Lisp interface to gnuplot which eschews CFFI, -CLOS and structures. It communicates with @command{gnuplot} via -@code{*standard-output*}, and users can plot data by printing to that -stream.") - (license license:llgpl)))) + "@code{CL-SXML} implements Oleg Kiselyov’s SXML, an S-expression-based +rendering of the XML Infoset.") + (license license:gpl3+)))) -(define-public cl-eazy-gnuplot - (sbcl-package->cl-source-package sbcl-eazy-gnuplot)) +(define-public cl-sxml + (sbcl-package->cl-source-package sbcl-cl-sxml)) -(define-public ecl-eazy-gnuplot - (sbcl-package->ecl-package sbcl-eazy-gnuplot)) +(define-public ecl-cl-sxml + (sbcl-package->ecl-package sbcl-cl-sxml)) -(define-public sbcl-archive - (let ((commit "631271c091ed02994bec3980cb288a2cf32c7cdc") - (revision "1")) - (package - (name "sbcl-archive") - (version (git-version "0.9" revision commit)) - (source (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/sharplispers/archive") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "0pvsc9fmybx7rxd0kmzq4shi6hszdpwdc1sfy7jwyfxf8n3hnv4p")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-cl-fad sbcl-trivial-gray-streams)) - (synopsis "Common Lisp library for tar and cpio archives") - (description - "This is a Common Lisp library to read and write disk-based file -archives such as those generated by the tar and cpio programs on Unix.") - (home-page "https://github.com/sharplispers/archive") - (license license:bsd-3)))) +(define-public sbcl-cl-syntax + (package + (name "sbcl-cl-syntax") + (version "0.0.3") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/m2ym/cl-syntax") + (commit "03f0c329bbd55b8622c37161e6278366525e2ccc"))) + (file-name (git-file-name "cl-syntax" version)) + (sha256 + (base32 "17ran8xp77asagl31xv8w819wafh6whwfc9p6dgx22ca537gyl4y")))) + (build-system asdf-build-system/sbcl) + (inputs + `(("cl-annot" ,sbcl-cl-annot) + ("cl-interpol" ,sbcl-cl-interpol) + ("named-readtables" ,sbcl-named-readtables) + ("trivial-types" ,sbcl-trivial-types))) + (arguments + '(#:asd-systems '("cl-syntax" + "cl-syntax-annot" + "cl-syntax-interpol"))) + (home-page "https://github.com/m2ym/cl-syntax") + (synopsis "Reader Syntax Coventions for Common Lisp and SLIME") + (description + "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp and SLIME.") + (license license:llgpl))) -(define-public cl-archive - (sbcl-package->cl-source-package sbcl-archive)) +(define-public cl-syntax + (sbcl-package->cl-source-package sbcl-cl-syntax)) -(define-public ecl-archive - (sbcl-package->ecl-package sbcl-archive)) +(define-public ecl-cl-syntax + (sbcl-package->ecl-package sbcl-cl-syntax)) -(define-public sbcl-tar-file - (let ((commit "0c10bc82f14702c97a26dc25ce075b5d3a2347d1") +(define-public sbcl-cl-syslog + (let ((commit "d5d46f777f0735938e6f650cf17d814b88b70305") (revision "0")) (package - (name "sbcl-tar-file") - (version (git-version "0.2.1" revision commit)) + (name "sbcl-cl-syslog") + (version (git-version "0.2.4" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://gitlab.common-lisp.net/cl-tar/cl-tar-file") + (url "https://github.com/mmaul/cl-syslog") (commit commit))) - (file-name (git-file-name "cl-tar-file" version)) + (file-name (git-file-name "cl-syslog" version)) (sha256 - (base32 "0i8j05fkgdqy4c4pqj0c68sh4s3klpx9kc5wp73qwzrl3xqd2svy")))) + (base32 "1qcz55jiqwk91b01hsahxnha884f6zf2883j2m51sqph0mvj69mh")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-parachute)) (inputs - (list sbcl-40ants-doc - sbcl-alexandria + (list sbcl-alexandria sbcl-babel - sbcl-chipz - sbcl-flexi-streams - sbcl-salza2 - sbcl-trivial-gray-streams)) - (home-page "https://gitlab.common-lisp.net/cl-tar/cl-tar-file") - (synopsis "Read and write physical entries to and from tar files") - (description - "@code{cl-tar-file} is a Common Lisp library that allows reading from -and writing to various tar archive formats. Currently supported are the POSIX -ustar, PAX (ustar with a few new entry types), GNU, and v7 (very old) formats. - -This library is rather low level and is focused exclusively on reading and -writing physical tar file entries using streams. Therefore, it contains no -functionality for automatically building archives from a set of files on the -filesystem or writing the contents of a file to the filesystem. Additionally, -there are no smarts that read multiple physical entries and combine them into -a single logical entry (e.g., with PAX extended headers or GNU long link/path -name support). For a higher-level library that reads and writes logical -entries, and also includes filesystem integration, see @code{cl-tar}.") + sbcl-cffi + sbcl-global-vars + sbcl-local-time + sbcl-split-sequence + sbcl-usocket)) + (arguments + (list #:tests? #f)) + (synopsis "Common Lisp interface to local and remote Syslog facilities") + (description "@code{cl-syslog} is a Common Lisp library that provides +access to the syslog logging facility.") + (home-page "https://cl-syslog.common-lisp.dev/") (license license:bsd-3)))) -(define-public cl-tar-file - (sbcl-package->cl-source-package sbcl-tar-file)) +(define-public cl-syslog + (sbcl-package->cl-source-package sbcl-cl-syslog)) -(define-public ecl-tar-file - (sbcl-package->ecl-package sbcl-tar-file)) +(define-public ecl-cl-syslog + (sbcl-package->ecl-package sbcl-cl-syslog)) -(define-public sbcl-tar - (let ((commit "7c6e07a10c93d9e311f087b5f6328cddd481669a") +(define-public sbcl-cl-template + (let ((commit "46193a9a389bb950530e579eae7e6e5a18184832") (revision "0")) (package - (name "sbcl-tar") - (version (git-version "0.2.3" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://gitlab.common-lisp.net/cl-tar/cl-tar") - (commit commit))) - (file-name (git-file-name "cl-tar" version)) - (sha256 - (base32 "0wp23cs3i6a89dibifiz6559la5nk58d1n17xvbxq4nrl8cqsllf")))) - (build-system asdf-build-system/sbcl) - ;; TODO: Build the tar program with 'build-program' when the - ;; 'asdf-release-ops' library is added to Guix. - (arguments - '(#:asd-systems '("tar" - "tar/common-extract" - "tar/create" - "tar/docs" - "tar/extract" - "tar/simple-extract"))) - (native-inputs - (list sbcl-parachute)) - (inputs - (list sbcl-40ants-doc - sbcl-alexandria - sbcl-babel - sbcl-local-time - sbcl-osicat - sbcl-split-sequence - sbcl-tar-file)) - (home-page "https://gitlab.common-lisp.net/cl-tar/cl-tar") - (synopsis "High-level interface for tar files") - (description - "@code{cl-tar} is a Common Lisp library providing a high-level interface -for interacting with tar archives.") - (license license:expat)))) + (name "sbcl-cl-template") + (version (git-version "0.0.1" revision commit)) + (home-page "https://github.com/alpha123/cl-template") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/alpha123/cl-template") + (commit commit))) + (file-name (git-file-name "cl-template" version)) + (sha256 + (base32 "1rhg023a2nxsk5x6abd6i0a8sh36aj0bgsh80w60m3b7xlsva2x2")))) + (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-fiveam)) + (synopsis "Template engine for Common Lisp") + (description "@code{cl-template} is a template engine for Common Lisp, +taking inspiration from Ruby's ERb module.") + (license license:expat)))) -(define-public cl-tar - (sbcl-package->cl-source-package sbcl-tar)) +(define-public cl-template + (sbcl-package->cl-source-package sbcl-cl-template)) -(define-public ecl-tar - (sbcl-package->ecl-package sbcl-tar)) +(define-public ecl-cl-template + (sbcl-package->ecl-package sbcl-cl-template)) -(define-public sbcl-misc-extensions - (let ((commit "101c05112bf2f1e1bbf527396822d2f50ca6327a") - (revision "1")) +(define-public sbcl-cl-tga + (let ((commit "4dc2f7b8a259b9360862306640a07a23d4afaacc") + (revision "0")) (package - (name "sbcl-misc-extensions") - (version (git-version "3.3" revision commit)) + (name "sbcl-cl-tga") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://gitlab.common-lisp.net/misc-extensions/devel.git") + (url "https://github.com/fisxoj/cl-tga") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 - "0gz5f4p70qzilnxsnf5lih2n9m4wjcw8hlw4w8mpn9jyhyppyyv0")))) + (base32 "03k3npmn0xd3fd2m7vwxph82av2xrfb150imqrinlzqmzvz1v1br")))) (build-system asdf-build-system/sbcl) - (synopsis "Collection of small macros and extensions for Common Lisp") + (home-page "https://github.com/fisxoj/cl-tga") + (synopsis "TGA file loader for Common Lisp") (description - "This project is intended as a catchall for small, general-purpose -extensions to Common Lisp. It contains: - -@itemize -@item @code{new-let}, a macro that combines and generalizes @code{let}, -@code{let*} and @code{multiple-value-bind}, -@item @code{gmap}, an iteration macro that generalizes @code{map}. -@end itemize\n") - (home-page "https://common-lisp.net/project/misc-extensions/") - (license license:public-domain)))) - -(define-public cl-misc-extensions - (sbcl-package->cl-source-package sbcl-misc-extensions)) - -(define-public ecl-misc-extensions - (sbcl-package->ecl-package sbcl-misc-extensions)) - -(define-public sbcl-mt19937 - (package - (name "sbcl-mt19937") - (version "1.1") - (source - (origin - (method url-fetch) - (uri (string-append "https://common-lisp.net/project/asdf-packaging/" - "mt19937-latest.tar.gz")) - (sha256 - (base32 - "1iw636b0iw5ygkv02y8i41lh7xj0acglv0hg5agryn0zzi2nf1xv")))) - (build-system asdf-build-system/sbcl) - (synopsis "Mersenne Twister pseudo-random number generator") - (description - "MT19937 is a portable Mersenne Twister pseudo-random number generator -for Common Lisp.") - (home-page "https://www.cliki.net/mt19937") - (license license:public-domain))) + "Cl-tga was written to facilitate loading @emph{.tga} files into OpenGL +programs. It's a very simple library, and, at the moment, only supports +non-RLE encoded forms of the files.") + (license license:expat)))) -(define-public cl-mt19937 - (sbcl-package->cl-source-package sbcl-mt19937)) +(define-public cl-tga + (sbcl-package->cl-source-package sbcl-cl-tga)) -(define-public ecl-mt19937 - (sbcl-package->ecl-package sbcl-mt19937)) +(define-public ecl-cl-tga + (sbcl-package->ecl-package sbcl-cl-tga)) -(define-public sbcl-fset - (let ((commit "6d2f9ded8934d2b42f2571a0ba5bda091037d852") - (revision "1")) +(define-public sbcl-cl-tld + ;; No release. + (let ((commit "f5014da8d831fa9481d4181d4450f10a52850c75")) (package - (name "sbcl-fset") - (version (git-version "1.3.2" revision commit)) + (name "sbcl-cl-tld") + (version (git-version "0.1" "2" commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/slburson/fset") + (url "https://github.com/lu4nx/cl-tld") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 - "127acblwrbqicx47h6sgvknz1cqyfn8p4xkhkn1m7hxh8w5gk1zy")) - (snippet '(begin - ;; Remove obsolete copy of system definition. - (delete-file "Code/fset.asd") - #t)))) + (base32 "0sxnn35gzdby1ixil6zbjg72vli9fcspwzsqimqk455310syx9iv")))) (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-misc-extensions sbcl-mt19937 sbcl-named-readtables)) - (synopsis "Functional set-theoretic collections library") + (home-page "https://github.com/lu4nx/cl-tld/") + (synopsis "Extract the Top Level Domain from domains, in Common Lisp") (description - "FSet is a functional set-theoretic collections library for Common Lisp. -Functional means that all update operations return a new collection rather than -modifying an existing one in place. Set-theoretic means that collections may -be nested arbitrarily with no additional programmer effort; for instance, sets -may contain sets, maps may be keyed by sets, etc.") - (home-page "https://common-lisp.net/project/fset/Site/index.html") - (license license:llgpl)))) + "This library extracts the TLD (Top Level Domain) from domains. The +information is taken from @url{https://publicsuffix.org}.") + (license license:public-domain)))) -(define-public cl-fset - (sbcl-package->cl-source-package sbcl-fset)) +(define-public cl-tld + (sbcl-package->cl-source-package sbcl-cl-tld)) -(define-public ecl-fset - (package - (inherit (sbcl-package->ecl-package sbcl-fset)) - (arguments - ;; Tests fails on ECL with "The function FSET::MAKE-CHAR is undefined". - '(#:tests? #f)))) +(define-public ecl-cl-tld + (sbcl-package->ecl-package sbcl-cl-tld)) -(define-public sbcl-modf - (let ((commit "dea93fe62c6bf7f66f32f52ac0c555aedbf7abad") +(define-public sbcl-cl-tls + (let ((commit "2ab4fc3ae7e79e451126a9bb6bc38ca2cd2cb4ba") (revision "0")) (package - (name "sbcl-modf") - (version (git-version "0" revision commit)) + (name "sbcl-cl-tls") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/smithzvk/modf") + (url "https://github.com/shrdlu68/cl-tls") (commit commit))) - (file-name (git-file-name "cl-modf" version)) + (file-name (git-file-name "cl-tls" version)) (sha256 - (base32 - "1aap7ldy7lv942khp026pgndgdzfkkqa9xcq1ykinrmflrgdazay")))) + (base32 "1j6gwv21ibkk6xd1xxm54wgwp09dzqg60b8z72hivpnq8gwm0ba7")))) (build-system asdf-build-system/sbcl) (inputs (list sbcl-alexandria - sbcl-closer-mop - sbcl-iterate)) - (native-inputs - (list sbcl-stefil)) - (home-page "https://github.com/smithzvk/modf") - (synopsis "SETF like macro for functional programming in Common Lisp") - (description "This library simplifies functional programming in Common -Lisp by making it easier to make new data structures with specified changes in -place.") + sbcl-babel + sbcl-cl-base64 + sbcl-fast-io + sbcl-ironclad)) + (home-page "https://github.com/shrdlu68/cl-tls") + (synopsis "Implementation of Transport Layer Security Protocols") + (description "This package provides prototype Common Lisp +implementations of TLS, RFC5246, ASN.1, x{501,509}, and PKCS{1,3,5,8}.") (license license:bsd-3)))) -(define-public cl-modf - (sbcl-package->cl-source-package sbcl-modf)) +(define-public cl-tls + (sbcl-package->cl-source-package sbcl-cl-tls)) -(define-public ecl-modf - (sbcl-package->ecl-package sbcl-modf)) +(define-public ecl-cl-tls + (sbcl-package->ecl-package sbcl-cl-tls)) -(define-public sbcl-cl-cont - (let ((commit "fc1fa7e6eb64894fdca13e688e6015fad5290d2a") +(define-public sbcl-cl-typesetting + (let ((commit "86eba981fc4254addebecf765578ec350d6e3b75") (revision "1")) (package - (name "sbcl-cl-cont") - (version (git-version "0.3.8" revision commit)) + (name "sbcl-cl-typesetting") + (version (git-version "0.8.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://gitlab.common-lisp.net/cl-cont/cl-cont.git") + (url "https://github.com/mbattyani/cl-typesetting") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-typesetting" version)) (sha256 - (base32 - "1zf8zvb0i6jm3hhfks4w74hibm6avgc6f9s1qwgjrn2bcik8lrvz")))) + (base32 "0fcs5mq0gxfczbrg7ay8r4bf5r4g6blvpdbjkhcl8dapcikyn35h")))) (build-system asdf-build-system/sbcl) + (arguments + ;; NOTE: (Sharlatan-20210515T213014+0100): Circular dependencies with + ;; cl-typegraph + `(#:tests? #f)) (inputs - (list sbcl-alexandria sbcl-closer-mop)) - (native-inputs - (list sbcl-rt)) - (synopsis "Delimited continuations for Common Lisp") + `(("cl-pdf" ,sbcl-cl-pdf) + ("xmls" ,sbcl-xmls))) + (home-page "https://github.com/mbattyani/cl-typesetting") + (synopsis "Stand-alone Common Lisp typesetting system") (description - "This is a library that implements delimited continuations by -transforming Common Lisp code to continuation passing style.") - (home-page "https://common-lisp.net/project/cl-cont/") - (license license:llgpl)))) + "CL-TYPESETTING is a cross-platform Common Lisp typesetting library for +all kind of typesetting applications.") + (license license:bsd-2)))) -(define-public cl-cont - (sbcl-package->cl-source-package sbcl-cl-cont)) +(define-public cl-typesetting + (sbcl-package->cl-source-package sbcl-cl-typesetting)) -(define-public ecl-cl-cont - (sbcl-package->ecl-package sbcl-cl-cont)) +(define-public ecl-cl-typesetting + (sbcl-package->ecl-package sbcl-cl-typesetting)) -(define-public sbcl-cl-coroutine - (let ((commit "de098f8d5debd8b14ef6864b5bdcbbf5ddbcfd72") +(define-public sbcl-cl-uglify-js + ;; There have been many bug fixes since the 2010 release. + (let ((commit "429c5e1d844e2f96b44db8fccc92d6e8e28afdd5") (revision "1")) (package - (name "sbcl-cl-coroutine") + (name "sbcl-cl-uglify-js") (version (git-version "0.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/takagi/cl-coroutine") + (url "https://github.com/mishoo/cl-uglify-js") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-uglify-js" version)) (sha256 (base32 - "1cqdhdjxffgfs116l1swjlsmcbly0xgcgrckvaajd566idj9yj4l")))) + "0k39y3c93jgxpr7gwz7w0d8yknn1fdnxrjhd03057lvk5w8js27a")))) (build-system asdf-build-system/sbcl) (inputs - `(("alexandria" ,sbcl-alexandria) - ("cl-cont" ,sbcl-cl-cont))) - (native-inputs - (list sbcl-prove)) - (arguments - `(;; TODO: Fix the tests. They fail with: - ;; "Component CL-COROUTINE-ASD::CL-COROUTINE-TEST not found" - #:tests? #f - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-tests - (lambda _ - (substitute* "cl-coroutine-test.asd" - (("cl-test-more") - "prove")) - #t))))) - (synopsis "Coroutine library for Common Lisp") - (description - "This is a coroutine library for Common Lisp implemented using the -continuations of the @code{cl-cont} library.") - (home-page "https://github.com/takagi/cl-coroutine") - (license license:llgpl)))) + (list sbcl-parse-js sbcl-cl-ppcre sbcl-cl-ppcre-unicode + sbcl-parse-number sbcl-iterate)) + (home-page "https://github.com/mishoo/cl-uglify-js") + (synopsis "JavaScript compressor library for Common Lisp") + (description "This is a Common Lisp version of UglifyJS, a JavaScript +compressor. It works on data produced by @code{parse-js} to generate a +@dfn{minified} version of the code. Currently it can: -(define-public cl-coroutine - (sbcl-package->cl-source-package sbcl-cl-coroutine)) +@itemize +@item reduce variable names (usually to single letters) +@item join consecutive @code{var} statements +@item resolve simple binary expressions +@item group most consecutive statements using the @code{sequence} operator (comma) +@item remove unnecessary blocks +@item convert @code{IF} expressions in various ways that result in smaller code +@item remove some unreachable code +@end itemize\n") + (license license:zlib)))) -(define-public ecl-cl-coroutine - (sbcl-package->ecl-package sbcl-cl-coroutine)) +(define-public cl-uglify-js + (sbcl-package->cl-source-package sbcl-cl-uglify-js)) -(define-public sbcl-vas-string-metrics - (let ((commit "f2e4500b180316123fbd549bd51c751ee2d6ba0f") - (revision "1")) - (package - (name "sbcl-vas-string-metrics") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/vsedach/vas-string-metrics") - (commit commit))) - (file-name (git-file-name "vas-string-metrics" version)) - (sha256 - (base32 "11fcnd03ybzz37rkg3z0wsb727yqgcd9gn70sccfb34l89ia279k")))) - (build-system asdf-build-system/sbcl) - (arguments - '(#:asd-test-systems '("test.vas-string-metrics") - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-test-asd - (lambda _ - (substitute* "test.vas-string-metrics.asd" - ((":depends-on") - (string-append - ":perform (test-op (op c) (symbol-call :vas-string-metrics :run-tests))" - "\n" - " :depends-on")))))))) - (home-page "https://github.com/vsedach/vas-string-metrics") - (synopsis "String distance algorithms for Common Lisp") - (description - "VAS-STRING-METRICS provides the Jaro, Jaro-Winkler, Soerensen-Dice, -Levenshtein, and normalized Levenshtein string distance/similarity metrics -algorithms.") - (license license:lgpl3+)))) +(define-public ecl-cl-uglify-js + (sbcl-package->ecl-package sbcl-cl-uglify-js)) -(define-public ecl-vas-string-metrics - (sbcl-package->ecl-package sbcl-vas-string-metrics)) +(define-public uglify-js + (package + (inherit sbcl-cl-uglify-js) + (name "uglify-js") + (build-system trivial-build-system) + (arguments + `(#:modules ((guix build utils)) + #:builder + (let* ((bin (string-append (assoc-ref %outputs "out") "/bin/")) + (script (string-append bin "uglify-js"))) + (use-modules (guix build utils)) + (mkdir-p bin) + (with-output-to-file script + (lambda _ + (format #t "#!~a/bin/sbcl --script -(define-public cl-vas-string-metrics - (sbcl-package->cl-source-package sbcl-vas-string-metrics)) + (require :asdf) + (asdf:initialize-source-registry + #p\"~a/etc/common-lisp/source-registry.conf.d/\") + (asdf:initialize-output-translations + #p\"~a/etc/common-lisp/asdf-output-translations.conf.d/\")" + (assoc-ref %build-inputs "sbcl") + (assoc-ref %build-inputs "sbcl-cl-uglify-js") + (assoc-ref %build-inputs "sbcl-cl-uglify-js")) + ;; FIXME: cannot use progn here because otherwise it fails to + ;; find cl-uglify-js. + (for-each + write + '(;; Quiet, please! + (let ((*standard-output* (make-broadcast-stream)) + (*error-output* (make-broadcast-stream))) + (asdf:load-system :cl-uglify-js)) + (let ((file (cadr *posix-argv*))) + (if file + (format t "~a" + (cl-uglify-js:ast-gen-code + (cl-uglify-js:ast-mangle + (cl-uglify-js:ast-squeeze + (with-open-file (in file) + (parse-js:parse-js in)))) + :beautify nil)) + (progn + (format *error-output* + "Please provide a JavaScript file.~%") + (sb-ext:exit :code 1)))))))) + (chmod script #o755) + #t))) + (inputs + (list sbcl sbcl-cl-uglify-js)) + (synopsis "JavaScript compressor"))) -(define-public sbcl-vom - (let ((commit "1aeafeb5b74c53741b79497e0ef4acf85c92ff24") +(define-public sbcl-cl-unicode + (package + (name "sbcl-cl-unicode") + (version "0.1.6") + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/edicl/cl-unicode") + (commit (string-append "v" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "0ykx2s9lqfl74p1px0ik3l2izd1fc9jd1b4ra68s5x34rvjy0hza")))) + (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-flexi-streams)) + (inputs + (list sbcl-cl-ppcre)) + (home-page "http://weitz.de/cl-unicode/") + (synopsis "Portable Unicode library for Common Lisp") + (description "CL-UNICODE is a portable Unicode library Common Lisp, which +is compatible with perl. It is pretty fast, thread-safe, and compatible with +ANSI-compliant Common Lisp implementations.") + (license license:bsd-2))) + +(define-public cl-unicode + (sbcl-package->cl-source-package sbcl-cl-unicode)) + +(define-public ecl-cl-unicode + (sbcl-package->ecl-package sbcl-cl-unicode)) + +(define-public sbcl-cl-unification + (let ((commit "01079f34d197495880aa49ab727d63774d83035c") (revision "1")) (package - (name "sbcl-vom") - (version (git-version "0.1.4" revision commit)) + (name "sbcl-cl-unification") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/orthecreedence/vom") + (url "https://gitlab.common-lisp.net/cl-unification/cl-unification") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-unification" version)) (sha256 - (base32 - "0536kppj76ax4lrxhv42npkfjsmx45km2g439vf9jmw3apinz9cy")))) + (base32 "0nhqamn3qgg38i6aw2pshffdwr2hzslycg8ficmn333gw0h9rf4g")))) (build-system asdf-build-system/sbcl) - (synopsis "Tiny logging utility for Common Lisp") + (native-inputs + (list sbcl-ptester)) + (inputs + (list sbcl-cl-ppcre)) + (home-page "https://common-lisp.net/project/cl-unification/") + (synopsis "Unification framework for Common Lisp") (description - "Vom is a logging library for Common Lisp. It's goal is to be useful -and small. It does not provide a lot of features as other loggers do, but -has a small codebase that's easy to understand and use.") - (home-page "https://github.com/orthecreedence/vom") - (license license:expat)))) + "This package provides a framework to unify arbitrary +Common Lisp objects while constructing bindings for placeholders +(unification variables) in a template sublanguage.") + (license license:bsd-0)))) -(define-public cl-vom - (sbcl-package->cl-source-package sbcl-vom)) +(define-public cl-unification + (sbcl-package->cl-source-package sbcl-cl-unification)) -(define-public ecl-vom - (sbcl-package->ecl-package sbcl-vom)) +(define-public ecl-cl-unification + (let ((pkg (sbcl-package->ecl-package sbcl-cl-unification))) + (package + (inherit pkg) + (arguments + (substitute-keyword-arguments (package-arguments pkg) + ;; The tests fail on ECL with: + ;; "In MAKE-ARRAY: the elements in :INITIAL-CONTENTS do not match + ;; the array dimensions." + ((#:tests? _ #f) #f)))))) -(define-public sbcl-cl-libuv - (let ((commit "32100c023c518038d0670a103eaa4d50dd785d29") +(define-public sbcl-cl-utilities + (let ((commit "dce2d2f6387091ea90357a130fa6d13a6776884b") (revision "1")) (package - (name "sbcl-cl-libuv") - (version (git-version "0.1.6" revision commit)) + (name "sbcl-cl-utilities") + (version (git-version "0.0.0" revision commit)) (source (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/orthecreedence/cl-libuv") - (commit commit))) - (file-name (git-file-name name version)) + (method url-fetch) + (uri + (string-append + "https://gitlab.common-lisp.net/cl-utilities/cl-utilities/-/" + "archive/" commit "/cl-utilities-" commit ".tar.gz")) (sha256 - (base32 - "1kwix4si8a8hza34ab2k7whrh7z0yrmx39v2wc3qblv9m244jkh1")))) + (base32 "1r46v730yf96nk2vb24qmagv9x96xvd08abqwhf02ghgydv1a7z2")))) (build-system asdf-build-system/sbcl) - (inputs - `(("alexandria" ,sbcl-alexandria) - ("cffi" ,sbcl-cffi) - ("libuv" ,libuv))) (arguments - `(#:phases + '(#:phases (modify-phases %standard-phases (add-after 'unpack 'fix-paths (lambda* (#:key inputs #:allow-other-keys) - (substitute* "lib.lisp" - (("/usr/lib/libuv.so") - (search-input-file inputs "/lib/libuv.so"))))) - (add-after 'fix-paths 'fix-system-definition - (lambda _ - (substitute* "cl-libuv.asd" - (("#:cffi #:alexandria") - "#:cffi #:cffi-grovel #:alexandria")) - #t))))) - (synopsis "Common Lisp bindings to libuv") + (substitute* "rotate-byte.lisp" + (("in-package :cl-utilities)" all) + "in-package :cl-utilities)\n\n#+sbcl\n(require :sb-rotate-byte)"))))))) + (home-page "https://common-lisp.net/project/cl-utilities") + (synopsis "Collection of semi-standard utilities") (description - "This library provides low-level libuv bindings for Common Lisp.") - (home-page "https://github.com/orthecreedence/cl-libuv") - (license license:expat)))) + "On Cliki.net <http://www.cliki.net/Common%20Lisp%20Utilities>, there +is a collection of Common Lisp Utilities, things that everybody writes since +they're not part of the official standard. There are some very useful things +there; the only problems are that they aren't implemented as well as you'd +like (some aren't implemented at all) and they aren't conveniently packaged +and maintained. It takes quite a bit of work to carefully implement utilities +for common use, commented and documented, with error checking placed +everywhere some dumb user might make a mistake.") + (license license:public-domain)))) -(define-public cl-libuv - (sbcl-package->cl-source-package sbcl-cl-libuv)) +(define-public cl-utilities + (sbcl-package->cl-source-package sbcl-cl-utilities)) -(define-public ecl-cl-libuv - (sbcl-package->ecl-package sbcl-cl-libuv)) +(define-public ecl-cl-utilities + (sbcl-package->ecl-package sbcl-cl-utilities)) -(define-public sbcl-cl-async - (let ((commit "f6423e44404a44434d803605e0d2e17199158e28") - (revision "1")) +(define-public sbcl-cl-variates + (let ((commit "4e7548754d8a8731a42487fae31174db4bf36d47") + (revision "0")) (package - (name "sbcl-cl-async") - (version (git-version "0.6.1" revision commit)) + (name "sbcl-cl-variates") + (version "0.9.0") (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/orthecreedence/cl-async") + (url "https://gitlab.common-lisp.net/cl-variates/cl-variates") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-variates" version)) (sha256 - (base32 - "11xi9dxb8mjgwzrkj88i0xkgk26z9w9ddxzbv6xsvfc1d4x5cf4x")))) + (base32 "03wnvfi3yfflpvi0mr732r834msij4vrwdbgf6csh0b8kqxl47zn")))) (build-system asdf-build-system/sbcl) - (inputs - `(("babel" ,sbcl-babel) - ("bordeaux-threads" ,sbcl-bordeaux-threads) - ("cffi" ,sbcl-cffi) - ("cl-libuv" ,sbcl-cl-libuv) - ("cl-ppcre" ,sbcl-cl-ppcre) - ("fast-io" ,sbcl-fast-io) - ("openssl" ,openssl) - ("static-vectors" ,sbcl-static-vectors) - ("trivial-features" ,sbcl-trivial-features) - ("trivial-gray-streams" ,sbcl-trivial-gray-streams) - ("vom" ,sbcl-vom))) - (arguments - `(#:asd-systems '("cl-async" - "cl-async-repl" - "cl-async-ssl") - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "src/ssl/package.lisp" - (("libcrypto\\.so") - (search-input-file inputs "/lib/libcrypto.so")) - (("libssl\\.so") - (search-input-file inputs "/lib/libssl.so")))))))) - (synopsis "Asynchronous operations for Common Lisp") - (description - "Cl-async is a library for general purpose, non-blocking programming in -Common Lisp. It uses the libuv library as backend.") - (home-page "https://orthecreedence.github.io/cl-async/") + ;; USE-PACKAGE #<PACKAGE "CL-VARIATES"> causes name-conflicts in + ;; #<PACKAGE "CL-VARIATES-TEST"> between the following symbols: + ;; CL-VARIATES:RANDOM-ELEMENT, LIFT:RANDOM-ELEMENT + (arguments (list #:tests? #f)) + (native-inputs (list sbcl-lift)) + (home-page "https://gitlab.common-lisp.net/cl-variates/cl-variates") + (synopsis "Portable Common Lisp Random Number Generation") + (description "The variates package provides portable random number +generation as well as numerous distributions.") (license license:expat)))) -(define-public cl-async - (sbcl-package->cl-source-package sbcl-cl-async)) +(define-public cl-variates + (sbcl-package->cl-source-package sbcl-cl-variates)) -(define-public ecl-cl-async - (sbcl-package->ecl-package sbcl-cl-async)) +(define-public ecl-cl-variates + (sbcl-package->ecl-package sbcl-cl-variates)) -(define-public sbcl-classimp - (let ((commit "d82a14c59bc733f89a1ea0b3447ebedddce5756e") +(define-public sbcl-cl-vectors + (package + (name "sbcl-cl-vectors") + (version "0.1.5") + (source + (origin + (method url-fetch) + (uri (string-append "http://projects.tuxee.net/cl-vectors/" + "files/cl-vectors-" version ".tar.gz")) + (sha256 + (base32 + "04lhwi0kq8pkwhgd885pk80m1cp9sfvjjn5zj70s1dnckibhdmqh")))) + (build-system asdf-build-system/sbcl) + (inputs + `(("zpb-ttf" ,sbcl-zpb-ttf))) + (arguments + '(#:asd-systems '("cl-vectors" + "cl-paths" + "cl-paths-ttf" + "cl-aa" + "cl-aa-misc"))) + (home-page "http://projects.tuxee.net/cl-vectors/") + (synopsis "Create, transform and render anti-aliased vectorial paths") + (description + "This is a pure Common Lisp library to create, transform and render +anti-aliased vectorial paths.") + (license license:expat))) + +(define-public cl-vectors + (sbcl-package->cl-source-package sbcl-cl-vectors)) + +(define-public ecl-cl-vectors + (sbcl-package->ecl-package sbcl-cl-vectors)) + +(define-public sbcl-cl-vorbis + (let ((commit "c5835cd7091aea9e2e389ad359d244542d637758") (revision "0")) (package - (name "sbcl-classimp") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-cl-vorbis") + (version (git-version "1.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/3b/classimp") + (url "https://github.com/Shirakumo/cl-vorbis") (commit commit))) - (file-name (git-file-name "cl-classimp" version)) + (file-name (git-file-name "cl-vorbis" version)) (sha256 - (base32 "0pbnz6cf1zb2ayk4kbw0gphjb8nflnjns2rwhv86jz0kf0z1hqha")))) + (base32 "0713pl5c2khfpf8m3h1l2y0ilack7akf580h70jq6qcrnq3h4b40")) + (modules '((guix build utils))) + (snippet + ;; Delete bundled libraries, GlibC and Vorbis sources. + `(begin + (delete-file-recursively "static") + (for-each delete-file '("glibc-2.13.h" + "stb_vorbis.c" + "stb_vorbis_patch.c")))))) (build-system asdf-build-system/sbcl) (arguments - (list - #:phases - #~(modify-phases %standard-phases - (add-after 'unpack 'patch-assimp-lib-path - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "library.lisp" - (("libassimp.so.5" _) - (search-input-file inputs "/lib/libassimp.so.5.0.0")))))))) + `(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'fix-paths + (lambda* (#:key inputs #:allow-other-keys) + (substitute* "low-level.lisp" + (("libvorbis-lin-amd64.so") + (search-input-file inputs "/lib/libvorbis.so")))))))) (inputs - (list assimp-5.0 + (list libvorbis sbcl-cffi - sbcl-split-sequence)) - (home-page "https://github.com/3b/classimp") - (synopsis "Common Lisp CFFI bindings for Open Asset Import Library") - (description - "This package provides CFFI bindings to the @acronym{ASSIMP, Asset -Import} library for Common Lisp.") - (license license:expat)))) + sbcl-documentation-utils + sbcl-static-vectors + sbcl-trivial-features + sbcl-trivial-garbage)) + (home-page "https://shirakumo.github.io/cl-vorbis/") + (synopsis "OGG/Vorbis decoding using stb_vorbis for Common Lisp") + (description "This package provides CFFI bindings for the +@code{stb_vorbis} audio library to Common Lisp.") + (license license:zlib)))) -;; FIXME: The cl and ecl packages get the latest version of assimp as -;; dependency instead of the one specified in the sbcl package. Specifying -;; the dependencies explicitly works around the issue. -(define-public cl-classimp - (let ((pkg (sbcl-package->cl-source-package sbcl-classimp))) - (package - (inherit pkg) - (inputs - (list assimp-5.0 - cl-cffi - cl-split-sequence))))) +(define-public cl-vorbis + (sbcl-package->cl-source-package sbcl-cl-vorbis)) -(define-public ecl-classimp - (let ((pkg (sbcl-package->ecl-package sbcl-classimp))) - (package - (inherit pkg) - (inputs - (list assimp-5.0 - ecl-cffi - ecl-split-sequence))))) +(define-public ecl-cl-vorbis + (sbcl-package->ecl-package sbcl-cl-vorbis)) -(define-public sbcl-blackbird - (let ((commit "d361f81c1411dec07f6c2dcb11c78f7aea9aaca8") - (revision "1")) +(define-public sbcl-cl-wayland + (let ((commit "a92a5084b64102f538ab90212e99c7863e5338ae") + (revision "0")) (package - (name "sbcl-blackbird") - (version (git-version "0.5.2" revision commit)) + (name "sbcl-cl-wayland") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/orthecreedence/blackbird") + (url "https://github.com/sdilts/cl-wayland") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-wayland" version)) (sha256 - (base32 - "0xfds5yaya64arzr7w1x38karyz11swzbhxx1afldpradj9dh19c")))) + (base32 "1r4fn9dc0dz2b30k8z243yacx1y5z21qk4zh2ildj7ak51qx53zf")))) (build-system asdf-build-system/sbcl) + (arguments + (list #:phases + #~(modify-phases %standard-phases + (add-after 'unpack 'fix-paths + (lambda* (#:key inputs #:allow-other-keys) + (substitute* "wayland-server-core.lisp" + (("libwayland-server.so") + (search-input-file inputs + "/lib/libwayland-server.so")))))))) (inputs - (list sbcl-vom)) - (native-inputs - (list sbcl-cl-async sbcl-fiveam)) - (synopsis "Promise implementation for Common Lisp") + (list sbcl-cffi + sbcl-closer-mop + wayland)) + (home-page "https://github.com/sdilts/cl-wayland") + (synopsis "Common Lisp FFI bindings for libwayland") (description - "This is a standalone promise implementation for Common Lisp. It is -the successor to the now-deprecated cl-async-future project.") - (home-page "https://orthecreedence.github.io/blackbird/") - (license license:expat)))) + "This package provides Common Lisp FFI bindings for libwayland, +primarily for the mahogany window manager.") + (license license:bsd-3)))) -(define-public cl-blackbird - (sbcl-package->cl-source-package sbcl-blackbird)) +(define-public cl-wayland + (sbcl-package->cl-source-package sbcl-cl-wayland)) -(define-public ecl-blackbird - (sbcl-package->ecl-package sbcl-blackbird)) +(define-public ecl-cl-wayland + (sbcl-package->ecl-package sbcl-cl-wayland)) -(define-public sbcl-cl-async-future - (let ((commit "ee36c22a69a9516407458d2ed8b475f1fc473959") - (revision "1")) +(define-public sbcl-cl-webkit + (package + (name "sbcl-cl-webkit") + (version "3.5.10") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/joachifm/cl-webkit") + (commit version))) + (file-name (git-file-name "cl-webkit" version)) + (sha256 + (base32 + "0bn8idvbi58kg0g76lanvjzkgnkcy41yn9vbp7f80q9fa7w892rq")))) + (build-system asdf-build-system/sbcl) + (inputs + `(("cffi" ,sbcl-cffi) + ("cl-cffi-gtk" ,sbcl-cl-cffi-gtk) + ("webkitgtk" ,webkitgtk-for-gtk3))) + (native-inputs + `(;; Tests seem to need Xorg. + ;; ("xorg-server" ,xorg-server-for-tests) + ("calispel" ,sbcl-calispel) + ("fiveam" ,sbcl-fiveam) + ("float-features" ,sbcl-float-features))) + (arguments + `(#:asd-systems '("cl-webkit2") + #:tests? #f ; TODO: Tests hang, why? + #:phases + (modify-phases %standard-phases + ;; The following phase is needed for tests: + ;; (add-before 'check 'start-xorg-server + ;; (lambda* (#:key inputs #:allow-other-keys) + ;; ;; The test suite requires a running X server. + ;; (system (string-append (assoc-ref inputs "xorg-server") + ;; "/bin/Xvfb :1 &")) + ;; (setenv "DISPLAY" ":1") + ;; #t)) + (add-after 'unpack 'fix-paths + (lambda* (#:key inputs #:allow-other-keys) + (substitute* "webkit2/webkit2.init.lisp" + (("libwebkit2gtk" all) + (string-append + (assoc-ref inputs "webkitgtk") "/lib/" all)))))))) + (home-page "https://github.com/joachifm/cl-webkit") + (synopsis "Binding to WebKitGTK+ for Common Lisp") + (description + "@command{cl-webkit} is a binding to WebKitGTK+ for Common Lisp, +currently targeting WebKit version 2. The WebKitGTK+ library adds web +browsing capabilities to an application, leveraging the full power of the +WebKit browsing engine.") + (license license:expat))) + +(define-public cl-webkit + (sbcl-package->cl-source-package sbcl-cl-webkit)) + +(define-public ecl-cl-webkit + (sbcl-package->ecl-package sbcl-cl-webkit)) + +(define-public sbcl-cl-who + (let ((version "1.1.4") + (commit "07dafe9b351c32326ce20b5804e798f10d4f273d") + (revision "3")) (package - (name "sbcl-cl-async-future") - (version (git-version "0.4.4.1" revision commit)) + (name "sbcl-cl-who") + (version (git-version version revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/orthecreedence/cl-async-future") + (url "https://github.com/edicl/cl-who") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-who" version)) (sha256 (base32 - "0z0sc7qlzzxk99f4l26zp6rai9kv0kj0f599sxai5s44p17zbbvh")))) + "1rdvs113q6d46cblwhsv1vmm31p952wyzkyibqix0ypadpczlgp5")))) (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-blackbird)) (native-inputs - (list sbcl-cl-async sbcl-eos)) - (synopsis "Futures implementation for Common Lisp") + (list sbcl-flexi-streams)) + (home-page "https://edicl.github.io/cl-who/") + (synopsis "Yet another Lisp markup language") (description - "This is futures implementation for Common Lisp. It plugs in nicely -to cl-async.") - (home-page "https://orthecreedence.github.io/cl-async/future") - (license license:expat)))) + "There are plenty of Lisp Markup Languages out there - every Lisp +programmer seems to write at least one during his career - and CL-WHO (where +WHO means \"with-html-output\" for want of a better acronym) is probably just +as good or bad as the next one.") + (license license:bsd-2)))) -(define-public cl-async-future - (sbcl-package->cl-source-package sbcl-cl-async-future)) +(define-public cl-who + (sbcl-package->cl-source-package sbcl-cl-who)) -(define-public ecl-cl-async-future - (sbcl-package->ecl-package sbcl-cl-async-future)) +(define-public ecl-cl-who + (sbcl-package->ecl-package sbcl-cl-who)) -(define-public sbcl-green-threads - (let ((commit "fff5ebecb441a37e5c511773716aafd84a3c5840") - (revision "1")) +(define-public sbcl-cl-xmlspam + (let ((commit "ea06abcca2a73a9779bcfb09081e56665f94e22a")) (package - (name "sbcl-green-threads") - (version (git-version "0.3" revision commit)) + (name "sbcl-cl-xmlspam") + (build-system asdf-build-system/sbcl) + (version (git-version "0.0.0" "1" commit)) + (home-page "https://github.com/rogpeppe/cl-xmlspam") (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/thezerobit/green-threads") + (url home-page) (commit commit))) - (file-name (git-file-name name version)) + (file-name (string-append name "-" version)) (sha256 (base32 - "1czw7nr0dwfps76h8hjvglk1wdh53yqbfbvv30whwbgqx33iippz")))) - (build-system asdf-build-system/sbcl) + "0w4rqvrgdgk3fwfq3kx4r7wwdr2bv3b6n3bdqwsiriw9psqzpz2s")))) (inputs - `(("cl-async-future" ,sbcl-cl-async-future) - ("cl-cont" ,sbcl-cl-cont))) - (native-inputs - (list sbcl-prove)) - (arguments - `(;; TODO: Fix the tests. They fail with: - ;; "The function BLACKBIRD::PROMISE-VALUES is undefined" - #:tests? #f - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-tests - (lambda _ - (substitute* "green-threads-test.asd" - (("cl-test-more") - "prove")) - #t))))) - (synopsis "Cooperative multitasking library for Common Lisp") - (description - "This library allows for cooperative multitasking with help of cl-cont -for continuations. It tries to mimic the API of bordeaux-threads as much as -possible.") - (home-page "https://github.com/thezerobit/green-threads") + (list sbcl-cxml sbcl-cl-ppcre)) + (synopsis "Concise, regexp-like pattern matching on streaming XML for Common Lisp") + (description "CXML does an excellent job at parsing XML elements, but what +do you do when you have a XML file that's larger than you want to fit in +memory, and you want to extract some information from it? Writing code to deal +with SAX events, or even using Klacks, quickly becomes tedious. +@code{cl-xmlspam} (for XML Stream PAttern Matcher) is designed to make it easy +to write code that mirrors the structure of the XML that it's parsing. It +also makes it easy to shift paradigms when necessary - the usual Lisp control +constructs can be used interchangeably with pattern matching, and the full +power of CXML is available when necessary.") (license license:bsd-3)))) -(define-public cl-green-threads - (sbcl-package->cl-source-package sbcl-green-threads)) +(define-public cl-xmlspam + (sbcl-package->cl-source-package sbcl-cl-xmlspam)) -(define-public ecl-green-threads - (sbcl-package->ecl-package sbcl-green-threads)) +(define-public ecl-cl-xmlspam + (sbcl-package->ecl-package sbcl-cl-xmlspam)) -(define-public sbcl-cl-base32 - (let ((commit "8cdee06fab397f7b0a19583b57e7f0c98405be85") +(define-public sbcl-cl-yacc + (package + (name "sbcl-cl-yacc") + (version "0.3") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/jech/cl-yacc") + (commit (string-append "cl-yacc-" version)))) + (sha256 + (base32 + "16946pzf8vvadnyfayvj8rbh4zjzw90h0azz2qk1mxrvhh5wklib")) + (file-name (string-append "cl-yacc-" version "-checkout")))) + (build-system asdf-build-system/sbcl) + (arguments + `(#:asd-systems '("yacc"))) + (synopsis "LALR(1) parser generator for Common Lisp, similar in spirit to Yacc") + (description + "CL-Yacc is a LALR(1) parser generator for Common Lisp, similar in spirit +to AT&T Yacc, Berkeley Yacc, GNU Bison, Zebu, lalr.cl or lalr.scm. + +CL-Yacc uses the algorithm due to Aho and Ullman, which is the one also used +by AT&T Yacc, Berkeley Yacc and Zebu. It does not use the faster algorithm due +to DeRemer and Pennello, which is used by Bison and lalr.scm (not lalr.cl).") + (home-page "https://www.irif.fr/~jch//software/cl-yacc/") + (license license:expat))) + +(define-public cl-yacc + (sbcl-package->cl-source-package sbcl-cl-yacc)) + +(define-public ecl-cl-yacc + (sbcl-package->ecl-package sbcl-cl-yacc)) + +(define-public sbcl-cl-yaml + (let ((commit "c3202be9a753c51f3bc79538a5a498a8865192aa") (revision "1")) (package - (name "sbcl-cl-base32") + (name "sbcl-cl-yaml") (version (git-version "0.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/hargettp/cl-base32") + (url "https://github.com/eudoxia0/cl-yaml") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-yaml" version)) (sha256 - (base32 "17jrng8jb05d64ggyd11hp308c2fl5drvf9g175blgrkkl8l4mf8")))) + (base32 "1izjg0v6rf7dh069bbnnr67l30lsqj86wdk7y9ggbgiwh6v9j185")))) (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-alexandria sbcl-cl-libyaml sbcl-cl-ppcre + sbcl-parse-number)) (native-inputs - (list sbcl-lisp-unit)) - (synopsis "Common Lisp library for base32 encoding and decoding") + (list sbcl-cl-fad sbcl-fiveam sbcl-generic-comparability + sbcl-trivial-benchmark sbcl-yason)) + (home-page "https://github.com/eudoxia0/cl-yaml") + (synopsis "YAML parser for Common Lisp") (description - "This package provides functions for base32 encoding and decoding as -defined in RFC4648.") - (home-page "https://github.com/hargettp/cl-base32") + "This is a YAML parser and emitter for Common Lisp built on top of +libyaml.") (license license:expat)))) -(define-public cl-base32 - (sbcl-package->cl-source-package sbcl-cl-base32)) +(define-public cl-yaml + (sbcl-package->cl-source-package sbcl-cl-yaml)) -(define-public ecl-cl-base32 - (sbcl-package->ecl-package sbcl-cl-base32)) +(define-public ecl-cl-yaml + (sbcl-package->ecl-package sbcl-cl-yaml)) (define-public sbcl-cl-z85 (let ((commit "85b3951a9cfa2603acb6aee15567684f9a108098") @@ -12626,1557 +10087,875 @@ ZeroMQ.") (define-public ecl-cl-z85 (sbcl-package->ecl-package sbcl-cl-z85)) -(define-public sbcl-ltk - (let ((commit "ff14a781d211c19c35e65a7ecaece67dda0b3ebb") - (revision "0")) +(define-public sbcl-clache + (let ((commit "112976729565e1035532389ca25090ae99badd07")) (package - (name "sbcl-ltk") - (version (git-version "0.992" revision commit)) + (name "sbcl-clache") + (version (git-version "0.2.1" "1" commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/herth/ltk") + (url "https://github.com/html/clache/") (commit commit))) - (file-name (git-file-name "cl-ltk" version)) + (file-name (git-file-name "cl-clache" version)) (sha256 - (base32 "0f1xgsj2j7bq21cq2pa9rw3ybxd9vyknisl6z307lxx7lvhm3xac")))) + (base32 "0wxg004bsay58vr6xr6mlk7wj415qmvisqxvpnjsg6glfwca86ys")))) (build-system asdf-build-system/sbcl) (inputs - (list imagemagick tk)) + (list sbcl-alexandria + sbcl-babel + sbcl-cl-annot + sbcl-cl-fad + sbcl-cl-store + sbcl-cl-syntax + sbcl-ironclad + sbcl-trivial-garbage)) + (native-inputs + (list sbcl-prove)) (arguments - `(#:asd-systems '("ltk" - "ltk-mw" - "ltk-remote") - #:tests? #f - #:phases + `(#:phases (modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "ltk/ltk.lisp" - (("#-freebsd \"wish\"") - (string-append "#-freebsd \"" - (assoc-ref inputs "tk") - "/bin/wish\"")) - (("do-execute \"convert\"") - (string-append "do-execute \"" - (assoc-ref inputs "imagemagick") - "/bin/convert\""))) - #t)) - (add-after 'unpack 'fix-build + (add-after 'unpack 'fix-tests (lambda _ - (substitute* "ltk/ltk-remote.lisp" - (("\\(:export") - "(:shadow #:raise) (:export")) + (substitute* "clache-test.asd" + (("cl-test-more") "prove")) #t))))) - (synopsis "Common Lisp bindings for the Tk GUI toolkit") + (home-page "https://github.com/html/clache/") + (synopsis "General caching facility for Common Lisp") (description - "LTK is a Common Lisp binding for the Tk graphics toolkit. It is -written in pure Common Lisp and does not require any Tk knowledge for its -usage.") - (home-page "http://www.peter-herth.de/ltk/") + "CLACHE provides a general caching facility for Common Lisp. The API is +similar to the standard hash-table interface.") (license license:llgpl)))) -(define-public cl-ltk - (sbcl-package->cl-source-package sbcl-ltk)) +(define-public cl-clache + (sbcl-package->cl-source-package sbcl-clache)) -(define-public ecl-ltk - (sbcl-package->ecl-package sbcl-ltk)) +(define-public ecl-clache + (sbcl-package->ecl-package sbcl-clache)) -(define-public sbcl-cl-lex - (let ((commit "f2dbbe25ef553005fb402d9a6203180c3fa1093b") - (revision "1")) +(define-public sbcl-clack + (let ((commit "6fd0279424f7ba5fd4f92d69a1970846b0b11222") + (revision "2")) (package - (name "sbcl-cl-lex") - (version (git-version "1.1.3" revision commit)) + (name "sbcl-clack") + (version (git-version "2.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/djr7C4/cl-lex") + (url "https://github.com/fukamachi/clack") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-clack" version)) (sha256 - (base32 "1kg50f76bfpfxcv4dfivq1n9a0xlsra2ajb0vd68lxwgbidgyc2y")))) + (base32 "0sfmvqmsg9z13x0v77448rpdqgyprdq739nsbrjw9a28hv9jmkg9")))) (build-system asdf-build-system/sbcl) + (arguments + '(#:asd-systems '("clack" + "clack-handler-fcgi" + "clack-socket" + "clack-handler-hunchentoot"))) (inputs - (list sbcl-cl-ppcre)) - (synopsis "Common Lisp macros for generating lexical analyzers") + (list sbcl-alexandria + sbcl-bordeaux-threads + sbcl-cl-fastcgi + sbcl-flexi-streams + sbcl-hunchentoot + sbcl-lack + sbcl-quri + sbcl-split-sequence + sbcl-usocket)) + (home-page "https://github.com/fukamachi/clack") + (synopsis "Web Application Environment for Common Lisp") (description - "This is a Common Lisp library providing a set of macros for generating -lexical analyzers automatically. The lexers generated using @code{cl-lex} can -be used with @code{cl-yacc}.") - (home-page "https://github.com/djr7C4/cl-lex") - (license license:gpl3)))) - -(define-public cl-lex - (sbcl-package->cl-source-package sbcl-cl-lex)) - -(define-public ecl-cl-lex - (sbcl-package->ecl-package sbcl-cl-lex)) - -(define-public sbcl-cl-colors2 - (package - (name "sbcl-cl-colors2") - (version "0.6.0") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://codeberg.org/cage/cl-colors2") - (commit (string-append "v" version)))) - (file-name (git-file-name "cl-colors2" version)) - (sha256 - (base32 "0vnvlq9xixs04768q7hapsi16cjp3ych6mypvs6chihd5dal4cnd")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-clunit2)) - (inputs - (list sbcl-alexandria sbcl-cl-ppcre sbcl-parse-number)) - (synopsis "Color library for Common Lisp") - (description - "This is a very simple color library for Common Lisp, providing: - -@itemize -@item Types for representing colors in HSV, HSL, and RGB spaces. -@item Simple conversion functions between the above types. -@item Function printing colors to HEX, RGB, RGBA, and HSL. -@item Predefined colors from X11, SVG, and GDK. -@end itemize\n") - (home-page "https://codeberg.org/cage/cl-colors2") - (license license:boost1.0))) + "Clack is a web application environment for Common Lisp inspired by +Python's WSGI and Ruby's Rack.") + (license license:llgpl)))) -(define-public cl-colors2 - (sbcl-package->cl-source-package sbcl-cl-colors2)) +(define-public cl-clack + (sbcl-package->cl-source-package sbcl-clack)) -(define-public ecl-cl-colors2 - (sbcl-package->ecl-package sbcl-cl-colors2)) +(define-public ecl-clack + (sbcl-package->ecl-package sbcl-clack)) -(define-public sbcl-colored - (let ((commit "bee87efb0b047da0f071f5cf1457997ab5f93feb") - (revision "1")) +(define-public sbcl-clad + (let ((commit "1ff6f417d4ee3836d1edd96923d4b03f3cafa849") + (revision "0")) (package - (name "sbcl-colored") - (version (git-version "1.0.0" revision commit)) + (name "sbcl-clad") + (version + ;; There's no version, but there's a timestamp + (git-version "2023-01-21" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/Shinmera/colored/") + (url "https://gitlab.common-lisp.net/mantoniotti/CLAD") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-clad" version)) (sha256 - (base32 "0mpg91r6yfb9xqccd4r8z3hl2qzjhdj6daswb1cinrm8ffxrvy5k")))) + (base32 "184mhdq7pxd6hd4rzv8z4lfbwnkyhgm5bdn3xsqaav2j0d1dqm6i")) + (modules '((guix build utils))) + (snippet + ;; Delete compiled ABCL files. + '(begin + (delete-file "clad-package.abcl") + (delete-file "clad.abcl"))))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-parachute)) - (inputs - (list sbcl-documentation-utils)) - (synopsis "Colour representation, conversion, and operation for Common Lisp") + (synopsis "Library providing standard locations on the file system") (description - "This is a library for representing and mapping colours between their -various spaces.") - (home-page "https://shinmera.github.io/colored/") - (license license:zlib)))) - -(define-public cl-colored - (sbcl-package->cl-source-package sbcl-colored)) + "The Common Lisp Application Directories (CLAD) library is +a simple API collection that provides access to a set of @emph{standard} +Common Lisp folders on a per-application or per-library basis.") + (home-page "https://gitlab.common-lisp.net/mantoniotti/CLAD") + (license license:expat)))) ;the mit-modern-variant is used -(define-public ecl-colored - (sbcl-package->ecl-package sbcl-colored)) +(define-public cl-clad + (sbcl-package->cl-source-package sbcl-clad)) -(define-public sbcl-cl-jpeg - (let ((commit "ec557038128df6895fbfb743bfe8faf8ec2534af") - (revision "1")) +(define-public sbcl-clamp + (let ((commit "02b8f3953e5753cc61a719807c82f3795cd28fe1")) (package - (name "sbcl-cl-jpeg") - (version (git-version "2.8" revision commit)) + (name "sbcl-clamp") + (version (git-version "0.3" "1" commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/sharplispers/cl-jpeg") + (url "https://github.com/arclanguage/Clamp") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 "1bkkiqz8fqldlj1wbmrccjsvxcwj98h6s4b6gslr3cg2wmdv5xmy")))) - (build-system asdf-build-system/sbcl) - (synopsis "JPEG image library for Common Lisp") - (description - "This is a baseline JPEG codec written in Common Lisp. It can be used -for reading and writing JPEG image files.") - (home-page "https://github.com/sharplispers/cl-jpeg") - (license license:bsd-3)))) - -(define-public cl-jpeg - (sbcl-package->cl-source-package sbcl-cl-jpeg)) - -(define-public ecl-cl-jpeg - (sbcl-package->ecl-package sbcl-cl-jpeg)) - -(define-public sbcl-jpeg-turbo - (let ((commit "f79c646cc266c107bdace53572a31664754c6e0c") - (revision "1")) - (package - (name "sbcl-jpeg-turbo") - (version (git-version "1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/shamazmazum/jpeg-turbo/") - (commit commit))) - (file-name (git-file-name "cl-jpeg-turbo" version)) - (sha256 - (base32 "1andd1ibbk3224idnpsnrn96flr5d1wm9ja3di57fs04wn577sag")))) + (base32 "0fdr9nqfmmpxm6hvjdxi1jkclya9xlnrw1yc3cn1m4ww3f50p31m")))) (build-system asdf-build-system/sbcl) - (arguments - (list #:phases - #~(modify-phases %standard-phases - (add-after 'unpack 'fix-lib-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "src/jpeg-turbo.lisp" - (("\"libturbojpeg\\.so\\.0\"") - (string-append "\"" - (search-input-file inputs - "/lib/libturbojpeg.so") - "\"")))))))) - (native-inputs - (list sbcl-fiveam)) (inputs - (list libjpeg-turbo sbcl-cffi)) - (synopsis "Common Lisp wrapper for libjpeg-turbo") - (description - "This is a Common Lisp wrapper for libjpeg-turbo library which provides -TurboJPEG API for compressing and decompressing JPEG images.") - (home-page "https://github.com/shamazmazum/jpeg-turbo/") - (license license:bsd-2)))) - -(define-public cl-jpeg-turbo - (sbcl-package->cl-source-package sbcl-jpeg-turbo)) - -(define-public ecl-cl-jpeg-turbo - (sbcl-package->ecl-package sbcl-jpeg-turbo)) - -(define-public sbcl-png - (let ((commit "11b965fe378fd0561abe3616b18ff03af5179648") - (revision "1")) - (package - (name "sbcl-png") - (version (git-version "0.6" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/ljosa/cl-png") - (commit commit))) - (file-name (git-file-name "cl-png" version)) - (sha256 - (base32 "173hqwpd0rwqf95mfx1h9l9c3i8bb0gvnpspzmmz3g5x3440czy4")) - ;; Patch to fix compiling with SBCL >= 2.1.6. - (patches (search-patches "sbcl-png-fix-sbcl-compatibility.patch")))) - (build-system asdf-build-system/sbcl) + `(("iterate" ,sbcl-iterate) + ("cl-syntax" ,sbcl-cl-syntax))) + (native-inputs + `(("cl-unit" ,sbcl-clunit) + ("check-it" ,sbcl-check-it))) (arguments `(#:phases (modify-phases %standard-phases - (add-after 'unpack 'fix-lib-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "libpng.lisp" - (("\"libpng\"") - (string-append "\"" - (assoc-ref inputs "libpng") - "/lib/libpng\"")))))))) - (inputs - `(("cffi" ,sbcl-cffi) - ("libpng" ,libpng))) - (home-page "https://github.com/ljosa/cl-png") - (synopsis "Read and write PNG file format") - (description - "This package provides a @code{PNG} Common Lisp system to operate with -Portable Network Graphics file format.") - (license license:lgpl2.1)))) - -(define-public ecl-png - (sbcl-package->ecl-package sbcl-png)) - -(define-public cl-png - (sbcl-package->cl-source-package sbcl-png)) - -(define-public sbcl-cl-svg - (let ((commit "1e988ebd2d6e2ee7be4744208828ef1b59e5dcdc") - (revision "1")) - (package - (name "sbcl-cl-svg") - (version (git-version "0.0.3" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/wmannis/cl-svg") - (commit commit))) - (file-name (git-file-name "cl-svg" version)) - (sha256 - (base32 "11rmzimy6j7ln7q5y1h2kw1225rsfb6fpn89qjcq7h5lc8fay0wz")))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/wmannis/cl-svg") - (synopsis "Write SVG file format") + (add-after 'unpack 'fix-build + (lambda _ + (substitute* "clamp.asd" + (("\\(:file \"read\" :depends-on \\(\"aliases\"\\)\\)") + "(:file \"read\" :depends-on (\"aliases\" \"base\"))")) + #t))))) + (home-page "https://github.com/arclanguage/Clamp") + (synopsis "Common Lisp with Arc macros and procedures") (description - "This package provides the @code{CL-SVG} Common Lisp system to produce -Scalable Vector Graphics files.") - (license license:expat)))) - -(define-public ecl-cl-svg - (sbcl-package->ecl-package sbcl-cl-svg)) - -(define-public cl-svg - (sbcl-package->cl-source-package sbcl-cl-svg)) + "Clamp is an attempt to bring the powerful, but verbose, language of +Common Lisp up to the terseness of Arc. -(define-public sbcl-nodgui - (let ((commit "9d0c9731bc2f2b434f0ddabe4b3796432aad8cba") - (revision "1")) - (package - (name "sbcl-nodgui") - (version (git-version "0.6.2.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://codeberg.org/cage/nodgui.git") - (commit commit))) - (file-name (git-file-name "cl-nodgui" version)) - (sha256 - (base32 "0j98mcq0mn3wrlqm3j29pv530q0pkq00sk6liai97an51i1n08g6")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-clunit2)) - (inputs - (list sbcl-alexandria - sbcl-bordeaux-threads - sbcl-cl-colors2 - sbcl-cl-ppcre-unicode - sbcl-cl-unicode - sbcl-esrap - sbcl-flexi-streams - sbcl-jpeg-turbo - sbcl-named-readtables - sbcl-cl-opengl - sbcl-parse-number - sbcl-pngload - sbcl-sdl2 - sbcl-static-vectors - sbcl-trivial-garbage - sbcl-zpng - tk - tklib)) - (arguments - (list #:phases - #~(modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "src/wish-communication.lisp" - (("#-freebsd \"wish\"") - (string-append "#-freebsd \"" - (search-input-file inputs "/bin/wish") - "\"")))))))) - (synopsis "Common Lisp bindings for the Tk GUI toolkit") - (description - "Nodgui (@emph{No Drama GUI}) is a Common Lisp binding for the Tk GUI -toolkit. It also provides a few additional widgets more than the standard Tk -ones.") - (home-page "https://www.autistici.org/interzona/nodgui.html") - (license license:llgpl)))) +There are two parts to Clamp. There is the core of Clamp, which implements +the utilities of Arc that are easily converted from Arc to Common Lisp. The +other part is the \"experimental\" part. It contains features of Arc that are +not so easy to copy (ssyntax, argument destructuring, etc.).") + (license license:artistic2.0)))) -(define-public cl-nodgui - (sbcl-package->cl-source-package sbcl-nodgui)) +(define-public cl-clamp + (sbcl-package->cl-source-package sbcl-clamp)) -(define-public ecl-nodgui - (sbcl-package->ecl-package sbcl-nodgui)) +(define-public ecl-clamp + (sbcl-package->ecl-package sbcl-clamp)) -(define-public sbcl-salza2 +(define-public sbcl-class-options (package - (name "sbcl-salza2") - (version "2.1") + (name "sbcl-class-options") + (version "1.0.1") (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/xach/salza2") - (commit (string-append "release-" version)))) - (file-name (git-file-name name version)) + (url "https://github.com/Hexstream/class-options") + (commit (string-append "v" version)))) + (file-name (git-file-name "cl-class-options" version)) (sha256 - (base32 "1p48lxdibnps5rpyh5cmnk0vc77bmmxb32qdzfz93zadr8wwas10")))) + (base32 "1dkgr1vbrsra44jznzz2bvdf8nlpdrrkjcqrfs8aa7axksda3bqk")))) (build-system asdf-build-system/sbcl) (native-inputs - (list sbcl-chipz sbcl-flexi-streams sbcl-parachute)) + (list sbcl-enhanced-boolean sbcl-parachute)) (inputs - (list sbcl-trivial-gray-streams)) - (synopsis "Common Lisp library for zlib, deflate and gzip compression") + (list sbcl-closer-mop sbcl-enhanced-find-class)) + (home-page "https://www.hexstreamsoft.com/libraries/class-options/") + (synopsis "Accessing defining class and its options during modification") (description - "Salza2 is a Common Lisp library for creating compressed data in the zlib, -deflate, or gzip data formats, described in RFC 1950, RFC 1951, and RFC 1952, -respectively.") - (home-page "https://www.xach.com/lisp/salza2/") - (license license:bsd-2))) + "This package provides easy access to the defining class and its options +during initialization or reinitialization of its subcomponents.") + (license license:unlicense))) -(define-public cl-salza2 - (sbcl-package->cl-source-package sbcl-salza2)) +(define-public cl-class-options + (sbcl-package->cl-source-package sbcl-class-options)) -(define-public ecl-salza2 - (sbcl-package->ecl-package sbcl-salza2)) +(define-public ecl-class-options + (sbcl-package->ecl-package sbcl-class-options)) -(define-public sbcl-origin - (let ((commit "d646134302456408d6d43580bb05299f1695ab8e") - (revision "1")) +(define-public sbcl-classimp + (let ((commit "d82a14c59bc733f89a1ea0b3447ebedddce5756e") + (revision "0")) (package - (name "sbcl-origin") - (version (git-version "2.0.0" revision commit)) + (name "sbcl-classimp") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://git.mfiano.net/mfiano/origin") + (url "https://github.com/3b/classimp") (commit commit))) - (file-name (git-file-name "origin" version)) + (file-name (git-file-name "cl-classimp" version)) (sha256 - (base32 "1n9aszaif3yh8prs5r8v51fbj4r5jd1a048mivd5yij3hplkm82b")))) + (base32 "0pbnz6cf1zb2ayk4kbw0gphjb8nflnjns2rwhv86jz0kf0z1hqha")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-parachute)) + (arguments + (list + #:phases + #~(modify-phases %standard-phases + (add-after 'unpack 'patch-assimp-lib-path + (lambda* (#:key inputs #:allow-other-keys) + (substitute* "library.lisp" + (("libassimp.so.5" _) + (search-input-file inputs "/lib/libassimp.so.5.0.0")))))))) (inputs - (list sbcl-golden-utils sbcl-specialization-store)) - (home-page "https://git.mfiano.net/mfiano/origin") - (synopsis "Common Lisp graphics math library") + (list assimp-5.0 + sbcl-cffi + sbcl-split-sequence)) + (home-page "https://github.com/3b/classimp") + (synopsis "Common Lisp CFFI bindings for Open Asset Import Library") (description - "This is a native Common Lisp graphics math library with an emphasis on -performance and correctness.") + "This package provides CFFI bindings to the @acronym{ASSIMP, Asset +Import} library for Common Lisp.") (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")) +;; FIXME: The cl and ecl packages get the latest version of assimp as +;; dependency instead of the one specified in the sbcl package. Specifying +;; the dependencies explicitly works around the issue. +(define-public cl-classimp + (let ((pkg (sbcl-package->cl-source-package sbcl-classimp))) (package - (name "sbcl-png-read") - (version (git-version "0.3.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Ramarren/png-read") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "0vyczbcwskrygrf1hgrsnk0jil8skmvf1kiaalw5jps4fjrfdkw0")))) - (build-system asdf-build-system/sbcl) + (inherit pkg) (inputs - (list sbcl-babel sbcl-chipz sbcl-iterate)) - (synopsis "PNG decoder for Common Lisp") - (description "This is a Common Lisp library for reading PNG images.") - (home-page "https://github.com/Ramarren/png-read") - (license license:bsd-3)))) - -(define-public cl-png-read - (sbcl-package->cl-source-package sbcl-png-read)) + (list assimp-5.0 + cl-cffi + cl-split-sequence))))) -(define-public ecl-png-read - (sbcl-package->ecl-package sbcl-png-read)) +(define-public ecl-classimp + (let ((pkg (sbcl-package->ecl-package sbcl-classimp))) + (package + (inherit pkg) + (inputs + (list assimp-5.0 + ecl-cffi + ecl-split-sequence))))) -(define-public sbcl-3b-bmfont - (let ((commit "332c2262705f161627fc18add0310451a42799af") - (revision "3")) +(define-public sbcl-clavier + (let ((commit "9b1424eaad131e114a45b400784079124b5e2321") + (revision "1")) (package - (name "sbcl-3b-bmfont") - (version (git-version "0.0.1" revision commit)) + (name "sbcl-clavier") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/3b/3b-bmfont/") + (url "https://github.com/mmontone/clavier") (commit commit))) - (file-name (git-file-name "cl-3b-bmfont" version)) + (file-name (git-file-name "cl-clavier" version)) (sha256 - (base32 "11wnqa1wx9vji6cmxl5m5qnf12mqc6n7d5g8038r1wayq88bxia6")))) + (base32 "1gjd0rhxs2x7gn3fw1hnxivmm4ca4f1wxlg0fqv8fdfabgzsvl5y")))) (build-system asdf-build-system/sbcl) - (arguments - `(#:asd-systems '("3b-bmfont" - "3b-bmfont/common" - "3b-bmfont/json" - "3b-bmfont/text" - "3b-bmfont/xml"))) + (native-inputs (list sbcl-stefil)) (inputs (list sbcl-alexandria - sbcl-cxml - sbcl-flexi-streams - sbcl-jsown - sbcl-parse-number - 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.") + sbcl-chronicity + sbcl-cl-fad + sbcl-cl-ppcre + sbcl-closer-mop)) + (home-page "https://github.com/mmontone/clavier/") + (synopsis "General purpose validation library") + (description "Clavier is a general purpose validation library for +Common Lisp.") (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 cl-clavier + (sbcl-package->cl-source-package sbcl-clavier)) -(define sbcl-3b-bmfont/shinmera - (let ((commit "58e529d24b7799d56b4b3f9c8a953b585d42c7d2") - (revision "1")) - (package (inherit sbcl-3b-bmfont) - (version (git-version "0.0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shinmera/3b-bmfont/") - (commit commit))) - (file-name (git-file-name "3b-bmfont2" version)) - (sha256 - (base32 "17zby669b64rhxhk2szamzdgvispimh6ici05xa6x2vz4rvk71jq"))))))) +(define-public ecl-clavier + (sbcl-package->ecl-package sbcl-clavier)) -(define-public sbcl-sdf - ;; Shinmera's fork required for Alloy. - (let ((commit "e1ab3ac4ea52c0e0119b832f428c71f580b4d83b") - (revision "1")) +(define-public sbcl-claw + (let ((revision "0") + (commit "3cd4a96fca95eb9e8d5d069426694669f81b2250")) (package - (name "sbcl-sdf") - (version (git-version "0.0.1" revision commit)) + (name "sbcl-claw") + (version (git-version "1.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/Shinmera/sdf") + (url "https://github.com/borodust/claw") (commit commit))) - (file-name (git-file-name "sdf" version)) + (file-name (git-file-name "claw" version)) (sha256 - (base32 "1cyq4hkgiw9mnb87ah6xw19cybfs9hfbjvg1ch2mf4cr0ism0nvn")))) + (base32 "146yv0hc4hmk72562ssj2d41143pp84dcbd1h7f4nx1c7hf2bb0d")))) (build-system asdf-build-system/sbcl) (inputs - (list sbcl-zpb-ttf - sbcl-cl-vectors - sbcl-opticl - sbcl-binpack - sbcl-3b-bmfont/shinmera - sbcl-pathname-utils)) - (arguments - `(#:asd-systems '("sdf" "sdf/bmfont"))) - (home-page "https://github.com/Shinmera/sdf") - (synopsis "Signed distance font atlas generator") + (list sbcl-alexandria + sbcl-cffi + sbcl-cl-json + sbcl-cl-ppcre + sbcl-claw-support + sbcl-local-time + sbcl-trivial-features)) + (home-page "https://github.com/borodust/claw") + (synopsis "Autowrapper for Common Lisp") (description - "This library generates -sdf (@url{https://steamcdn-a.akamaihd.net/apps/valve/2007/SIGGRAPH2007_AlphaTestedMagnification.pdf}), -psdf and -msdf (@url{https://github.com/Chlumsky/msdfgen/files/3050967/thesis.pdf}) -atlases.") - (license license:expat)))) - -(define-public ecl-sdf - (sbcl-package->ecl-package sbcl-sdf)) - -(define-public cl-sdf - (sbcl-package->cl-source-package sbcl-sdf)) - -(define-public sbcl-zpng - (package - (name "sbcl-zpng") - (version "1.2.2") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/xach/zpng") - (commit (string-append "release-" version)))) - (file-name (git-file-name name version)) - (sha256 - (base32 "0b3ag3jhl3z7kdls3ahdsdxsfhhw5qrizk769984f4wkxhb69rcm")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-salza2)) - (synopsis "PNG encoder for Common Lisp") - (description "This is a Common Lisp library for creating PNG images.") - (home-page "https://www.xach.com/lisp/zpng/") - (license license:bsd-2))) + "This is a Common Lisp autowrapping facility for quickly creating clean +and lean bindings to C libraries.") + (license license:bsd-2)))) -(define-public cl-zpng - (sbcl-package->cl-source-package sbcl-zpng)) +(define-public cl-claw + (sbcl-package->cl-source-package sbcl-claw)) -(define-public ecl-zpng - (sbcl-package->ecl-package sbcl-zpng)) +(define-public ecl-claw + (sbcl-package->ecl-package sbcl-claw)) -(define-public sbcl-cl-qrencode +(define-public sbcl-claw-support (package - (name "sbcl-cl-qrencode") - (version "0.1.2") + (name "sbcl-claw-support") + (version "1.0.0") (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/jnjcc/cl-qrencode") - (commit (string-append "v" version)))) + (url "https://github.com/borodust/claw-support") + (commit "9a15c8bed04585f45e6a461bcda1b475144dbd0b"))) (file-name (git-file-name name version)) (sha256 - (base32 "1l5k131dchbf6cj8a8xqa731790p01p3qa1kdy2wa9dawy3ymkxr")))) + (base32 "1my2ka7h72ipx5n3b465g6kjkasrhsvhqlijwcg6dhlzs5yygl23")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-lisp-unit)) - (inputs - (list sbcl-zpng)) - (synopsis "QR code encoder for Common Lisp") + (home-page "https://github.com/borodust/claw-support") + (synopsis "Support routines for claw") (description - "This Common Lisp library provides function to make QR codes and to save -them as PNG files.") - (home-page "https://github.com/jnjcc/cl-qrencode") - (license license:gpl2+))) + "This package provides support routines for the @code{claw} Common Lisp +package.") + (license license:expat))) -(define-public cl-qrencode - (sbcl-package->cl-source-package sbcl-cl-qrencode)) +(define-public cl-claw-support + (sbcl-package->cl-source-package sbcl-claw-support)) -(define-public ecl-cl-qrencode - (sbcl-package->ecl-package sbcl-cl-qrencode)) +(define-public ecl-claw-support + (sbcl-package->ecl-package sbcl-claw-support)) -(define-public sbcl-hdf5-cffi - (let ((commit "5b5c88f191e470e4fe96b462334e3ce0806eed5c") - (revision "1")) +(define-public sbcl-claw-utils + (let ((revision "0") + (commit "efe25016501973dc369f067a64c7d225802bc56f")) (package - (name "sbcl-hdf5-cffi") - (version (git-version "1.8.18" revision commit)) + (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/hdfgroup/hdf5-cffi") + (url "https://github.com/borodust/claw-utils") (commit commit))) - (file-name (git-file-name "cl-hdf5-cffi" version)) + (file-name (git-file-name "claw-utils" version)) (sha256 - (base32 "0vda3075423xz83qky998lpac5b04dwfv7bwgh9jq8cs5v0zrxjf")))) + (base32 "01df3kyf2qs3czi332dnz2s35x2j0fq46vgmsw7wjrrvnqc22mk5")))) (build-system asdf-build-system/sbcl) - (synopsis "Common Lisp bindings for the HDF5 library") - (description - "@code{hdf5-cffi} is a CFFI wrapper for the HDF5 library.") - (home-page "https://github.com/hdfgroup/hdf5-cffi") - (license (license:non-copyleft - (string-append "https://github.com/HDFGroup/hdf5-cffi/raw/" - commit - "/LICENSE"))) (inputs - (list hdf5-1.10 sbcl-cffi)) - (native-inputs - (list sbcl-fiveam)) - (arguments - (list #:phases - #~(modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "src/library.lisp" - (("libhdf5.so") - (search-input-file inputs "/lib/libhdf5.so"))))) - (add-after 'fix-paths 'fix-newer-hdf5-compatibility - (lambda _ - (substitute* (list "src/h5-grovel.lisp" - "src/h5a-grovel.lisp" - "src/h5d-grovel.lisp" - "src/h5f-grovel.lisp" - "src/h5g-grovel.lisp" - "src/h5i-grovel.lisp" - "src/h5l-grovel.lisp" - "src/h5o-grovel.lisp" - "src/h5p-grovel.lisp" - "src/h5pl-grovel.lisp" - "src/h5r-grovel.lisp" - "src/h5s-grovel.lisp" - "src/h5t-grovel.lisp" - "src/h5z-grovel.lisp") - (("_H5private_H") - "H5private_H")))) - (add-after 'unpack 'fix-dependencies - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "hdf5-cffi.asd" - ((":depends-on \\(:cffi\\)") - ":depends-on (:cffi :cffi-grovel)")) - (substitute* "hdf5-cffi.test.asd" - ((":depends-on \\(:cffi :hdf5-cffi") - ":depends-on (:cffi :cffi-grovel :hdf5-cffi")))))))))) - -(define-public cl-hdf5-cffi - (sbcl-package->cl-source-package sbcl-hdf5-cffi)) - -(define-public ecl-hdf5-cffi - (sbcl-package->ecl-package sbcl-hdf5-cffi)) - -(define-public sbcl-history-tree - (package - (name "sbcl-history-tree") - (version "0.1.2") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/atlas-engineer/history-tree") - (commit version))) - (file-name (git-file-name "cl-history-tree" version)) - (sha256 - (base32 "1n3q6aqh0wm24pksj8371j5iinxpzy2kcnz97kmpndm1yhv4x5f2")))) - (build-system asdf-build-system/sbcl) - (inputs - (list - sbcl-alexandria - sbcl-custom-hash-table - sbcl-local-time - sbcl-nclasses - sbcl-trivial-package-local-nicknames)) - (native-inputs (list sbcl-lisp-unit2)) - (home-page "https://github.com/atlas-engineer/history-tree") - (synopsis "Store the history of a browser's visited paths") - (description - "This data structure can be used to store the history of visited paths or -URLs with a file or web browser, in a way that no “forward” element is ever -forgotten. - -The history tree is “global” in the sense that multiple owners (e.g. tabs) can -have overlapping histories. On top of that, an owner can spawn another one, -starting from one of its nodes (typically when you open a URL in a new tab).") - (license license:bsd-3))) - -(define-public cl-history-tree - (sbcl-package->cl-source-package sbcl-history-tree)) - -(define-public ecl-history-tree - (sbcl-package->ecl-package sbcl-history-tree)) - -(define-public sbcl-cl-randist - (package - (name "sbcl-cl-randist") - (version "0.4.2") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/lvaruzza/cl-randist") - (commit "f088a54b540a7adefab7c04094a6103f9edda3d0"))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "0l8hyd6nbxb7f50vyxz3rbbm7kgr1fnadc40jywy4xj5vi5kpj5g")))) - (build-system asdf-build-system/sbcl) - (synopsis "Random distributions for Common Lisp") - (description - "Manual translation from C to Common Lisp of some random number -generation functions from the GSL library.") - (home-page "https://github.com/lvaruzza/cl-randist") - (license license:bsd-2) - (arguments - `(#:tests? #f)))) + (list sbcl-alexandria sbcl-cffi sbcl-claw)) + (home-page "https://github.com/borodust/claw-utils") + (synopsis "Utilities for easier autowrapping") + (description + "This Common Lisp library contains various handy utilities to help +autowrapping with @code{claw}.") + (license license:expat)))) -(define-public cl-randist - (sbcl-package->cl-source-package sbcl-cl-randist)) +(define-public cl-claw-utils + (sbcl-package->cl-source-package sbcl-claw-utils)) -(define-public ecl-cl-randist - (sbcl-package->ecl-package sbcl-cl-randist)) +(define-public ecl-claw-utils + (sbcl-package->ecl-package sbcl-claw-utils)) -(define-public sbcl-float-features - (let ((commit "c1f86aea91cfaa3aa59799162be23ef8a12b199d") - (revision "2")) +(define-public sbcl-clawk + (let ((commit "3a91634df686417114044a98c063cbe76bfac7b6")) (package - (name "sbcl-float-features") - (version (git-version "1.0.0" revision commit)) + (name "sbcl-clawk") + (version (git-version "4" "1" commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/Shinmera/float-features") + (url "https://github.com/sharplispers/clawk") (commit commit))) - (file-name (git-file-name "float-features" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "0vqm9xhn2i4vbjrxnp4hr1l3lydjflhjykdz6cmqg2j48c5kh3g3")))) + (base32 "1ph3xjqilvinvgr9q3w47zxqyz1sqnq030nlx7kgkkv8j3bnqk7a")))) (build-system asdf-build-system/sbcl) - (synopsis "Common Lisp IEEE float portability library") - (description - "Portability library for IEEE float features that are not -covered by the Common Lisp standard.") - (home-page "https://github.com/Shinmera/float-features") - (license license:zlib) (inputs - `(("documentation-utils" ,sbcl-documentation-utils))) - (arguments - `(#:tests? #f))))) - -(define-public cl-float-features - (sbcl-package->cl-source-package sbcl-float-features)) - -(define-public ecl-float-features - (sbcl-package->ecl-package sbcl-float-features)) - -(define-public sbcl-function-cache - (package - (name "sbcl-function-cache") - (version "1.0.3") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/AccelerationNet/function-cache") - (commit "6a5ada401e57da2c8abf046f582029926e61fce8"))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "000vmd3f5rx5hs9nvphfric0gkzaadns31c6mxaslpv0k7pkrmc6")))) - (build-system asdf-build-system/sbcl) - (synopsis "Function caching / memoization library for Common Lisp") - (description - "A common lisp library that provides extensible function result -caching based on arguments (an expanded form of memoization).") - (home-page "https://github.com/AccelerationNet/function-cache") - (license - (license:non-copyleft - "https://github.com/AccelerationNet/function-cache/blob/master/README.md")) - (inputs - `(("alexandria" ,sbcl-alexandria) - ("cl-interpol" ,sbcl-cl-interpol) - ("iterate" ,sbcl-iterate) - ("symbol-munger" ,sbcl-symbol-munger) - ("closer-mop" ,sbcl-closer-mop))) - (arguments - `(#:tests? #f)))) + (list sbcl-regex)) + (home-page "https://github.com/sharplispers/clawk") + (synopsis "Common Lisp AWK") + (description + "CLAWK is an AWK implementation embedded into Common Lisp.") + (license license:bsd-2)))) -(define-public cl-function-cache - (sbcl-package->cl-source-package sbcl-function-cache)) +(define-public cl-clawk + (sbcl-package->cl-source-package sbcl-clawk)) -(define-public ecl-function-cache - (sbcl-package->ecl-package sbcl-function-cache)) +(define-public ecl-clawk + (sbcl-package->ecl-package sbcl-clawk)) -(define-public sbcl-cache-while - (let ((commit "38e9ffbdb2c894670c366c1e5802ffcc8cfd43a7") - (revision "1")) +(define-public sbcl-clesh + (let ((commit "44e96e04a72e5bc006dc4eb02ce8962348dd4a11")) (package - (name "sbcl-cache-while") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-clesh") + (version (git-version "0.0.0" "1" commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/charje/cache-while") + (url "https://github.com/Neronus/Clesh") (commit commit))) - (file-name (git-file-name "cache-while" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "1qil68rfn5irmkb0jk1f6g1zy80wgc3skl8cr4rfgh7ywgm5izx3")))) + (base32 "012ry02djnqyvvs61wbbqj3saz621w2l9gczrywdxhi5p4ycx318")))) (build-system asdf-build-system/sbcl) - (home-page "https://github.com/charje/cache-while") - (synopsis "Temporary / one-time caching macro for Common Lisp") + (inputs + (list sbcl-trivial-shell sbcl-named-readtables)) + (home-page "https://github.com/Neronus/Clesh") + (synopsis "Embed shell code in Common Lisp") (description - "This is a Common Lisp macro for defining temporary caches that -invalidate based on expressions evaluating to different values.") - (license license:llgpl)))) + "This is a very short and simple program, written in Common Lisp, that +extends Common Lisp to embed shell code in a manner similar to Perl's +backtick. It has been forked from SHELISP.") + (license license:bsd-2)))) -(define-public cl-cache-while - (sbcl-package->cl-source-package sbcl-cache-while)) +(define-public cl-clesh + (sbcl-package->cl-source-package sbcl-clesh)) -(define-public ecl-cache-while - (sbcl-package->ecl-package sbcl-cache-while)) +(define-public ecl-clesh + (sbcl-package->ecl-package sbcl-clesh)) -(define-public sbcl-type-r - (let ((commit "83c89e38f2f7a7b16f1012777ecaf878cfa6a267") +(define-public sbcl-clinenoise + (let ((commit "46e21f99d06a55d93eaa382cf652d55d457032ef") (revision "1")) (package - (name "sbcl-type-r") + (name "sbcl-clinenoise") (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/guicho271828/type-r") + (url "https://github.com/jasom/clinenoise") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "clinenoise" version)) (sha256 - (base32 - "1arsxc2539rg8vbrdirz4xxj1b06mc6g6rqndz7a02g127qvk2sm")))) + (base32 "0ydlirfk4dbpqqjwwph99v5swcrhd8v9g8q24fvs35wn2vm08lh1")))) (build-system asdf-build-system/sbcl) - (synopsis "Parser interface for Common Lisp built-in compound types") - (description - "Collections of accessor functions and patterns to access -the elements in compound type specifier, e.g. @code{dimensions} in -@code{(array element-type dimensions)}") - (home-page "https://github.com/guicho271828/type-r") - (license license:lgpl3+) (inputs - `(("trivia" ,sbcl-trivia) - ("alexandria" ,sbcl-alexandria))) - (native-inputs - (list sbcl-fiveam))))) + (list sbcl-alexandria sbcl-cffi sbcl-split-sequence)) + (home-page "https://github.com/jasom/clinenoise") + (synopsis "Port of linenoise to Common Lisp") + (description + "This package provides a trivial line-input library for VT-like +terminals.") + (license license:bsd-2)))) -(define-public cl-type-r - (sbcl-package->cl-source-package sbcl-type-r)) +(define-public cl-clinenoise + (sbcl-package->cl-source-package sbcl-clinenoise)) -(define-public ecl-type-r - (sbcl-package->ecl-package sbcl-type-r)) +(define-public ecl-clinenoise + (sbcl-package->ecl-package sbcl-clinenoise)) -(define-public sbcl-trivialib-type-unify - (let ((commit "62492ebf04db567dcf435ae84c50b7b8202ecf99") - (revision "1")) +(define-public sbcl-clingon + (let ((commit "379fc41e7b3977661f1454cf35acdbfae046d40d") + (revision "0")) (package - (name "sbcl-trivialib-type-unify") - (version (git-version "0.1" revision commit)) + (name "sbcl-clingon") + (version (git-version "0.5.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/guicho271828/trivialib.type-unify") + (url "https://github.com/dnaeon/clingon") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-clingon" version)) (sha256 - (base32 - "1bkyfzbwv75p50zp8n1n9rh2r29pw3vgz91gmn2gzzkyq3khj1vh")))) + (base32 "11p9lplx0fc5ghx601i150vrd46zdbvw0hfrbrrrdqplxaqpywq5")))) (build-system asdf-build-system/sbcl) - (synopsis "Common Lisp type unification") - (description - "Unifies a parametrized type specifier against an actual type specifier. -Importantly, it handles complicated array-subtypes and number-related types -correctly.") - (home-page "https://github.com/guicho271828/trivialib.type-unify") - (license license:lgpl3+) - (inputs - `(("alexandria" ,sbcl-alexandria) - ("trivia" ,sbcl-trivia) - ("introspect-environment" ,sbcl-introspect-environment) - ("type-r" ,sbcl-type-r))) (native-inputs - (list sbcl-fiveam)) - (arguments - `(#:asd-systems '("trivialib.type-unify")))))) + (list sbcl-rove)) + (inputs + (list sbcl-bobbin + sbcl-cl-reexport + sbcl-split-sequence + sbcl-with-user-abort)) + (home-page "https://github.com/dnaeon/clingon") + (synopsis "Command-line option parsing library for Common Lisp") + (description + "@code{clingon} is a command-line option parsing library for Common +Lisp. Its features include: +@itemize +@item Support for subcommands +@item Support for command aliases +@item Support for short and long options +@item Related options may be grouped into categories +@item Short options may be collapsed into a single argument, as in +@option{-xyz} +@item Long options support the notations @option{--long-opt arg} and +@option{--long-opt=arg} +@item Automatic generation of help/usage information for commands and +subcommands +@item Out-of-the-box support for @option{--version} and @option{--help} +@item Support for various kinds of options including string, integer, +boolean, switch, enum, list, counter, filepath, etc. +@item Subcommands can look up global options defined in parent commands +@item Support for required options +@item Options can be initialized via environment variables +@item Single interface for creating options using @code{CLINGON:MAKE-OPTION} +@item Generate documentation for your command-line application +@item Support for @code{pre-hook} and @code{post-hook} actions for commands, +which allow invoking functions before and after the respective handler of the +command is executed +@item Support for Bash and Zsh completions +@item Extensibility, so if you don't find something you need you can extend it +by developing a new option kind, or even a new mechanism for initializing +options, e.g., by looking up an external key/value store +@end itemize") + (license license:bsd-2)))) -(define-public cl-trivialib-type-unify - (sbcl-package->cl-source-package sbcl-trivialib-type-unify)) +(define-public cl-clingon + (sbcl-package->cl-source-package sbcl-clingon)) -(define-public ecl-trivialib-type-unify - (sbcl-package->ecl-package sbcl-trivialib-type-unify)) +(define-public ecl-clingon + (sbcl-package->ecl-package sbcl-clingon)) -(define-public sbcl-cl-unification - (let ((commit "01079f34d197495880aa49ab727d63774d83035c") +(define-public sbcl-clip + (let ((commit "7afa68702fbb99c47ed115ea0faccd97a29d9b2e") (revision "1")) (package - (name "sbcl-cl-unification") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-clip") + (version (git-version "0.7.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://gitlab.common-lisp.net/cl-unification/cl-unification") + (url "https://github.com/shinmera/clip") (commit commit))) - (file-name (git-file-name "cl-unification" version)) + (file-name (git-file-name "clip" version)) (sha256 - (base32 "0nhqamn3qgg38i6aw2pshffdwr2hzslycg8ficmn333gw0h9rf4g")))) + (base32 "13kkajkva2shm19fvn4yashsw18l6imv2rmy3hmpcky7g5ay7bv3")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-ptester)) (inputs - (list sbcl-cl-ppcre)) - (home-page "https://common-lisp.net/project/cl-unification/") - (synopsis "Unification framework for Common Lisp") + (list sbcl-array-utils sbcl-lquery)) + (home-page "https://shinmera.github.io/clip/") + (synopsis "Common Lisp HTML templating engine") (description - "This package provides a framework to unify arbitrary -Common Lisp objects while constructing bindings for placeholders -(unification variables) in a template sublanguage.") - (license license:bsd-0)))) + "Clip is an attempt at a templating library that allows you to write +templates in a way that is both accessible to direct webdesign and +flexible. The main idea is to incorporate transformation commands into an HTML +file through tags and attributes. Clip is heavily dependent on Plump and +lQuery.") + (license license:zlib)))) -(define-public ecl-cl-unification - (let ((pkg (sbcl-package->ecl-package sbcl-cl-unification))) - (package - (inherit pkg) - (arguments - (substitute-keyword-arguments (package-arguments pkg) - ;; The tests fail on ECL with: - ;; "In MAKE-ARRAY: the elements in :INITIAL-CONTENTS do not match - ;; the array dimensions." - ((#:tests? _ #f) #f)))))) +(define-public cl-clip + (sbcl-package->cl-source-package sbcl-clip)) -(define-public cl-unification - (sbcl-package->cl-source-package sbcl-cl-unification)) +(define-public ecl-clip + (sbcl-package->ecl-package sbcl-clip)) -(define-public sbcl-specialized-function - (let ((commit "5e2b04432bdf728496e6ff7227f210f845af7247") - (revision "3")) +(define-public sbcl-clml + (let ((commit "95505b54c8c7b4b27f500c3be97fa5732f4b51a8") + (revision "0")) (package - (name "sbcl-specialized-function") - (version (git-version "0.1" revision commit)) + (name "sbcl-clml") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/numcl/specialized-function") + (url "https://github.com/mmaul/clml") (commit commit))) - (file-name (git-file-name "specialized-function" version)) + (file-name (git-file-name "clml" version)) (sha256 - (base32 "19hfgc83b7as630r1w9r8yl0v6xq3dn01vcrl0bd4pza5hgjn4la")))) + (base32 "006pii59nmpc61n7p7h8ha5vjg6x0dya327i58z0rnvxs249h345")) + ;; TODO: Remove this when the patch has been merged upstream. + (patches (search-patches "sbcl-clml-fix-types.patch")))) (build-system asdf-build-system/sbcl) - (synopsis "Julia-like dispatch for Common Lisp") - (description - "This library is part of NUMCL. It provides a macro -@code{SPECIALIZED} that performs a Julia-like dispatch on the arguments, -lazily compiling a type-specific version of the function from the same -code. The main target of this macro is speed.") - (home-page "https://github.com/numcl/specialized-function") - (license license:lgpl3+) (inputs - `(("alexandria" ,sbcl-alexandria) - ("iterate" ,sbcl-iterate) - ("lisp-namespace" ,sbcl-lisp-namespace) - ("trivia" ,sbcl-trivia) - ("trivial-cltl2" ,sbcl-trivial-cltl2) - ("type-r" ,sbcl-type-r))) - (native-inputs - (list sbcl-fiveam))))) - -(define-public cl-specialized-function - (sbcl-package->cl-source-package sbcl-specialized-function)) - -(define-public ecl-specialized-function - (sbcl-package->ecl-package sbcl-specialized-function)) - -(define-public sbcl-conduit-packages - (package - (name "sbcl-conduit-packages") - (version "2.0.0") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/tfeb/conduit-packages") - (commit (string-append "v" version)))) - (file-name (git-file-name "cl-conduit-packages" version)) - (sha256 - (base32 "1n783in84mrk9lnc3nshwsgxhb8y0dk6ys9z6jlxkv0jpjxhpjjc")))) - (build-system asdf-build-system/sbcl) - (arguments '(#:asd-systems '("org.tfeb.conduit-packages"))) - (synopsis "Conduit packages for Common Lisp") - (description "This library defines a way of treating Common Lisp -packages as conduits which can sit between one or more implementation -packages and users of those packages.") - (home-page "https://github.com/tfeb/conduit-packages/") - (license license:expat))) - -(define-public cl-conduit-packages - (sbcl-package->cl-source-package sbcl-conduit-packages)) + (list sbcl-alexandria + sbcl-array-operations + sbcl-cl-fad + sbcl-cl-ppcre + sbcl-drakma + sbcl-introspect-environment + sbcl-iterate + sbcl-lparallel + sbcl-parse-number + sbcl-split-sequence + sbcl-trivial-garbage)) + (synopsis "Common Lisp machine learning library") + (description + "CLML (Common Lisp Machine Learning) is a high performance and large +scale statistical machine learning package") + (home-page "https://mmaul.github.io/clml/") + (license license:llgpl)))) -(define-public ecl-conduit-packages - (sbcl-package->ecl-package sbcl-conduit-packages)) +(define-public cl-clml + (sbcl-package->cl-source-package sbcl-clml)) -(define-public sbcl-constantfold - (let ((commit "0ff1d97a3fbcb89264f6a2af6ce62b73e7b421f4") - (revision "1")) +(define-public sbcl-clobber + (let ((commit "212721c24a8bb792714314ba52dfe818641f2e98") + (revision "0")) (package - (name "sbcl-constantfold") - (version (git-version "0.1" revision commit)) + (name "sbcl-clobber") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/numcl/constantfold") + (url "https://github.com/robert-strandh/Clobber") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-clobber" version)) (sha256 - (base32 - "153h0569z6bff1qbad0bdssplwwny75l7ilqwcfqfdvzsxf9jh06")))) + (base32 "0pqzfn2wqbzzwlwc3l84iv3i3wa9zfgnh14mq67h9qkib8wjzx3n")))) (build-system asdf-build-system/sbcl) - (synopsis "Support library for numcl") + (home-page "https://github.com/robert-strandh/Clobber") + (synopsis "Common Lisp Library for transaction-oriented databases") (description - "Support library for numcl. Registers a function as an -additional form that is considered as a candidate for a constant.") - (home-page "https://github.com/numcl/constantfold") - (license license:lgpl3+) - (inputs - `(("trivia" ,sbcl-trivia) - ("alexandria" ,sbcl-alexandria) - ("iterate" ,sbcl-iterate) - ("lisp-namespace" ,sbcl-lisp-namespace))) - (native-inputs - (list sbcl-fiveam))))) + "CLOBBER is an alternative to so-called @emph{object prevalence}, and in +particular to @code{cl-prevalence}. Clobber is both simpler, more flexible, and +more robust than systems based on object prevalence.") + (license license:bsd-2)))) -(define-public cl-constantfold - (sbcl-package->cl-source-package sbcl-constantfold)) +(define-public cl-clobber + (sbcl-package->cl-source-package sbcl-clobber)) -(define-public ecl-constantfold - (sbcl-package->ecl-package sbcl-constantfold)) +(define-public ecl-clobber + (sbcl-package->ecl-package sbcl-clobber)) -(define-public sbcl-gtype - (let ((commit "2442e32485635525af278ebd8fa69a27d5b8cf18") - (revision "2")) - (package - (name "sbcl-gtype") - (version (git-version "0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/numcl/gtype") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "0hbkfdw00v7bsa6zbric34p5w6hfwxycccg8wc2faq0cxhsvpv9h")))) - (build-system asdf-build-system/sbcl) - (synopsis "C++/Julia-like parametric types in Common Lisp") - (description - "Support library for numcl that provides Julia-like runtime parametric -type correctness in Common Lisp. It is based on CLtL2 extensions.") - (home-page "https://github.com/numcl/gtype") - (license license:lgpl3+) - (inputs - `(("trivialib.type-unify" ,sbcl-trivialib-type-unify) - ("trivial-cltl2" ,sbcl-trivial-cltl2) - ("trivia" ,sbcl-trivia) - ("alexandria" ,sbcl-alexandria) - ("iterate" ,sbcl-iterate) - ("type-r" ,sbcl-type-r))) - (native-inputs - (list sbcl-fiveam))))) +(define-public sbcl-clog + (package + (name "sbcl-clog") + (version "1.2") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/rabbibotton/clog") + (commit (string-append "v" version)))) + (file-name (git-file-name "cl-clog" version)) + (sha256 + (base32 "0f4i6571nm0j704zgnh60sc9slifs11byb2gs8gamqjcfh931dap")))) + (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-3bmd + sbcl-alexandria + sbcl-bordeaux-threads + sbcl-cl-ppcre + sbcl-cl-sqlite + sbcl-cl-template + sbcl-clack + sbcl-closer-mop + sbcl-colorize + sbcl-dbi + sbcl-hunchentoot + sbcl-lack + sbcl-mgl-pax + sbcl-parse-float + sbcl-quri + sbcl-trivial-open-browser + sbcl-websocket-driver)) + (arguments + '(#:asd-systems '("clog" "clog/docs" "clog/tools") + #:phases (modify-phases %standard-phases + (add-after 'unpack 'fix-symbol-name + (lambda _ + (substitute* "source/clog-docs.lisp" + (("clog:@CLOG-MANUAL") + "clog::@CLOG_MANUAL"))))))) + (home-page "https://github.com/rabbibotton/clog") + (synopsis "Common Lisp Omnificent GUI") + (description + "This package provides a Common Lisp web framework for building GUI +applications. CLOG can take the place, or work along side, most cross platform +GUI frameworks and website frameworks. The CLOG package starts up the +connectivity to the browser or other websocket client (often a browser embedded +in a native template application).") + (license license:bsd-3))) -(define-public cl-gtype - (sbcl-package->cl-source-package sbcl-gtype)) +(define-public cl-clog + (sbcl-package->cl-source-package sbcl-clog)) -(define-public ecl-gtype - (let ((pkg (sbcl-package->ecl-package sbcl-gtype))) - (package - (inherit pkg) - (arguments - (substitute-keyword-arguments (package-arguments pkg) - ;; The tests fail on ECL with a COMPILE-FILE-ERROR for t/package.lisp. - ((#:tests? _ #f) #f)))))) +(define-public ecl-clog + (sbcl-package->ecl-package sbcl-clog)) -(define-public sbcl-numcl - (let ((commit "a28f612d072e5f93137584de5155a42243b3bd6b") - (revision "3")) +(define-public sbcl-clop + (let ((commit "c0c3fe7efa5ac95ba1644febfb2c2acab757fcda") + (revision "0")) (package - (name "sbcl-numcl") - (version (git-version "0.2.0" revision commit)) + (name "sbcl-clop") + ;; ASD file indicates 0.1.0, but changelog 1.0.1. + (version (git-version "1.0.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/numcl/numcl") + (url "https://github.com/sheepduke/clop") (commit commit))) - (file-name (git-file-name "numcl" version)) + (file-name (git-file-name "cl-clop" version)) (sha256 - (base32 "15m4spbgayawnw5jjz04zfp0jnk9g6hgq5fmr648hzjzj50j1d78")))) + (base32 "1q7rlizr8gcbfz4a9660gdbw7d2zbld18akjpibg54j7jh5kb8gc")))) (build-system asdf-build-system/sbcl) - (arguments - `(;; Tests often fail because they require a dynamic-space-size much - ;; bigger than the default one. Disable them for now. - #:tests? #f)) (native-inputs (list sbcl-fiveam)) (inputs - `(("alexandria" ,sbcl-alexandria) - ("cl-randist" ,sbcl-cl-randist) - ("constantfold" ,sbcl-constantfold) - ("float-features" ,sbcl-float-features) - ("function-cache" ,sbcl-function-cache) - ("gtype" ,sbcl-gtype) - ("iterate" ,sbcl-iterate) - ("lisp-namespace" ,sbcl-lisp-namespace) - ("specialized-function" ,sbcl-specialized-function) - ("trivia" ,sbcl-trivia) - ("type-r" ,sbcl-type-r))) - (home-page "https://numcl.github.io/numcl/") - (synopsis "Numpy clone in Common Lisp") + (list sbcl-alexandria + sbcl-cl-str + sbcl-esrap + sbcl-local-time + sbcl-parse-number)) + (home-page "https://github.com/sheepduke/clop") + (synopsis "TOML parser for Common Lisp") (description - "This package is a Python Numpy clone implemented in pure Common Lisp.") - (license license:lgpl3+)))) + "Clop is a Common Lisp library for parsing strings in the TOML +configuration file format.") + (license license:expat)))) -(define-public cl-numcl - (sbcl-package->cl-source-package sbcl-numcl)) +(define-public cl-clop + (sbcl-package->cl-source-package sbcl-clop)) -(define-public ecl-numcl - (sbcl-package->ecl-package sbcl-numcl)) +(define-public ecl-clop + (sbcl-package->ecl-package sbcl-clop)) -(define-public sbcl-pzmq - (let ((commit "6f7b2ca02c23ea53510a9b0e0f181d5364ce9d32") - (revision "2")) +(define-public sbcl-closer-mop + (let ((commit "7b86f2add029208ebc74ec6a41c2ccfd3c382dbc") + (revision "3")) (package - (name "sbcl-pzmq") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-closer-mop") + (version (git-version "1.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/orivej/pzmq") + (url "https://github.com/pcostanza/closer-mop") (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "19mdhxhzzghlmff1fic4chg5iz0psglkim09z6dgpijm26biny05")))) - (build-system asdf-build-system/sbcl) - (native-inputs - `(("bordeaux-threads" ,sbcl-bordeaux-threads) - ("fiveam" ,sbcl-fiveam) - ("let-plus" ,sbcl-let-plus))) - (inputs - `(("cffi" ,sbcl-cffi) - ("zeromq" ,zeromq))) - (arguments - `(#:phases (modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "c-api.lisp" - (("\"libzmq") - (string-append "\"" - (assoc-ref inputs "zeromq") - "/lib/libzmq"))) - #t))))) - (synopsis "Common Lisp bindings for the ZeroMQ library") - (description "This Common Lisp library provides bindings for the ZeroMQ -lightweight messaging kernel.") - (home-page "https://github.com/orivej/pzmq") - (license license:unlicense)))) - -(define-public cl-pzmq - (sbcl-package->cl-source-package sbcl-pzmq)) - -(define-public ecl-pzmq - (sbcl-package->ecl-package sbcl-pzmq)) - -(define-public sbcl-clss - (let ((revision "2") - (commit "f62b849189c5d1be378f0bd3d403cda8d4fe310b")) - (package - (name "sbcl-clss") - (version (git-version "0.3.1" revision commit)) - (source - (origin - (method git-fetch) - (uri - (git-reference - (url "https://github.com/Shinmera/clss") - (commit commit))) - (sha256 - (base32 "1033dchpanhcgxl5qfhr80aw9adbp9bvllhzvvy5p9mrfnidd1fv")) - (file-name (git-file-name name version)))) - (inputs - (list sbcl-array-utils sbcl-plump)) - (build-system asdf-build-system/sbcl) - (synopsis "DOM tree searching engine based on CSS selectors") - (description "CLSS is a DOM traversal engine based on CSS -selectors. It makes use of the Plump-DOM and is used by lQuery.") - (home-page "https://github.com/Shinmera/clss") - (license license:zlib)))) - -(define-public cl-clss - (sbcl-package->cl-source-package sbcl-clss)) - -(define-public ecl-clss - (sbcl-package->ecl-package sbcl-clss)) - -(define-public sbcl-lquery - (let ((revision "1") - (commit "8048111c6b83956daa632e7a3ffbd8c9c203bd8d")) - (package - (name "sbcl-lquery") - (version (git-version "3.2.1" revision commit)) - (source - (origin - (method git-fetch) - (uri - (git-reference - (url "https://github.com/Shinmera/lquery") - (commit commit))) (sha256 - (base32 "0520mcpxc2d6fdm8z61arpgd2z38kan7cf06qs373n5r64rakz6w")) - (file-name (git-file-name name version)))) - (native-inputs - (list sbcl-fiveam)) - (inputs - (list sbcl-array-utils sbcl-form-fiddle sbcl-plump sbcl-clss)) + (base32 "1fzxdpq873rpagmj3h9bgv7n95h4p03pnxrklbxp06sxb26xyi16")) + (file-name (git-file-name "cl-closer-mop" version )))) (build-system asdf-build-system/sbcl) - (synopsis "Library to allow jQuery-like HTML/DOM manipulation") - (description "@code{lQuery} is a DOM manipulation library written in -Common Lisp, inspired by and based on the jQuery syntax and -functions. It uses Plump and CLSS as DOM and selector engines. The -main idea behind lQuery is to provide a simple interface for crawling -and modifying HTML sites, as well as to allow for an alternative -approach to templating.") - (home-page "https://github.com/Shinmera/lquery") - (license license:zlib)))) + (home-page "https://github.com/pcostanza/closer-mop") + (synopsis "Rectifies absent or incorrect CLOS MOP features") + (description "Closer to MOP is a compatibility layer that rectifies many +of the absent or incorrect CLOS MOP features across a broad range of Common +Lisp implementations.") + (license license:expat)))) -(define-public cl-lquery - (sbcl-package->cl-source-package sbcl-lquery)) +(define-public cl-closer-mop + (sbcl-package->cl-source-package sbcl-closer-mop)) -(define-public ecl-lquery - (sbcl-package->ecl-package sbcl-lquery)) +(define-public ecl-closer-mop + (sbcl-package->ecl-package sbcl-closer-mop)) -(define-public sbcl-cl-mysql - (let ((commit "ab56c279c1815aec6ca0bfe85164ff7e85cfb6f9") - (revision "1")) +(define-public sbcl-clostrum + (let ((commit "c85d38bde9d093f1f132574e9b98b8d64683cd51") + (revision "0")) (package - (name "sbcl-cl-mysql") - (version (git-version "0.1" revision commit)) + (name "sbcl-clostrum") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/hackinghat/cl-mysql") + (url "https://github.com/s-expressionists/Clostrum") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-clostrum" commit)) (sha256 - (base32 "0dg5ynx2ww94d0qfwrdrm7plkn43h64hs4iiq9mj2s1s4ixnp3lr")))) + (base32 "10alsdnpzbgic75xghwjp414sqwg4npvp69zn0r4l8ms0ki9zr1x")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-stefil)) - (inputs - `(("cffi" ,sbcl-cffi) - ("mariadb-lib" ,mariadb "lib"))) - (arguments - `(#:tests? #f ; TODO: Tests require a running server - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "system.lisp" - (("libmysqlclient_r" all) - (string-append (assoc-ref inputs "mariadb-lib") - "/lib/" - all))) - #t))))) - (synopsis "Common Lisp wrapper for MySQL") + (native-inputs (list sbcl-fiveam)) + (home-page "https://github.com/s-expressionists/Clostrum") + (synopsis "First Class Global Environments") (description - "@code{cl-mysql} is a Common Lisp implementation of a MySQL wrapper.") - (home-page "http://www.hackinghat.com/index.php/cl-mysql") - (license license:expat)))) - -(define-public cl-mysql - (sbcl-package->cl-source-package sbcl-cl-mysql)) - -(define-public ecl-cl-mysql - (sbcl-package->ecl-package sbcl-cl-mysql)) - -(define-public sbcl-postmodern - (package - (name "sbcl-postmodern") - (version "1.32.9") - (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 "137jci4hn4vlxf48y39k0di27kc89kvxy3brmn3vl9xq56sy6mhz")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list 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 -@item Efficient communication with the database server without need for -foreign libraries. -@item Support for UTF-8 on Unicode-aware Lisp implementations. -@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 - -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))) + "This package provides first-class global environments for +Common Lisp.") + (license license:bsd-2)))) -(define-public cl-postmodern - (sbcl-package->cl-source-package sbcl-postmodern)) +(define-public cl-clostrum + (sbcl-package->cl-source-package sbcl-clostrum)) -(define-public ecl-postmodern - (package - (inherit (sbcl-package->ecl-package sbcl-postmodern)) - (arguments - `(#:tests? #f - #: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" - ((":or :sbcl :allegro :ccl :clisp" all) - (string-append all " :ecl"))) - #t))))))) +(define-public ecl-clostrum + (sbcl-package->ecl-package sbcl-clostrum)) -(define-public sbcl-db3 - (let ((commit "38e5ad35f025769fb7f8dcdc6e56df3e8efd8e6d") +(define sbcl-closure-common + (let ((commit "e3c5f5f454b72b01b89115e581c3c52a7e201e5c") (revision "1")) (package - (name "sbcl-db3") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-closure-common") + (build-system asdf-build-system/sbcl) + (version (git-version "20101006" revision commit)) + (home-page "https://common-lisp.net/project/cxml/") (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/dimitri/cl-db3") + (url "https://github.com/sharplispers/closure-common") (commit commit))) - (file-name (git-file-name "cl-db3" version)) + (file-name (git-file-name name 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)) + (base32 + "0k5r2qxn122pxi301ijir3nayi9sg4d7yiy276l36qmzwhp4mg5n")))) + (inputs + `(("trivial-gray-streams" ,sbcl-trivial-gray-streams) + ("babel" ,sbcl-babel))) + (synopsis "Support Common Lisp library for CXML") + (description "Closure-common is an internal helper library. The name +Closure is a reference to the web browser it was originally written for.") + ;; TODO: License? + (license #f)))) -(define-public sbcl-dbi - (let ((commit "738a74dd69adb2a7c21fa67e140d89c7df25b227") - (revision "2")) +(define-public sbcl-closure-template + ;; There are no releases since 2015. + (let ((commit "f1983aa525045691e128027d2a2d74831c873d6e") + (revision "0")) (package - (name "sbcl-dbi") - (version (git-version "0.9.5" revision commit)) + (name "sbcl-closure-template") + (version (git-version "0.2.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/fukamachi/cl-dbi") + (url "https://github.com/archimag/cl-closure-template") (commit commit))) - (file-name (git-file-name "cl-dbi" version)) + (file-name (git-file-name "cl-closure-template" version)) (sha256 - (base32 "0f8z7an8ssg8mdf9k781r4ygdppv798v6f08ibgpd8mv8a6491fg")))) + (base32 "16h0fs6bjjd4n9pbkwcprpgyj26vsw2akk3q08m7xmsmqi05dppv")))) (build-system asdf-build-system/sbcl) - (native-inputs - `(("alexandria" ,sbcl-alexandria) - ("rove" ,sbcl-rove) - ("trivial-types" ,sbcl-trivial-types))) + (native-inputs (list sbcl-lift)) (inputs - `(("bordeaux-threads" ,sbcl-bordeaux-threads) - ("cl-mysql" ,sbcl-cl-mysql) - ("cl-sqlite" ,sbcl-cl-sqlite) - ("closer-mop" ,sbcl-closer-mop) - ("postmodern" ,sbcl-postmodern) - ("split-sequence" ,sbcl-split-sequence) - ("trivial-garbage" ,sbcl-trivial-garbage))) - (arguments - `(#:asd-systems '("dbi" - "dbd-mysql" - "dbd-postgres" - "dbd-sqlite3"))) - (synopsis "Database independent interface for Common Lisp") + (list sbcl-alexandria + sbcl-babel + sbcl-closer-mop + sbcl-esrap + sbcl-iterate + sbcl-parse-number + sbcl-split-sequence)) + (synopsis "Lisp implementation of Google Closure Templates") (description - "@code{dbi} is a Common Lisp library providing a database independent -interface for MySQL, PostgreSQL and SQLite.") - (home-page "https://github.com/fukamachi/cl-dbi") + "This package provides a Common Lisp implementation of Google +Closure Templates.") + (home-page "https://github.com/archimag/cl-closure-template/") (license license:llgpl)))) -(define-public cl-dbi - (sbcl-package->cl-source-package sbcl-dbi)) - -(define-public ecl-dbi - (sbcl-package->ecl-package sbcl-dbi)) - -(define-public sbcl-uffi - (package - (name "sbcl-uffi") - (version "2.1.2") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "http://git.kpe.io/uffi.git") - (commit (string-append "v" version)))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1hqszvz0a3wk4s9faa83sc3vjxcb5rxmjclyr17yzwg55z733kry")) - (modules '((guix build utils))) - (snippet - ;; The useless bundled debian folder drags `make' into the closure. - `(begin - (delete-file-recursively "debian") - #t)))) - (build-system asdf-build-system/sbcl) - (arguments - `(#:tests? #f ; TODO: Fix use of deprecated ASDF functions - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-permissions - (lambda _ - (make-file-writable "doc/html.tar.gz") - #t))))) - (synopsis "Universal foreign function library for Common Lisp") - (description - "UFFI provides a universal foreign function interface (FFI) - for Common Lisp.") - (home-page "https://quickdocs.org/uffi/") - (license license:llgpl))) +(define-public cl-closure-template + (sbcl-package->cl-source-package sbcl-closure-template)) -(define-public cl-uffi - (package - (inherit (sbcl-package->cl-source-package sbcl-uffi)) - (arguments - `(#:phases - ;; asdf-build-system/source has its own phases and does not inherit - ;; from asdf-build-system/sbcl phases. - (modify-phases %standard-phases/source - ;; Already done in SBCL package. - (delete 'reset-gzip-timestamps)))))) +(define-public ecl-closure-template + (sbcl-package->ecl-package sbcl-closure-template)) (define-public sbcl-clsql (package @@ -14337,375 +11116,238 @@ interfaces as well as a functional and an object oriented interface.") ((#:asd-systems asd-systems '()) `(cons "clsql-cffi" ,asd-systems))))))) -(define-public sbcl-sycamore - (let ((commit "fd2820fec165ad514493426dea209728f64e6d18")) +(define-public sbcl-clss + (let ((revision "2") + (commit "f62b849189c5d1be378f0bd3d403cda8d4fe310b")) (package - (name "sbcl-sycamore") - (version "0.0.20120604") + (name "sbcl-clss") + (version (git-version "0.3.1" revision commit)) (source (origin (method git-fetch) - (uri (git-reference - (url "https://github.com/ndantam/sycamore/") - (commit commit))) - (file-name (git-file-name name version)) + (uri + (git-reference + (url "https://github.com/Shinmera/clss") + (commit commit))) (sha256 - (base32 "00bv1aj89q5vldmq92zp2364jq312zjq2mbd3iyz1s2b4widzhl7")))) - (build-system asdf-build-system/sbcl) + (base32 "1033dchpanhcgxl5qfhr80aw9adbp9bvllhzvvy5p9mrfnidd1fv")) + (file-name (git-file-name name version)))) (inputs - (list sbcl-alexandria sbcl-cl-ppcre)) - (synopsis "Purely functional data structure library in Common Lisp") - (description - "Sycamore is a fast, purely functional data structure library in Common Lisp. -If features: - -@itemize -@item Fast, purely functional weight-balanced binary trees. -@item Leaf nodes are simple-vectors, greatly reducing tree height. -@item Interfaces for tree Sets and Maps (dictionaries). -@item Ropes. -@item Purely functional pairing heaps. -@item Purely functional amortized queue. -@end itemize\n") - (home-page "https://ndantam.github.io/sycamore/") - (license license:bsd-3)))) - -(define-public cl-sycamore - (sbcl-package->cl-source-package sbcl-sycamore)) - -(define-public ecl-sycamore - (sbcl-package->ecl-package sbcl-sycamore)) - -(define-public sbcl-funds - (let ((commit "39d425818876b898c20780a678803df506df8424") - (revision "2")) - (package - (name "sbcl-funds") - (version (git-version "1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/charJe/funds") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "13y1jhvnpzrs9daz6f3z67w6h2y21ggb10j3j4vnc5p3m8i7ps4p")))) + (list sbcl-array-utils sbcl-plump)) (build-system asdf-build-system/sbcl) - (synopsis "Purely functional data structure library in Common Lisp") - (description - "Funds provides portable, purely functional data structures in Common -Lisp. It includes tree based implementations for Array, Hash, Queue, Stack, and -Heap.") - (home-page "https://common-lisp.net/project/funds/") - (license license:asl2.0)))) - -(define-public cl-funds - (sbcl-package->cl-source-package sbcl-funds)) - -(define-public ecl-funds - (sbcl-package->ecl-package sbcl-funds)) - -(define-public sbcl-trivial-package-local-nicknames - (package - (name "sbcl-trivial-package-local-nicknames") - (version "0.2") - (home-page "https://github.com/phoe/trivial-package-local-nicknames") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit "16b7ad4c2b120f50da65154191f468ea5598460e"))) - (file-name (git-file-name name version)) - (sha256 - (base32 "18qc27xkjzdcqrilpk3pm7djldwq5rm3ggd5h9cr8hqcd54i2fqg")))) - (build-system asdf-build-system/sbcl) - (synopsis "Common Lisp compatibility library for package local nicknames") - (description - "This library is a portable compatibility layer around package local nicknames (PLN). -This was done so there is a portability library for the PLN API not included -in DEFPACKAGE.") - (license license:unlicense))) + (synopsis "DOM tree searching engine based on CSS selectors") + (description "CLSS is a DOM traversal engine based on CSS +selectors. It makes use of the Plump-DOM and is used by lQuery.") + (home-page "https://github.com/Shinmera/clss") + (license license:zlib)))) -(define-public cl-trivial-package-local-nicknames - (sbcl-package->cl-source-package sbcl-trivial-package-local-nicknames)) +(define-public cl-clss + (sbcl-package->cl-source-package sbcl-clss)) -(define-public ecl-trivial-package-local-nicknames - (sbcl-package->ecl-package sbcl-trivial-package-local-nicknames)) +(define-public ecl-clss + (sbcl-package->ecl-package sbcl-clss)) -(define-public sbcl-enchant - (let ((commit "6af162a7bf10541cbcfcfa6513894900329713fa")) +(define-public sbcl-cluffer + (let ((commit "4aad29c276a58a593064e79972ee4d77cae0af4a")) (package - (name "sbcl-enchant") + (name "sbcl-cluffer") (version (git-version "0.0.0" "1" commit)) - (home-page "https://github.com/tlikonen/cl-enchant") (source (origin (method git-fetch) (uri (git-reference - (url home-page) + (url "https://github.com/robert-strandh/cluffer") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 "19yh5ihirzi1d8xqy1cjqipzd6ly3245cfxa5s9xx496rryz0s01")))) + (base32 + "1bcg13g7qb3dr8z50aihdjqa6miz5ivlc9wsj2csgv1km1mak2kj")))) (build-system asdf-build-system/sbcl) (inputs - `(("enchant" ,enchant) - ("cffi" ,sbcl-cffi))) + (list sbcl-acclimation sbcl-clump)) (arguments `(#:phases (modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "load-enchant.lisp" - (("libenchant") - (string-append - (assoc-ref inputs "enchant") "/lib/libenchant-2")))))))) - (synopsis "Common Lisp interface for the Enchant spell-checker library") - (description - "Enchant is a Common Lisp interface for the Enchant spell-checker -library. The Enchant library is a generic spell-checker library which uses -other spell-checkers transparently as back-end. The library supports the -multiple checkers, including Aspell and Hunspell.") - (license license:public-domain)))) - -(define-public cl-enchant - (sbcl-package->cl-source-package sbcl-enchant)) - -(define-public ecl-enchant - (sbcl-package->ecl-package sbcl-enchant)) - -(define-public sbcl-cl-change-case - (let ((commit "45c70b601125889689e0c1c37d7e727a3a0af022") - (revision "1")) - (package - (name "sbcl-cl-change-case") - (version (git-version "0.2.0" revision commit)) - (home-page "https://github.com/rudolfochrist/cl-change-case") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (file-name (git-file-name "cl-change-case" version)) - (sha256 - (base32 "0qmk341zzcsbf8sq0w9ix3r080zg4ri6vzxym63lhdjfzwz3y8if")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-cl-ppcre sbcl-cl-ppcre-unicode)) - (native-inputs - (list sbcl-fiveam)) - (synopsis - "Convert Common Lisp strings between camelCase, PascalCase and more") - (description - "@code{cl-change-case} is a library to convert strings between -camelCase, PascalCase, snake_case, param-case, CONSTANT_CASE and more.") - (license license:llgpl)))) + (add-after 'install 'unpatch-shebangs + (lambda* (#:key outputs #:allow-other-keys) + ;; The documentation Makefile rely on shell scripts. + ;; TODO: Build it! + ;; In the mean time, remove the shabang as it adds bash to the + ;; closure. + (let* ((out (assoc-ref outputs "out")) + (build-aux (string-append + out "/share/"))) + (substitute* (find-files build-aux) + (("^#!.*/bin/sh") "#!/bin/sh") + (("^#!.*/bin/bash") "#!/bin/bash")))))))) + (home-page "https://github.com/robert-strandh/cluffer") + (synopsis "Common Lisp library providing a protocol for text-editor buffers") + (description "Cluffer is a library for representing the buffer of a text +editor. As such, it defines a set of CLOS protocols for client code to +interact with the buffer contents in various ways, and it supplies different +implementations of those protocols for different purposes.") + (license license:bsd-2)))) -(define-public cl-change-case - (sbcl-package->cl-source-package sbcl-cl-change-case)) +(define-public cl-cluffer + (sbcl-package->cl-source-package sbcl-cluffer)) -(define-public ecl-cl-change-case - (sbcl-package->ecl-package sbcl-cl-change-case)) +(define-public ecl-cluffer + (sbcl-package->ecl-package sbcl-cluffer)) -(define-public sbcl-modularize - (let ((commit "86c5d9a11fbd2df9f0f03ac10b5d71837c8934ba") - (revision "1")) +(define-public sbcl-clump + (let ((commit "1ea4dbac1cb86713acff9ae58727dd187d21048a")) (package - (name "sbcl-modularize") - (version (git-version "1.0.0" revision commit)) + (name "sbcl-clump") + (version (git-version "0.0.0" "1" commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/Shinmera/modularize") + (url "https://github.com/robert-strandh/Clump") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 "1zys29rfkb649rkgl3snxhajk8d5yf7ryxkrwy020kwdh7zdsg7d")))) - (build-system asdf-build-system/sbcl) + (base32 + "1639msyagsswj85gc0wd90jgh8588j3qg5q70by9s2brf2q6w4lh")))) (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)) + (list sbcl-acclimation)) + (build-system asdf-build-system/sbcl) + (home-page "https://github.com/robert-strandh/Clump") + (synopsis "Collection of tree implementations for Common Lisp") + (description "The purpose of this library is to provide a collection of +implementations of trees. -(define-public cl-modularize - (sbcl-package->cl-source-package sbcl-modularize)) +In contrast to existing libraries such as cl-containers, it does not impose a +particular use for the trees. Instead, it aims for a stratified design, +allowing client code to choose between different levels of abstraction. -(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 - (list sbcl-closer-mop sbcl-lambda-fiddle sbcl-modularize - 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)))) +As a consequence of this policy, low-level interfaces are provided where +the concrete representation is exposed, but also high level interfaces +where the trees can be used as search trees or as trees that represent +sequences of objects.") + (license license:bsd-2)))) -(define-public ecl-modularize-hooks - (sbcl-package->ecl-package sbcl-modularize-hooks)) +(define-public cl-clump + (sbcl-package->cl-source-package sbcl-clump)) -(define-public cl-modularize-hooks - (sbcl-package->cl-source-package sbcl-modularize-hooks)) +(define-public ecl-clump + (sbcl-package->ecl-package sbcl-clump)) -(define-public sbcl-modularize-interfaces - (let ((commit "96353657afb8c7aeba7ef5b51eb04c5ed3bcb6ef") - (revision "1")) +(define-public sbcl-cluster + (let ((commit "b040e97578f3027d7d8c7652c74917726574c43e") + (revision "0")) (package - (name "sbcl-modularize-interfaces") - (version (git-version "0.9.3" revision commit)) + (name "sbcl-cluster") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/Shinmera/modularize-interfaces") + (url "https://github.com/robert-strandh/Cluster") (commit commit))) - (file-name (git-file-name "modularize-interfaces" version)) + (file-name (git-file-name "cl-cluster" commit)) (sha256 - (base32 "0bjf4wy39cwf75m7vh0r7mmcchs09yz2lrbyap98hnq8blq70fhc")))) + (base32 "0ixbr3wm7d3m8mgzasd95rxvs9kip6ngr5s1zk7j3604mcfssqyi")))) (build-system asdf-build-system/sbcl) (inputs - (list sbcl-lambda-fiddle sbcl-modularize sbcl-trivial-arguments - sbcl-trivial-indent)) - (home-page "https://shinmera.github.io/modularize-interfaces/") - (synopsis "Programmatical interfaces extension for Modularize") + (list sbcl-acclimation + sbcl-split-sequence)) + (home-page "https://github.com/robert-strandh/Cluster") + (synopsis "Assembler with input in the form of standard instances") (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)))) + "Cluster is an assembler (initially for x86 and x86-64) with a difference. +To avoid the issue of defining a syntax, the input to Cluster is a list +of standard objects (i.e., instances of the class STANDARD-OBJECT), +as opposed to a character file or S-expressions.") + (license license:bsd-2)))) -(define-public ecl-modularize-interfaces - (sbcl-package->ecl-package sbcl-modularize-interfaces)) +(define-public cl-cluster + (sbcl-package->cl-source-package sbcl-cluster)) -(define-public cl-modularize-interfaces - (sbcl-package->cl-source-package sbcl-modularize-interfaces)) +(define-public ecl-cluster + (sbcl-package->ecl-package sbcl-cluster)) -(define-public sbcl-moptilities - (let ((commit "a436f16b357c96b82397ec018ea469574c10dd41")) +(define-public sbcl-clx + (let ((commit "38400456d66823e417d1d27d339b09885e25eb59") + (revision "1")) (package - (name "sbcl-moptilities") - (version (git-version "0.3.13" "1" commit)) - (home-page "https://github.com/gwkkwg/moptilities/") + (name "sbcl-clx") + (version (git-version "0.7.5" revision commit)) (source (origin (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (file-name (git-file-name name version)) + (uri + (git-reference + (url "https://github.com/sharplispers/clx") + (commit commit))) (sha256 - (base32 "1q12bqjbj47lx98yim1kfnnhgfhkl80102fkgp9pdqxg0fp6g5fc")))) + (base32 "1c05gjqh5lil2sgma0yap4mxd9y1cjkp933hyx1iaj14950nhfnl")) + (file-name (git-file-name "cl-clx" version)))) (build-system asdf-build-system/sbcl) - (inputs - `(("closer-mop" ,sbcl-closer-mop))) (native-inputs - (list sbcl-lift)) + (list sbcl-fiasco xorg-server-for-tests)) (arguments - `(#:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-tests - (lambda _ - (substitute* "lift-standard.config" - ((":relative-to lift-test") - ":relative-to moptilities-test")) - #t)) - (add-after 'install 'remove-test-results - ;; Otherwise the drag the SBCL package into the closure of the CL - ;; package. - (lambda* (#:key outputs #:allow-other-keys) - (let* ((out (assoc-ref outputs "out")) - (source-path (string-append out "/share/common-lisp/" - (%lisp-type) "/moptilities/"))) - (delete-file-recursively - (string-append source-path "/test-results"))) - #t))))) - (synopsis "Compatibility layer for Common Lisp MOP implementation differences") - (description - "MOP utilities provide a common interface between Lisps and make the -MOP easier to use.") - (license license:expat)))) + (list #:phases + #~(modify-phases %standard-phases + (add-before 'check 'prepare-test-environment + (lambda _ + (system "Xvfb :1 &") + (setenv "DISPLAY" ":1")))))) + (home-page "https://www.cliki.net/portable-clx") + (synopsis "X11 client library for Common Lisp") + (description "CLX is an X11 client library for Common Lisp. The code was +originally taken from a CMUCL distribution, was modified somewhat in order to +make it compile and run under SBCL, then a selection of patches were added +from other CLXes around the net.") + (license license:x11)))) -(define-public cl-moptilities - (sbcl-package->cl-source-package sbcl-moptilities)) +(define-public cl-clx + (sbcl-package->cl-source-package sbcl-clx)) -(define-public ecl-moptilities - (let ((pkg (sbcl-package->ecl-package sbcl-moptilities))) - (package - (inherit pkg) - (arguments - ;; Tests fail with "The function LIFT::GET-BACKTRACE-AS-STRING is - ;; undefined" on ECL. - '(#:tests? #f))))) +(define-public ecl-clx + (sbcl-package->ecl-package sbcl-clx)) -(define-public sbcl-osicat - (let ((commit "982327905b8980ff3173344ca87282e046565732") - (revision "4")) +(define-public sbcl-clx-truetype + (let ((commit "c6e10a918d46632324d5863a8ed067a83fc26de8") + (revision "1")) (package - (name "sbcl-osicat") - (version (git-version "0.7.0" revision commit)) - (home-page "https://www.common-lisp.net/project/osicat/") + (name "sbcl-clx-truetype") + (version (git-version "0.0.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/osicat/osicat") + (url "https://github.com/l04m33/clx-truetype") (commit commit))) - (file-name (git-file-name "cl-osicat" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "10q1dfkhrvp5ia860q10y4wdm11fmxf7xv8zl4viz2np9xzf5v22")) + (base32 + "079hyp92cjkdfn6bhkxsrwnibiqbz4y4af6nl31lzw6nm91j5j37")) + (modules '((guix build utils))) (snippet '(begin - ;; The useless release.sh drags `bash' into the closure. - (delete-file "scripts/release.sh") + (substitute* "package.lisp" + ((":export") ":export\n :+font-cache-filename+")) #t)))) (build-system asdf-build-system/sbcl) (inputs - (list sbcl-alexandria sbcl-cffi sbcl-trivial-features)) - (native-inputs - (list sbcl-rt)) - (synopsis "Operating system interface for Common Lisp") - (description - "Osicat is a lightweight operating system interface for Common Lisp on -Unix-platforms. It is not a POSIX-style API, but rather a simple lispy -accompaniment to the standard ANSI facilities.") + (list sbcl-clx + sbcl-zpb-ttf + sbcl-cl-vectors + sbcl-cl-fad + sbcl-cl-store + sbcl-trivial-features)) + (home-page "https://github.com/l04m33/clx-truetype") + (synopsis "Antialiased TrueType font rendering using CLX and XRender") + (description "CLX-TrueType is pure common lisp solution for +antialiased TrueType font rendering using CLX and XRender extension.") (license license:expat)))) -(define-public cl-osicat - (sbcl-package->cl-source-package sbcl-osicat)) +(define-public cl-clx-truetype + (sbcl-package->cl-source-package sbcl-clx-truetype)) -(define-public ecl-osicat - (sbcl-package->ecl-package sbcl-osicat)) +(define-public ecl-clx-truetype + (sbcl-package->ecl-package sbcl-clx-truetype)) (define-public sbcl-clx-xembed (let ((commit "a5c4b844d31ee68ffa58c933cc1cdddde6990743") @@ -14739,1889 +11381,2022 @@ accompaniment to the standard ANSI facilities.") (define-public ecl-clx-xembed (sbcl-package->ecl-package sbcl-clx-xembed)) -(define-public sbcl-mw-equiv - (let ((commit "3ae871458685b1ef7cd6a996ee22c8c5e738a03d") - (revision "1")) +(define-public sbcl-cmd + (let ((commit "0164d574ba236e2001ee1d9dba3f4774c7512a8c") + (revision "8")) (package - (name "sbcl-mw-equiv") - (version (git-version "0.1.2" revision commit)) - (home-page "https://github.com/sharplispers/mw-equiv/") + (name "sbcl-cmd") + (version (git-version "0.0.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/sharplispers/mw-equiv/") + (url "https://github.com/ruricolist/cmd/") (commit commit))) - (file-name (git-file-name "cl-mw-equiv" version)) + (file-name (git-file-name "cl-cmd" version)) (sha256 - (base32 "1fl90wp0jp7l90mps53fq0kzb28f10qfr739527h03xwqccyylad")))) + (base32 "03wbckzmz6pqdlz7pyar6nfg4vs4bl0b2np7n3kk3qhjbrdakc4m")))) (build-system asdf-build-system/sbcl) - (synopsis "Extensible object equivalence protocol for Common Lisp") - (description "Common Lisp comes with quite some functions to compare -objects for equality, yet none is applicable in every situation and in general -this is hard, as equality of objects depends on the semantics of operations on -them. As consequence, users find themselves regularly in a situation where -they have to roll their own specialized equality test. - -This module provides one of many possible equivalence relations between -standard Common Lisp objects. However, it can be extended for new objects -through a simple CLOS protocol. The rules when two objects are considered -equivalent distinguish between @emph{mutating} and @emph{frozen objects}. A -frozen object is promised not to be mutated in the future in a way that -operations on it can notice the difference. - -We have chosen to compare mutating objects only for identity (pointer -equality), to avoid various problems. Equivalence for frozen objects on the -other hand is established by recursing on the objects' constituent parts and -checking their equivalence. Hence, two objects are equivalent under the -@code{OBJECT=} relation, if they are either identical, or if they are frozen -and structurally equivalent, i.e. their constituents are point-wise -equivalent. - -Since many objects are potentially mutable, but are not necessarily mutated -from a certain point in their life time on, it is possible to promise to the -equivalence relation that they remain frozen for the rest of their life time, -thus enabling coarser equivalence than the often too fine-grained pointer -equality.") - (license license:bsd-2)))) + (arguments + (list #: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")) + (ps-bin (string-append (assoc-ref inputs "procps") + "/bin"))) + (substitute* "cmd.lisp" + (("\\(def \\+env\\+ \"env\"\\)") + (format #f "(def +env+ \"~a/env\")" bin)) + (("\\(def \\+kill\\+ \"kill\"\\)") + (format #f "(def +kill+ \"~a/kill\")" bin)) + (("\\(def \\+ps\\+ \"ps\"\\)") + (format #f "(def +ps+ \"~a/ps\")" ps-bin)) + (("\\(def \\+pwd\\+ \"pwd\"\\)") + (format #f "(def +pwd+ \"~a/pwd\")" bin)) + (("\\(def \\+sh\\+ \"/bin/sh\"\\)") + (format #f "(def +sh+ \"~a\")" (which "sh"))) + (("\\(def \\+tr\\+ \"tr\"\\)") + (format #f "(def +tr+ \"~a/tr\")" bin))))))))) + (inputs + (list coreutils + procps + sbcl-alexandria + sbcl-serapeum + sbcl-shlex + sbcl-trivia)) + (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 cl-mw-equiv - (sbcl-package->cl-source-package sbcl-mw-equiv)) +(define-public cl-cmd + (sbcl-package->cl-source-package sbcl-cmd)) -(define-public ecl-mw-equiv - (sbcl-package->ecl-package sbcl-mw-equiv)) +(define-public ecl-cmd + (sbcl-package->ecl-package sbcl-cmd)) -(define-public sbcl-quantile-estimator +(define-public sbcl-cmn (package - (name "sbcl-quantile-estimator") - (version "0.0.1") + (name "sbcl-cmn") + (version "2021.11.22") (source (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/deadtrickster/quantile-estimator.cl") - (commit "84d0ea405d793f5e808c68c4ddaf25417b0ff8e5"))) - (file-name (git-file-name name version)) + (method url-fetch) + (uri "https://ccrma.stanford.edu/software/cmn/cmn.tar.gz") + (file-name (string-append "cmn-" version ".tar.gz")) (sha256 - (base32 - "0rlswkf0siaabsvvch3dgxmg45fw5w8pd9b7ri2w7a298aya52z9")))) + (base32 "04j1l57cdyfi2zzxqwmvmf1hl899ffgs3bl4r42ba47zsw45kq14")))) (build-system asdf-build-system/sbcl) - (arguments - '(#:asd-test-systems '("quantile-estimator.test"))) - (inputs - (list sbcl-alexandria)) - (native-inputs - (list sbcl-mw-equiv sbcl-prove sbcl-log4cl)) - (home-page "https://github.com/deadtrickster/quantile-estimator.cl") - (synopsis - "Effective computation of biased quantiles over data streams") + (home-page "https://ccrma.stanford.edu/software/cmn/") + (synopsis "Western music notation package written in Common Lisp") (description - "Common Lisp implementation of Graham Cormode and S. -Muthukrishnan's Effective Computation of Biased Quantiles over Data -Streams in ICDE’05.") + "CMN provides a package of functions to hierarchically describe a musical +score. When evaluated, the musical score is rendered to an image.") (license license:expat))) -(define-public cl-quantile-estimator - (sbcl-package->cl-source-package sbcl-quantile-estimator)) +(define-public cl-cmn + (sbcl-package->cl-source-package sbcl-cmn)) -(define-public ecl-quantile-estimator - (sbcl-package->ecl-package sbcl-quantile-estimator)) +(define-public ecl-cmn + (sbcl-package->ecl-package sbcl-cmn)) -(define-public sbcl-prometheus - (package - (name "sbcl-prometheus") - (version "0.4.1") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/deadtrickster/prometheus.cl") - (commit "7352b92296996ff383503e19bdd3bcea30409a15"))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "0fzczls2kfgdx18pja4lqxjrz72i583185d8nq0pb3s331hhzh0z")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("alexandria" ,sbcl-alexandria) - ("bordeaux-threads" ,sbcl-bordeaux-threads) - ("cffi" ,sbcl-cffi) - ("cl-fad" ,sbcl-cl-fad) - ("cl-ppcre" ,sbcl-cl-ppcre) - ("drakma" ,sbcl-drakma) - ("hunchentoot" ,sbcl-hunchentoot) - ("local-time" ,sbcl-local-time) - ("quantile-estimator" ,sbcl-quantile-estimator) - ("salza2" ,sbcl-salza2) - ("split-sequence" ,sbcl-split-sequence) - ("trivial-utf-8" ,sbcl-trivial-utf-8))) - (arguments - '(#:asd-systems '("prometheus" - "prometheus.collectors.sbcl" - "prometheus.collectors.process" - "prometheus.formats.text" - "prometheus.exposers.hunchentoot" - "prometheus.pushgateway"))) - (home-page "https://github.com/deadtrickster/prometheus.cl") - (synopsis "Prometheus.io Common Lisp client") - (description "Prometheus.io Common Lisp client.") - (license license:expat))) +(define-public sbcl-coalton + (let ((commit "939342495f55991812c2c2767322c5e51e755216") + (revision "4")) + (package + (name "sbcl-coalton") + (version (git-version "0.0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/coalton-lang/coalton") + (commit commit))) + (file-name (git-file-name "cl-coalton" version)) + (sha256 + (base32 "08qzj3v4fvn9h87whyqg650rpap8lva7jr94d1akv6m2z62l5q68")))) + (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-fiasco)) + (inputs + (list sbcl-alexandria + sbcl-concrete-syntax-tree + sbcl-eclector + sbcl-float-features + sbcl-fset + sbcl-named-readtables + sbcl-trivial-garbage)) + (home-page "https://coalton-lang.github.io") + (synopsis "Dialect of ML in Common Lisp") + (description + "Coalton is a dialect of ML embedded in Common Lisp. It emphasizes +practicality and interoperability with Lisp, and is intended to be a DSL that +allows one to gradually make their programs safer.") + (license license:expat)))) -(define-public cl-prometheus - (sbcl-package->cl-source-package sbcl-prometheus)) +(define-public cl-coalton + (sbcl-package->cl-source-package sbcl-coalton)) -(define-public ecl-prometheus - (sbcl-package->ecl-package sbcl-prometheus)) +(define-public ecl-coalton + (sbcl-package->ecl-package sbcl-coalton)) -(define-public sbcl-promise - (let ((commit "801db8f853da7935ae2e487fd7f8763acbc5ad2a") +(define-public sbcl-coleslaw + (let ((commit "e7e68ce6020d13b14bf212890a7d8973d7af3b40") (revision "0")) (package - (name "sbcl-promise") + (name "sbcl-coleslaw") + (version (git-version "0.9.7" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/coleslaw-org/coleslaw") + (commit commit))) + (file-name (git-file-name "cl-coleslaw" version)) + (sha256 + (base32 "1w21a272q4x7nlr4kbmwwvkjvb4hpnw869byvy47vv361y7pimws")))) + (build-system asdf-build-system/sbcl) + (outputs '("out" "bin")) + (arguments + '(#:asd-systems '("coleslaw" "coleslaw-cli") + #:phases + (modify-phases %standard-phases + (add-after 'unpack 'fix-paths + (lambda _ + (substitute* "plugins/publish-gh-pages.sh" + (("^rsync\\b") (which "rsync"))) + (substitute* '("plugins/rsync.lisp" + "src/coleslaw.lisp") + (("\\brun-program \"rsync\\b") + (string-append "run-program \"" (which "rsync")))))) + (add-after 'create-asdf-configuration 'build-program + (lambda* (#:key outputs #:allow-other-keys) + (build-program + (string-append (assoc-ref outputs "bin") "/bin/coleslaw") + outputs + #:dependencies '("coleslaw-cli") + #:entry-program '((apply (function coleslaw-cli::main) + arguments)) + #:compress? #t)))))) + (native-inputs + (list sbcl-prove)) + (inputs + (list rsync + sbcl-3bmd + sbcl-alexandria + sbcl-cl-fad + sbcl-cl-ppcre + sbcl-cl-unicode + sbcl-clack + sbcl-closer-mop + sbcl-closure-template + sbcl-inferior-shell + sbcl-local-time + sbcl-trivia)) + (home-page "https://github.com/coleslaw-org/coleslaw") + (synopsis "Static site generator") + (description + "Coleslaw is a static site generator written in Common Lisp.") + (license license:bsd-2)))) + +(define-public cl-coleslaw + (sbcl-package->cl-source-package sbcl-coleslaw)) + +(define-public ecl-coleslaw + (sbcl-package->ecl-package sbcl-coleslaw)) + +(define-public sbcl-collectors + (let ((commit "4c5e70cf399381de8fb485d4ed5a5c8fd7555146") + (revision "2")) + (package + (name "sbcl-collectors") + (version (git-version "1.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/AccelerationNet/collectors") + (commit commit))) + (file-name (git-file-name "cl-collectors" version)) + (sha256 + (base32 "1kc9q05wyp8yjz5wqc73nar7l49vcnfhj4924li81v76hlb03665")))) + (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-alexandria sbcl-closer-mop sbcl-symbol-munger)) + (native-inputs + (list sbcl-lisp-unit2)) + (home-page "https://github.com/AccelerationNet/collectors/") + (synopsis "Common lisp library providing collector macros") + (description "A small collection of common lisp macros to make +collecting values easier.") + (license license:bsd-3)))) + +(define-public cl-collectors + (sbcl-package->cl-source-package sbcl-collectors)) + +(define-public ecl-collectors + (sbcl-package->ecl-package sbcl-collectors)) + +(define-public sbcl-colored + (let ((commit "bee87efb0b047da0f071f5cf1457997ab5f93feb") + (revision "1")) + (package + (name "sbcl-colored") (version (git-version "1.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/Shinmera/promise") + (url "https://github.com/Shinmera/colored/") (commit commit))) - (file-name (git-file-name "cl-promise" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "07cvz6vb5y1d9vndcwq7q1cp54aqvyqzv6wk8vmymbz3lawq2wsn")))) + (base32 "0mpg91r6yfb9xqccd4r8z3hl2qzjhdj6daswb1cinrm8ffxrvy5k")))) (build-system asdf-build-system/sbcl) (native-inputs (list sbcl-parachute)) (inputs (list sbcl-documentation-utils)) - (home-page "https://shinmera.github.io/promise/") - (synopsis "Promise mechanism for asynchronous operations") + (synopsis "Colour representation, conversion, and operation for Common Lisp") (description - "This library implements a basic promise datastructure, which is useful -for dealing with asynchronous behaviours. Importantly, this library does not -use any other libraries or frameworks, and instead leaves the execution and -state transition of promise objects in your control, making it easy to -integrate.") + "This is a library for representing and mapping colours between their +various spaces.") + (home-page "https://shinmera.github.io/colored/") (license license:zlib)))) -(define-public ecl-promise - (sbcl-package->ecl-package sbcl-promise)) +(define-public cl-colored + (sbcl-package->cl-source-package sbcl-colored)) -(define-public cl-promise - (sbcl-package->cl-source-package sbcl-promise)) +(define-public ecl-colored + (sbcl-package->ecl-package sbcl-colored)) -(define-public sbcl-uuid - (let ((commit "e7d6680c3138385c0708f7aaf0c96622eeb140e8")) +(define-public sbcl-colorize + (let ((commit "ea676b584e0899cec82f21a9e6871172fe3c0eb5")) (package - (name "sbcl-uuid") - (version (git-version "2012.12.26" "1" commit)) + (name "sbcl-colorize") + (version (git-version "0.0.0" "1" commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/dardoria/uuid") + (url "https://github.com/kingcons/colorize") (commit commit))) - (file-name (git-file-name name version)) (sha256 (base32 - "0jnyp2kibcf5cwi60l6grjrj8wws9chasjvsw7xzwyym2lyid46f")))) + "1pdg4kiaczmr3ivffhirp7m3lbr1q27rn7dhaay0vwghmi31zcw9")) + (file-name (git-file-name "colorize" version)))) (build-system asdf-build-system/sbcl) (inputs - (list sbcl-ironclad sbcl-trivial-utf-8)) - (home-page "https://github.com/dardoria/uuid") - (synopsis - "Common Lisp implementation of UUIDs according to RFC4122") + (list sbcl-alexandria sbcl-split-sequence sbcl-html-encode)) + (synopsis "Common Lisp for syntax highlighting") (description - "Common Lisp implementation of UUIDs according to RFC4122.") - (license license:llgpl)))) + "@command{colorize} is a Lisp library for syntax highlighting +supporting the following languages: Common Lisp, Emacs Lisp, Scheme, Clojure, +C, C++, Java, Python, Erlang, Haskell, Objective-C, Diff, Webkit.") + (home-page "https://github.com/kingcons/colorize") + ;; TODO: Missing license? + (license license:expat)))) -(define-public cl-uuid - (sbcl-package->cl-source-package sbcl-uuid)) +(define-public cl-colorize + (sbcl-package->cl-source-package sbcl-colorize)) -(define-public ecl-uuid - (sbcl-package->ecl-package sbcl-uuid)) +(define-public ecl-colorize + (sbcl-package->ecl-package sbcl-colorize)) -(define-public sbcl-dissect - (let ((commit "cffd38479f0e64e805f167bbdb240b783ecc8d45")) +(define-public sbcl-com.gigamonkeys.binary-data + (let ((commit "22e908976d7f3e2318b7168909f911b4a00963ee") + (revision "0")) (package - (name "sbcl-dissect") - (version (git-version "1.0.0" "1" commit)) + (name "sbcl-com.gigamonkeys.binary-data") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/Shinmera/dissect") + (url "https://github.com/gigamonkey/monkeylib-binary-data") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 - "0rmsjkgjl90gl6ssvgd60hb0d5diyhsiyypvw9hbc0ripvbmk5r5")))) + (base32 "072v417vmcnvmyh8ddq9vmwwrizm7zwz9dpzi14qy9nsw8q649zw")))) (build-system asdf-build-system/sbcl) (inputs - (list sbcl-cl-ppcre)) - (home-page "https://shinmera.github.io/dissect/") - (synopsis - "Introspection library for the call stack and restarts") + (list sbcl-alexandria)) + (home-page "https://github.com/gigamonkey/monkeylib-binary-data") + (synopsis "Common Lisp library for reading and writing binary data") (description - "Dissect is a small Common Lisp library for introspecting the call stack -and active restarts.") - (license license:zlib)))) + "This a Common Lisp library for reading and writing binary data. It is +based on code from chapter 24 of the book @emph{Practical Common Lisp}.") + (license license:bsd-3)))) -(define-public cl-dissect - (sbcl-package->cl-source-package sbcl-dissect)) +(define-public cl-com.gigamonkeys.binary-data + (sbcl-package->cl-source-package sbcl-com.gigamonkeys.binary-data)) -(define-public ecl-dissect - (sbcl-package->ecl-package sbcl-dissect)) +(define-public ecl-com.gigamonkeys.binary-data + (sbcl-package->ecl-package sbcl-com.gigamonkeys.binary-data)) -(define-public sbcl-exponential-backoff - (let ((commit "8d9e8444d8b3184a524c12ce3449f91613ab714f")) +(define-public sbcl-command-line-args + (package + (name "sbcl-command-line-args") + (version "0.1.1") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://git.sr.ht/~whereiseveryone/command-line-args") + (commit (string-append "v" version)))) + (file-name (git-file-name "cl-command-line-args" version)) + (sha256 + (base32 "140xnz2v0v3hfg3dp2fhidw8ns6lxd3a5knm07wqdp48ksg119wy")))) + (build-system asdf-build-system/sbcl) + (arguments + '(#:asd-systems '("whereiseveryone.command-line-args"))) + (inputs + (list sbcl-alexandria + sbcl-charje.documentation + sbcl-cl-str + sbcl-serapeum + sbcl-trivia)) + (home-page "https://git.sr.ht/~whereiseveryone/command-line-args") + (synopsis "Automatically generate command line interfaces") + (description "Command-Line-Args provides a main macro (@code{command}) +that wraps a @code{defun} form and creates a new function that parses the +command line arguments. It has support for command-line options, positional, +and variadic arguments. It also generates a basic help message. The +interface is meant to be easy and non-intrusive.") + (license license:agpl3+))) + +(define-public cl-command-line-args + (sbcl-package->cl-source-package sbcl-command-line-args)) + +(define-public ecl-command-line-args + (sbcl-package->ecl-package sbcl-command-line-args)) + +(define-public sbcl-command-line-arguments + (let ((commit "fbac862fb01c0e368141204f3f639920462c23fe") + (revision "1")) (package - (name "sbcl-exponential-backoff") - (version (git-version "0" "1" commit)) + (name "sbcl-command-line-arguments") + (version (git-version "2.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/death/exponential-backoff") + (url "https://github.com/fare/command-line-arguments") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 - "1389hm9hxv85s0125ja4js1bvh8ay4dsy9q1gaynjv27ynik6gmv")))) + (base32 "054m1ikndzqf72mb9ajaa64136cwr3bgag4yfbi1574a9vq75mjq")))) (build-system asdf-build-system/sbcl) - (home-page "https://github.com/death/exponential-backoff") - (synopsis "Exponential backoff algorithm in Common Lisp") - (description - "An implementation of the exponential backoff algorithm in Common Lisp. -Inspired by the implementation found in Chromium. Read the header file to -learn about each of the parameters.") + (home-page "https://github.com/fare/command-line-arguments") + (synopsis "Trivial command-line argument parsing library for Common Lisp") + (description "This is a library to abstract away the parsing of +Unix-style command-line arguments. Use it in conjunction with asdf:program-op +or cl-launch for portable processing of command-line arguments.") (license license:expat)))) -(define-public cl-exponential-backoff - (sbcl-package->cl-source-package sbcl-exponential-backoff)) +(define-public cl-command-line-arguments + (sbcl-package->cl-source-package sbcl-command-line-arguments)) -(define-public ecl-exponential-backoff - (sbcl-package->ecl-package sbcl-exponential-backoff)) +(define-public ecl-command-line-arguments + (sbcl-package->ecl-package sbcl-command-line-arguments)) -(define-public sbcl-sxql - (let ((commit "cc3478cacb0557475a59cf619dad66c5dc8080ba") +(define-public sbcl-common-lisp-jupyter + (let ((commit "ba9f0e746b9200d6fd6db647d7274448119ed01b") (revision "3")) (package - (name "sbcl-sxql") + (name "sbcl-common-lisp-jupyter") (version (git-version "0.1.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/fukamachi/sxql") + (url "https://github.com/yitzchak/common-lisp-jupyter") (commit commit))) - (file-name (git-file-name "cl-sqxl" version)) + (file-name (git-file-name "common-lisp-jupyter" commit)) (sha256 - (base32 "011an993amy8q3gl4hyqrgnc93cgny3cv9gbp679rrmyyp8zmywr")))) + (base32 "0si69xfzi769dprwfy7gp1x3bl7lxz6d4n98sa26w9r41wvay5ja")))) (build-system asdf-build-system/sbcl) (inputs (list sbcl-alexandria - sbcl-cl-package-locks - sbcl-cl-syntax + sbcl-babel + sbcl-bordeaux-threads + sbcl-cl-base64 + sbcl-cl-indentify + sbcl-closer-mop + sbcl-dissect + sbcl-eclector + sbcl-ironclad sbcl-iterate - sbcl-optima - sbcl-split-sequence - sbcl-trivia - sbcl-trivial-types)) - (native-inputs - (list sbcl-prove)) - (home-page "https://github.com/fukamachi/sxql") - (synopsis "SQL generator for Common Lisp") - (description "SQL generator for Common Lisp.") - (license license:bsd-3)))) + sbcl-multilang-documentation + sbcl-puri + sbcl-pzmq + sbcl-shasht + sbcl-static-vectors + sbcl-trivial-do + sbcl-trivial-garbage + sbcl-trivial-gray-streams + 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:expat)))) -(define-public cl-sxql - (sbcl-package->cl-source-package sbcl-sxql)) +(define-public cl-common-lisp-jupyter + (sbcl-package->cl-source-package sbcl-common-lisp-jupyter)) -(define-public ecl-sxql - (sbcl-package->ecl-package sbcl-sxql)) +(define-public ecl-common-lisp-jupyter + (sbcl-package->ecl-package sbcl-common-lisp-jupyter)) -(define-public sbcl-cl-ascii-table - (let ((commit "d9f5e774a56fad1b416e4dadb8f8a5b0e84094e2") - (revision "1")) +(define-public sbcl-compatible-metaclasses + (package + (name "sbcl-compatible-metaclasses") + (version "1.0") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Hexstream/compatible-metaclasses") + (commit (string-append "v" version)))) + (file-name (git-file-name "cl-compatible-metaclasses" version)) + (sha256 + (base32 "17cf74j400cl6sjslfhkv13lir85k705v63mx3dd4y6dl5hvsdh6")))) + (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-parachute)) + (inputs + (list sbcl-class-options + sbcl-closer-mop + sbcl-enhanced-find-class)) + (home-page "https://www.hexstreamsoft.com/libraries/compatible-metaclasses/") + (synopsis "Simplifies class mixins by validating superclasses") + (description + "This library validates superclasses according to a simple substitution +model, thereby greatly simplifying the definition of class mixins.") + (license license:unlicense))) + +(define-public cl-compatible-metaclasses + (sbcl-package->cl-source-package sbcl-compatible-metaclasses)) + +(define-public ecl-compatible-metaclasses + (sbcl-package->ecl-package sbcl-compatible-metaclasses)) + +(define-public sbcl-compiler-macro + (let ((commit "7796bda64aec5af3ca175170ad3565167868789c") + (revision "0")) (package - (name "sbcl-cl-ascii-table") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-compiler-macro") + (version (git-version "0.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/telephil/cl-ascii-table") + (url "https://github.com/Bike/compiler-macro") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-compiler-macro" version)) (sha256 - (base32 "125fdif9sgl7k0ngjhxv0wjas2q27d075025hvj2rx1b1x948z4s")))) + (base32 "13sswps7s0qy6939mvj8q57hkx0qkga6rl6xjhjr7pk7by0xdsjq")))) (build-system asdf-build-system/sbcl) - (synopsis "Library to make ascii-art tables") - (description - "This is a Common Lisp library to present tabular data in ascii-art -tables.") - (home-page "https://github.com/telephil/cl-ascii-table") - (license license:expat)))) + (native-inputs + (list sbcl-fiveam)) + (inputs + (list sbcl-introspect-environment)) + (home-page "https://github.com/Bike/compiler-macro") + (synopsis "Common Lisp compiler macro utilities") + (description "This library is a collection of utilities for writing +compiler macros. It is intended to make it possible to make compiler macros +much more useful, by granting them access to lexical type information, making +the protocol for declining expansion more convenient, and establishing some +information for signaling optimization advice to programmers. Some utilities +to support this, especially for reasoning on types, are also included.") + (license license:cc0)))) -(define-public cl-ascii-table - (sbcl-package->cl-source-package sbcl-cl-ascii-table)) +(define-public cl-compiler-macro + (sbcl-package->cl-source-package sbcl-compiler-macro)) -(define-public ecl-cl-ascii-table - (sbcl-package->ecl-package sbcl-cl-ascii-table)) +(define-public ecl-compiler-macro + (sbcl-package->ecl-package sbcl-compiler-macro)) -(define-public sbcl-cl-rdkafka +(define-public sbcl-compiler-macro-notes (package - (name "sbcl-cl-rdkafka") - (version "1.1.0") + (name "sbcl-compiler-macro-notes") + (version "0.2.0") (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/SahilKang/cl-rdkafka") + (url "https://github.com/digikar99/compiler-macro-notes") (commit (string-append "v" version)))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-compiler-macro-notes" version)) (sha256 - (base32 - "0z2g0k0xy8k1p9g93h8dy9wbygaq7ziwagm4yz93zk67mhc0b84v")))) + (base32 "1jv8snj2wvim3k9qhl1vsx82n56nzdmwa3ms9c4ml2d58fwpfjzs")))) (build-system asdf-build-system/sbcl) - (arguments - `(#:tests? #f ; Attempts to connect to locally running Kafka - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "src/low-level/librdkafka-bindings.lisp" - (("librdkafka" all) - (string-append (assoc-ref inputs "librdkafka") "/lib/" - all)))))))) (inputs - `(("bordeaux-threads" ,sbcl-bordeaux-threads) - ("cffi" ,sbcl-cffi) - ("librdkafka" ,librdkafka) - ("lparallel" ,sbcl-lparallel) - ("trivial-garbage" ,sbcl-trivial-garbage))) - (home-page "https://github.com/SahilKang/cl-rdkafka") - (synopsis "Common Lisp client library for Apache Kafka") - (description "A Common Lisp client library for Apache Kafka.") - (license license:gpl3))) + (list sbcl-alexandria + sbcl-cl-environments)) + (home-page "https://github.com/digikar99/compiler-macro-notes") + (synopsis "Macros and conditions for use within macros and compiler-macros") + (description + "Alternative to the @code{compiler-macro} library: -(define-public cl-rdkafka - (sbcl-package->cl-source-package sbcl-cl-rdkafka)) +@itemize +@item Here, we do not treat compiler notes as warnings, but instead these are +a separate class of conditions. These are also not errors. +@item Two main condition classes are provided: compiler-macro-notes:note and +compiler-macro-notes:optimization-failure-note. While the latter is a subclass +of the former, the latter notes are printed in a slightly different manner to +the former. +@item To be able to correctly print the expansion path that led to the +condition, user code is expected to avoid performing a nonlocal exit to a +place outside with-notes. +@end itemize\n") + (license license:expat))) -(define-public ecl-cl-rdkafka - (sbcl-package->ecl-package sbcl-cl-rdkafka)) +(define-public cl-compiler-macro-notes + (sbcl-package->cl-source-package sbcl-compiler-macro-notes)) -(define-public sbcl-acclimation - (let ((commit "4d51150902568fcd59335f4cc4cfa022df6116a5")) +(define-public ecl-compiler-macro-notes + (sbcl-package->ecl-package sbcl-compiler-macro-notes)) + +(define-public sbcl-computable-reals + (let ((commit "fdc73d75e79d0a4ce6d01c822c950ae2eb137d39")) (package - (name "sbcl-acclimation") - (version (git-version "0.0.0" "1" commit)) + (name "sbcl-computable-reals") + (version (git-version "1.1.0" "1" commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/robert-strandh/Acclimation") + (url "https://github.com/stylewarning/computable-reals") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 - "1aw7rarjl8ai57h0jxnp9hr3dka7qrs55mmbl1p6rhd6xj8mp9wq")))) + (base32 "0f12axi53x14l12dgf4a1lfq3p1fx7fh7sjfc0db3lk88ph9qfwl")))) (build-system asdf-build-system/sbcl) - (home-page "https://github.com/robert-strandh/Acclimation") - (synopsis "Internationalization library for Common Lisp") - (description "This project is meant to provide tools for -internationalizing Common Lisp programs. - -One important aspect of internationalization is of course the language used in -error messages, documentation strings, etc. But with this project we provide -tools for all other aspects of internationalization as well, including dates, -weight, temperature, names of physical quantitites, etc.") - (license license:bsd-2)))) + (home-page "https://github.com/stylewarning/computable-reals") + (synopsis "Arbitrary-precision, re-computing real-numbers in Common Lisp") + (description + "This library provides arbitrary precision (floating point) real +numbers in Common Lisp.") + (license license:bsd-3)))) -(define-public cl-acclimation - (sbcl-package->cl-source-package sbcl-acclimation)) +(define-public cl-computable-reals + (sbcl-package->cl-source-package sbcl-computable-reals)) -(define-public ecl-acclimation - (sbcl-package->ecl-package sbcl-acclimation)) +(define-public ecl-computable-reals + (sbcl-package->ecl-package sbcl-computable-reals)) -(define-public sbcl-clump - (let ((commit "1ea4dbac1cb86713acff9ae58727dd187d21048a")) +(define-public sbcl-concrete-syntax-tree + (let ((commit "37291727196a3bc88a7be67c1427c52078d4b82c") + (revision "0")) (package - (name "sbcl-clump") - (version (git-version "0.0.0" "1" commit)) + (name "sbcl-concrete-syntax-tree") + (version (git-version "0.2.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/robert-strandh/Clump") + (url "https://github.com/s-expressionists/Concrete-Syntax-Tree") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-concrete-syntax-tree" commit)) (sha256 - (base32 - "1639msyagsswj85gc0wd90jgh8588j3qg5q70by9s2brf2q6w4lh")))) + (base32 "15q9jyqsh2z921li9my8c840cj2ci7k217x5frfiyk0kymkx4rgv")))) + (build-system asdf-build-system/sbcl) (inputs (list sbcl-acclimation)) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/robert-strandh/Clump") - (synopsis "Collection of tree implementations for Common Lisp") - (description "The purpose of this library is to provide a collection of -implementations of trees. + (arguments + '(#:asd-systems '("concrete-syntax-tree" + "concrete-syntax-tree-destructuring" + "concrete-syntax-tree-source-info"))) + (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. -In contrast to existing libraries such as cl-containers, it does not impose a -particular use for the trees. Instead, it aims for a stratified design, -allowing client code to choose between different levels of abstraction. +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. -As a consequence of this policy, low-level interfaces are provided where -the concrete representation is exposed, but also high level interfaces -where the trees can be used as search trees or as trees that represent -sequences of objects.") +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 cl-clump - (sbcl-package->cl-source-package sbcl-clump)) +(define-public cl-concrete-syntax-tree + (sbcl-package->cl-source-package sbcl-concrete-syntax-tree)) -(define-public ecl-clump - (sbcl-package->ecl-package sbcl-clump)) +(define-public ecl-concrete-syntax-tree + (sbcl-package->ecl-package sbcl-concrete-syntax-tree)) -(define-public sbcl-cluffer - (let ((commit "4aad29c276a58a593064e79972ee4d77cae0af4a")) +(define-public sbcl-concurrent-hash-tables + (let ((commit "6ad539b8970ff94b1e1369b59065ed7d0660904c") + (revision "1")) (package - (name "sbcl-cluffer") - (version (git-version "0.0.0" "1" commit)) + (name "sbcl-concurrent-hash-tables") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/robert-strandh/cluffer") + (url "https://github.com/no-defun-allowed/concurrent-hash-tables") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-concurrent-hash-tables" version)) (sha256 - (base32 - "1bcg13g7qb3dr8z50aihdjqa6miz5ivlc9wsj2csgv1km1mak2kj")))) + (base32 "0wgbv3wl33rlfbywmjag0gk7igzfksmib30r8cbnd5n47ic09iip")))) (build-system asdf-build-system/sbcl) (inputs - (list sbcl-acclimation sbcl-clump)) - (arguments - `(#:phases - (modify-phases %standard-phases - (add-after 'install 'unpatch-shebangs - (lambda* (#:key outputs #:allow-other-keys) - ;; The documentation Makefile rely on shell scripts. - ;; TODO: Build it! - ;; In the mean time, remove the shabang as it adds bash to the - ;; closure. - (let* ((out (assoc-ref outputs "out")) - (build-aux (string-append - out "/share/"))) - (substitute* (find-files build-aux) - (("^#!.*/bin/sh") "#!/bin/sh") - (("^#!.*/bin/bash") "#!/bin/bash")))))))) - (home-page "https://github.com/robert-strandh/cluffer") - (synopsis "Common Lisp library providing a protocol for text-editor buffers") - (description "Cluffer is a library for representing the buffer of a text -editor. As such, it defines a set of CLOS protocols for client code to -interact with the buffer contents in various ways, and it supplies different -implementations of those protocols for different purposes.") + (list sbcl-atomics sbcl-bordeaux-threads)) + (home-page "https://github.com/no-defun-allowed/concurrent-hash-tables") + (synopsis "Portability library for concurrent hash tables in Common Lisp") + (description "@code{concurrent-hash-tables} is a Common Lisp portability +library wrapping some implementations of concurrent hash tables which do not +have to be entirely locked in their operation, including +@code{42nd-at-threadmill}, @code{luckless}, and a fallback, segmented hash +table.") (license license:bsd-2)))) -(define-public cl-cluffer - (sbcl-package->cl-source-package sbcl-cluffer)) +(define-public cl-concurrent-hash-tables + (sbcl-package->cl-source-package sbcl-concurrent-hash-tables)) -(define-public ecl-cluffer - (sbcl-package->ecl-package sbcl-cluffer)) +(define-public ecl-concurrent-hash-tables + (sbcl-package->ecl-package sbcl-concurrent-hash-tables)) -(define-public sbcl-cl-libsvm-format - (let ((commit "3300f84fd8d9f5beafc114f543f9d83417c742fb") - (revision "0")) +(define-public sbcl-conduit-packages + (package + (name "sbcl-conduit-packages") + (version "2.0.0") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/tfeb/conduit-packages") + (commit (string-append "v" version)))) + (file-name (git-file-name "cl-conduit-packages" version)) + (sha256 + (base32 "1n783in84mrk9lnc3nshwsgxhb8y0dk6ys9z6jlxkv0jpjxhpjjc")))) + (build-system asdf-build-system/sbcl) + (arguments '(#:asd-systems '("org.tfeb.conduit-packages"))) + (synopsis "Conduit packages for Common Lisp") + (description "This library defines a way of treating Common Lisp +packages as conduits which can sit between one or more implementation +packages and users of those packages.") + (home-page "https://github.com/tfeb/conduit-packages/") + (license license:expat))) + +(define-public cl-conduit-packages + (sbcl-package->cl-source-package sbcl-conduit-packages)) + +(define-public ecl-conduit-packages + (sbcl-package->ecl-package sbcl-conduit-packages)) + +(define-public sbcl-conium + (let ((commit "089adfd8759ec7973bb6f67b98d7a246e67aeb05") + (revision "1")) (package - (name "sbcl-cl-libsvm-format") - (version (git-version "0.1.0" revision commit)) + (name "sbcl-conium") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/masatoi/cl-libsvm-format") + (url "https://github.com/sharplispers/conium") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "conium" version)) (sha256 - (base32 - "0284aj84xszhkhlivaigf9qj855fxad3mzmv3zfr0qzb5k0nzwrg")))) + (base32 "0y31za8xr8734p2pf8mrw1jd1fksh2d4y1p12wwjyn8hxxsvsx1w")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-prove)) (inputs - (list sbcl-alexandria)) - (synopsis "LibSVM data format reader for Common Lisp") + (list sbcl-closer-mop)) + (home-page "https://github.com/sharplispers/conium") + (synopsis "Portability library for debugger- and compiler-related tasks") (description - "This Common Lisp library provides a fast reader for data in LibSVM -format.") - (home-page "https://github.com/masatoi/cl-libsvm-format") - (license license:expat)))) + "Conium is a portability library for debugger- and compiler-related +tasks in Common Lisp. It is fork of SWANK-BACKEND.") + (license license:public-domain)))) -(define-public cl-libsvm-format - (sbcl-package->cl-source-package sbcl-cl-libsvm-format)) +(define-public cl-conium + (sbcl-package->cl-source-package sbcl-conium)) -(define-public ecl-cl-libsvm-format - (sbcl-package->ecl-package sbcl-cl-libsvm-format)) +(define-public ecl-conium + (sbcl-package->ecl-package sbcl-conium)) -(define-public sbcl-cl-online-learning - (let ((commit "87fbef8a340219e853adb3a5bf44a0470da76964") +(define-public sbcl-constantfold + (let ((commit "0ff1d97a3fbcb89264f6a2af6ce62b73e7b421f4") (revision "1")) (package - (name "sbcl-cl-online-learning") - (version (git-version "0.5" revision commit)) + (name "sbcl-constantfold") + (version (git-version "0.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/masatoi/cl-online-learning") + (url "https://github.com/numcl/constantfold") (commit commit))) - (file-name (git-file-name "cl-online-learning" version)) + (file-name (git-file-name name version)) (sha256 (base32 - "1lfq04lnxivx59nq5dd02glyqsqzf3vdn4s9b8wnaln5fs8g2ph9")))) + "153h0569z6bff1qbad0bdssplwwny75l7ilqwcfqfdvzsxf9jh06")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-prove)) - (inputs - `(("cl-libsvm-format" ,sbcl-cl-libsvm-format) - ("cl-store" ,sbcl-cl-store))) - (home-page "https://github.com/masatoi/cl-online-learning") - (synopsis "Online Machine Learning for Common Lisp") + (synopsis "Support library for numcl") (description - "This library contains a collection of machine learning algorithms for -online linear classification written in Common Lisp.") - (license license:expat)))) + "Support library for numcl. Registers a function as an +additional form that is considered as a candidate for a constant.") + (home-page "https://github.com/numcl/constantfold") + (license license:lgpl3+) + (inputs + `(("trivia" ,sbcl-trivia) + ("alexandria" ,sbcl-alexandria) + ("iterate" ,sbcl-iterate) + ("lisp-namespace" ,sbcl-lisp-namespace))) + (native-inputs + (list sbcl-fiveam))))) -(define-public cl-online-learning - (sbcl-package->cl-source-package sbcl-cl-online-learning)) +(define-public cl-constantfold + (sbcl-package->cl-source-package sbcl-constantfold)) -(define-public ecl-cl-online-learning - (sbcl-package->ecl-package sbcl-cl-online-learning)) +(define-public ecl-constantfold + (sbcl-package->ecl-package sbcl-constantfold)) -(define-public sbcl-cl-mpg123 - (let ((commit "5f042c839d2ea4a2ff2a7b60c839d8633d64161d") - (revision "1")) +(define-public sbcl-contextl + ;; No release since 2013. + (let ((commit "f4fb3f59b0844788613fc4d1cc0d2b08df9488bb") + (revision "2")) (package - (name "sbcl-cl-mpg123") + (name "sbcl-contextl") (version (git-version "1.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/Shirakumo/cl-mpg123") + (url "https://github.com/pcostanza/contextl/") (commit commit))) - (file-name (git-file-name "cl-mpg123" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "1hl721xaczxck008ax2y3jpkm509ry1sg3lklh2k76764m3ndrjf")) - (modules '((guix build utils))) - (snippet - '(begin - ;; Remove bundled pre-compiled libraries. - (delete-file-recursively "static") - #t)))) + (base32 "0apgznz4g6lpmd86lq7w0xddfjgnirk83ig7p0j6i93xadhy9wh0")))) (build-system asdf-build-system/sbcl) - (arguments - `(#: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)))) + (list sbcl-closer-mop sbcl-lw-compat)) + (home-page "https://github.com/pcostanza/contextl") + (synopsis "Context-oriented programming for Common Lisp") + (description "ContextL is a CLOS extension for Context-Oriented +Programming (COP). -(define-public ecl-cl-mpg123 - (sbcl-package->ecl-package sbcl-cl-mpg123)) +Find overview of ContextL's features in an overview paper: +@url{http://www.p-cos.net/documents/contextl-soa.pdf}. See also this general +overview article about COP which also contains some ContextL examples: +@url{http://www.jot.fm/issues/issue_2008_03/article4/}.") + (license license:expat)))) -(define-public cl-mpg123 - (sbcl-package->cl-source-package sbcl-cl-mpg123)) +(define-public cl-contextl + (sbcl-package->cl-source-package sbcl-contextl)) -(define-public sbcl-cl-out123 - (let ((commit "41771bfd419e7349ad569f8e6fcd8a26d6f9e5b7") - (revision "2")) +(define-public ecl-contextl + (sbcl-package->ecl-package sbcl-contextl)) + +(define-public sbcl-core-gp + (let ((commit "90ec1c4599a19c5a911be1f703f78d5108aee160") + (revision "1")) (package - (name "sbcl-cl-out123") - (version (git-version "1.0.0" revision commit)) + (name "sbcl-core-gp") + (version (git-version "0.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/Shirakumo/cl-out123") + (url "https://github.com/jorgetavares/core-gp") (commit commit))) - (file-name (git-file-name "cl-out123" version)) + (file-name (git-file-name "cl-core-gp" version)) (sha256 - (base32 "0ahgc5l5lbpl3ini4pn5crh8b7dlr386pxczl0d4h6djhccxzs4w")) - (modules '((guix build utils))) - (snippet - '(begin - ;; Remove bundled pre-compiled libraries. - (delete-file-recursively "static"))))) + (base32 "0nzlb2gwqisa1amlpl4zc5xxph2g3qwhfyaxchci67d31rzws6l3")))) (build-system asdf-build-system/sbcl) - (arguments - `(#:tests? #f ; No tests - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "low-level.lisp" - (("libout123.so") - (search-input-file inputs "/lib/libout123.so")))))))) - (inputs - (list mpg123 - sbcl-bordeaux-threads - sbcl-cffi - sbcl-documentation-utils - sbcl-trivial-features - sbcl-trivial-garbage)) - (home-page "https://shirakumo.github.io/cl-out123/") - (synopsis "Common Lisp bindings to libout123") + (home-page "https://github.com/jorgetavares/core-gp") + (synopsis "Common Lisp library for genetic programming") (description - "This is a bindings library to @code{libout123} which allows easy -cross-platform audio playback.") - (license license:zlib)))) + "@code{core-gp} is a Common Lisp library for genetic programming (GP) +algorithms. It allows standard GP, strongly-typed GP, grammatical evolution as +well as standard genetic algorithms.") + (license license:expat)))) -(define-public ecl-cl-out123 - (sbcl-package->ecl-package sbcl-cl-out123)) +(define-public cl-core-gp + (sbcl-package->cl-source-package sbcl-core-gp)) -(define-public cl-out123 - (sbcl-package->cl-source-package sbcl-cl-out123)) +(define-public ecl-core-gp + (sbcl-package->ecl-package sbcl-core-gp)) -(define-public sbcl-cl-portaudio - (let ((commit "c50cd061c25216a736f684e45101f5c0188a384f") +(define-public sbcl-croatoan + (let ((commit "282145ff9e9005fddc4241bc6827b3ab09c5bd25") (revision "1")) (package - (name "sbcl-cl-portaudio") - (version (git-version "1.0.0" revision commit)) + (name "sbcl-croatoan") + (version (git-version "2.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/filonenko-mikhail/cl-portaudio") + (url "https://github.com/McParen/croatoan") (commit commit))) - (file-name (git-file-name "cl-portaudio" version)) + (file-name (git-file-name "cl-croatoan" version)) (sha256 - (base32 "177c6bgf30caj5qpzfnzhbamax7c5zm2p4911mw7fay94vjs7zyb")))) + (base32 "021h2f2yj4j9gynr3k7qi36x94jm5b95p3vaddbaih96wyzgbmq5")))) (build-system asdf-build-system/sbcl) - (inputs - (list portaudio sbcl-cffi sbcl-ffa)) (arguments - (list #:tests? #f ; Tests need access to sound cards - #:phases - #~(modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "src/portaudio.lisp" - (("libportaudio\\.so") - (search-input-file inputs "/lib/libportaudio.so")))))))) - (synopsis "Common Lisp bindings to portaudio") - (description - "This package provides audio input and output functions to Common Lisp -using bindings to the portaudio library.") - (home-page "https://github.com/filonenko-mikhail/cl-portaudio") + '(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'fix-paths + (lambda* (#:key inputs #:allow-other-keys) + (substitute* "ncurses/ncurses.lisp" + (("libncursesw.so") + (search-input-file inputs "/lib/libncursesw.so")))))))) + (inputs + (list ncurses + sbcl-cffi + sbcl-trivial-gray-streams + sbcl-bordeaux-threads)) + (synopsis "Common Lisp bindings for the ncurses terminal library") + (description "Croatoan provides high-level Common Lisp CLOS bindings for +the ncurses terminal library.") + (home-page "https://github.com/McParen/croatoan") (license license:expat)))) -(define-public cl-portaudio - (sbcl-package->cl-source-package sbcl-cl-portaudio)) +(define-public cl-croatoan + (sbcl-package->cl-source-package sbcl-croatoan)) -(define-public ecl-cl-portaudio - (sbcl-package->ecl-package sbcl-cl-portaudio)) +(define-public ecl-croatoan + (sbcl-package->ecl-package sbcl-croatoan)) -(define-public sbcl-cl-random-forest - (let ((commit "fedb36ce99bb6f4d7e3a7dd6d8b058f331308f91") +(define-public sbcl-crypto-shortcuts + (let ((commit "7efd22d80e867cd8c9f8f363d4fe7b51ee2dadc0") (revision "1")) (package - (name "sbcl-cl-random-forest") - (version (git-version "0.1" revision commit)) + (name "sbcl-crypto-shortcuts") + (version (git-version "2.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/masatoi/cl-random-forest") + (url "https://github.com/Shinmera/crypto-shortcuts") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "crypto-shortcuts" version)) (sha256 - (base32 - "0wqh4dxy5hrvm14jgyfypwhdw35f24rsksid4blz5a6l2z16rlmq")))) + (base32 "0c0m0ar04jn7qf2v8c4sivamlzki03r13rnxy8b3n27rh9r6hgin")))) (build-system asdf-build-system/sbcl) - (native-inputs - `(("prove" ,sbcl-prove) - ("trivial-garbage" ,sbcl-trivial-garbage))) (inputs - `(("alexandria" ,sbcl-alexandria) - ("cl-libsvm-format" ,sbcl-cl-libsvm-format) - ("cl-online-learning" ,sbcl-cl-online-learning) - ("lparallel" ,sbcl-lparallel))) - (arguments - `(#:tests? #f)) ; The tests download data from the Internet - (synopsis "Random Forest and Global Refinement for Common Lisp") + (list sbcl-cl-base64 sbcl-flexi-streams sbcl-ironclad)) + (synopsis "Collection of common cryptography functions") (description - "CL-random-forest is an implementation of Random Forest for multiclass -classification and univariate regression written in Common Lisp. It also -includes an implementation of Global Refinement of Random Forest.") - (home-page "https://github.com/masatoi/cl-random-forest") - (license license:expat)))) + "This is a collection of common cryptography functions for Common +Lisp.") + (home-page "https://shinmera.github.io/crypto-shortcuts/") + (license license:zlib)))) -(define-public cl-random-forest - (sbcl-package->cl-source-package sbcl-cl-random-forest)) +(define-public cl-crypto-shortcuts + (sbcl-package->cl-source-package sbcl-crypto-shortcuts)) -(define-public ecl-cl-random-forest - (sbcl-package->ecl-package sbcl-cl-random-forest)) +(define-public ecl-crypto-shortcuts + (sbcl-package->ecl-package sbcl-crypto-shortcuts)) -(define-public sbcl-bordeaux-fft - (let ((commit "4a1f5600cae59bdabcb32de4ee2d7d73a9450d6e") +(define-public sbcl-css-lite + (let ((commit "6ee4e6212ed56943d665df163d2a834b122e6273") (revision "0")) (package - (name "sbcl-bordeaux-fft") - (version (git-version "1.0.1" revision commit)) + (name "sbcl-css-lite") + (version "0.01") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/paddymul/css-lite") + (commit commit))) + (sha256 + (base32 "1lyvw7hcy09k5qs6icky23s13psqxncyc73hdyiimb66p0jx6k0d")) + (file-name (git-file-name "cl-css-lite" commit)))) + (build-system asdf-build-system/sbcl) + (home-page "https://github.com/paddymul/css-lite") + (synopsis "CSS grammar for Lisp") + (description + "@code{cl-css-lite} is a library for generating CSS from an s-exp based +syntax. When compiled with Parenscript loaded in the Lisp image, it +also provides the same CSS generation facilities in Parenscript-generated +JavaScript code.") + (license license:bsd-3)))) + +(define-public cl-css-lite + (sbcl-package->cl-source-package sbcl-css-lite)) + +(define-public ecl-css-lite + (sbcl-package->ecl-package sbcl-css-lite)) + +(define-public sbcl-ctype + (let ((commit "4fc4c5ae44c435ed82556969f698005bee50101c")) + (package + (name "sbcl-ctype") + (version (git-version "0.0.0" "1" commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/ahefner/bordeaux-fft") + (url "https://github.com/s-expressionists/ctype") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-ctype" version)) (sha256 - (base32 "0j584w6kq2k6r8lp2i14f9605rxhp3r15s33xs08iz1pndn6iwqf")))) + (base32 "05smc81ml9rbcbzdhqg2mi9drnjsipq62r5q7f7qql8hbx01vl9i")))) (build-system asdf-build-system/sbcl) - (home-page "http://vintage-digital.com/hefner/software/bordeaux-fft/") - (synopsis "Fast Fourier Transform for Common Lisp") + (inputs + (list sbcl-alexandria)) + (arguments + '(#:asd-systems '("ctype" "ctype-tfun"))) + (home-page "https://github.com/s-expressionists/ctype") + (synopsis "Common Lisp type system implementation") (description - "The Bordeaux-FFT library provides a reasonably efficient implementation -of the Fast Fourier Transform and its inverse for complex-valued inputs, in -portable Common Lisp.") - (license license:gpl2+)))) + "This system is an implementation of the Common Lisp type system; +particularly @code{cl:typep} and @code{cl:subtypep}.") + (license license:bsd-2)))) -(define-public cl-bordeaux-fft - (sbcl-package->cl-source-package sbcl-bordeaux-fft)) +(define-public cl-ctype + (sbcl-package->cl-source-package sbcl-ctype)) -(define-public ecl-bordeaux-fft - (sbcl-package->ecl-package sbcl-bordeaux-fft)) +(define-public ecl-ctype + (sbcl-package->ecl-package sbcl-ctype)) -(define-public sbcl-napa-fft3 - (let ((commit "f2d9614c7167da327c9ceebefb04ff6eae2d2236") +(define-public sbcl-curry-compose-reader-macros + (let ((commit "beaa92dedf392726c042184bfd6149fa8d9e6ac2") (revision "0")) (package - (name "sbcl-napa-fft3") - (version (git-version "0.0.1" revision commit)) + (name "sbcl-curry-compose-reader-macros") + (version (git-version "1.0.0" revision commit)) (source (origin (method git-fetch) - (uri (git-reference - (url "https://github.com/pkhuong/Napa-FFT3") - (commit commit))) + (uri + (git-reference + (url "https://github.com/eschulte/curry-compose-reader-macros") + (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 "1hxjf599xgwm28gbryy7q96j9ys6hfszmv0qxpr5698hxnhknscp")))) + (base32 + "0rv9bl8xrad5wfcg5zs1dazvnpmvqz6297lbn8bywsrcfnlf7h98")))) (build-system asdf-build-system/sbcl) - (home-page "https://github.com/pkhuong/Napa-FFT3") - (synopsis "Fast Fourier Transform routines in Common Lisp") + (inputs + (list sbcl-alexandria sbcl-named-readtables)) + (synopsis "Reader macros for partial application and composition") (description - "Napa-FFT3 provides Discrete Fourier Transform (DFT) routines, but also -buildings blocks to express common operations that involve DFTs: filtering, -convolutions, etc.") - (license license:bsd-3)))) + "This Common Lisp library provides reader macros for concise expression +of function partial application and composition.") + (home-page "https://eschulte.github.io/curry-compose-reader-macros/") + (license license:public-domain)))) -(define-public cl-napa-fft3 - (sbcl-package->cl-source-package sbcl-napa-fft3)) +(define-public cl-curry-compose-reader-macros + (sbcl-package->cl-source-package sbcl-curry-compose-reader-macros)) -(define-public sbcl-cl-tga - (let ((commit "4dc2f7b8a259b9360862306640a07a23d4afaacc") - (revision "0")) +(define-public ecl-curry-compose-reader-macros + (sbcl-package->ecl-package sbcl-curry-compose-reader-macros)) + +(define-public sbcl-custom-hash-table + (let ((commit "f26983133940f5edf826ebbc8077acc04816ddfa")) (package - (name "sbcl-cl-tga") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-custom-hash-table") + (version (git-version "0.3" "1" commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/fisxoj/cl-tga") + (url "https://github.com/metawilm/cl-custom-hash-table") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 "03k3npmn0xd3fd2m7vwxph82av2xrfb150imqrinlzqmzvz1v1br")))) + (base32 "1k4mvrpbqqds2fwjxp1bxmrfmr8ch4dkwhnkbw559knbqshvrlj5")))) (build-system asdf-build-system/sbcl) - (home-page "https://github.com/fisxoj/cl-tga") - (synopsis "TGA file loader for Common Lisp") - (description - "Cl-tga was written to facilitate loading @emph{.tga} files into OpenGL -programs. It's a very simple library, and, at the moment, only supports -non-RLE encoded forms of the files.") + (arguments + '(#:asd-systems '("cl-custom-hash-table"))) + (home-page "https://github.com/metawilm/cl-custom-hash-table") + (synopsis "Custom hash tables for Common Lisp") + (description "This library allows creation of hash tables with arbitrary +@code{test}/@code{hash} functions, in addition to the @code{test} functions +allowed by the standard (@code{EQ}, @code{EQL}, @code{EQUAL} and +@code{EQUALP}), even in implementations that don't support this functionality +directly.") (license license:expat)))) -(define-public cl-tga - (sbcl-package->cl-source-package sbcl-cl-tga)) +(define-public cl-custom-hash-table + (sbcl-package->cl-source-package sbcl-custom-hash-table)) -(define-public ecl-cl-tga - (sbcl-package->ecl-package sbcl-cl-tga)) +(define-public ecl-custom-hash-table + (sbcl-package->ecl-package sbcl-custom-hash-table)) -(define-public sbcl-com.gigamonkeys.binary-data - (let ((commit "22e908976d7f3e2318b7168909f911b4a00963ee") - (revision "0")) +(define-public sbcl-cxml + (let ((commit "00b22bf4c4cf11c993d5866fae284f95ab18e6bf") + (revision "1")) (package - (name "sbcl-com.gigamonkeys.binary-data") + (name "sbcl-cxml") (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/gigamonkey/monkeylib-binary-data") + (url "https://github.com/sharplispers/cxml") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 "072v417vmcnvmyh8ddq9vmwwrizm7zwz9dpzi14qy9nsw8q649zw")))) + (base32 + "13kif7rf3gqdycsk9zq0d7y0g9y81krkl0z87k0p2fkbjfgrph37")))) (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-alexandria)) - (home-page "https://github.com/gigamonkey/monkeylib-binary-data") - (synopsis "Common Lisp library for reading and writing binary data") - (description - "This a Common Lisp library for reading and writing binary data. It is -based on code from chapter 24 of the book @emph{Practical Common Lisp}.") - (license license:bsd-3)))) - -(define-public cl-com.gigamonkeys.binary-data - (sbcl-package->cl-source-package sbcl-com.gigamonkeys.binary-data)) - -(define-public ecl-com.gigamonkeys.binary-data - (sbcl-package->ecl-package sbcl-com.gigamonkeys.binary-data)) - -(define-public sbcl-deflate - (package - (name "sbcl-deflate") - (version "1.0.3") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/pmai/Deflate") - (commit (string-append "release-" version)))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1jpdjnxh6cw2d8hk70r2sxn92is52s9b855irvwkdd777fdciids")))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/pmai/Deflate") - (synopsis "Native deflate decompression for Common Lisp") - (description - "This library is an implementation of Deflate (RFC 1951) decompression, -with optional support for ZLIB-style (RFC 1950) and gzip-style (RFC 1952) -wrappers of deflate streams. It currently does not handle compression.") - (license license:expat))) + (inputs + (list sbcl-closure-common sbcl-puri sbcl-trivial-gray-streams)) + (synopsis "Common Lisp XML parser") + (description "CXML implements a namespace-aware, validating XML 1.0 +parser as well as the DOM Level 2 Core interfaces. Two parser interfaces are +offered, one SAX-like, the other similar to StAX.") + (home-page "https://common-lisp.net/project/cxml/") + (license license:llgpl)))) -(define-public cl-deflate - (sbcl-package->cl-source-package sbcl-deflate)) +(define-public cl-cxml + (sbcl-package->cl-source-package sbcl-cxml)) -(define-public ecl-deflate - (sbcl-package->ecl-package sbcl-deflate)) +(define-public ecl-cxml + (sbcl-package->ecl-package sbcl-cxml)) -(define-public sbcl-skippy - (let ((commit "e456210202ca702c792292c5060a264d45e47090") - (revision "0")) +(define-public sbcl-cxml-rng + (let ((commit "bdcfeb92798694b2935a8321e641d8803e814b7b") + (revision "1")) (package - (name "sbcl-skippy") - (version (git-version "1.3.12" revision commit)) + (name "sbcl-cxml-rng") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/xach/skippy") + (url "http://www.lichteblau.com/git/cxml-rng.git") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 "1sxbn5nh24qpx9w64x8mhp259cxcl1x8p126wk3b91ijjsj7l5vj")))) + (base32 + "1rld038hmvm0whaffkszd5ks7mg44z1vfbgddal434df8sgspzql")))) (build-system asdf-build-system/sbcl) - (home-page "https://xach.com/lisp/skippy/") - (synopsis "Common Lisp library for GIF images") - (description - "Skippy is a Common Lisp library to read and write GIF image files.") - (license license:bsd-2)))) + (inputs + (list sbcl-cxml sbcl-cl-ppcre sbcl-cl-yacc sbcl-parse-number + sbcl-cl-base64)) + (synopsis "Relax NG for Closure XML (CXML)") + (description "An implementation of Relax NG schema validation written in +Common Lisp, including support for compact syntax, DTD Compatibility, and the +XSD type library.") + (home-page "http://www.lichteblau.com/cxml-rng/") + (license license:bsd-2)))) -(define-public cl-skippy - (sbcl-package->cl-source-package sbcl-skippy)) +(define-public cl-cxml-rng + (sbcl-package->cl-source-package sbcl-cxml-rng)) -(define-public ecl-skippy - (sbcl-package->ecl-package sbcl-skippy)) +;; FIXME: Fails on ECL with +;; In function STRUCTURE-SET, the value of the first argument is +;; #<empty 0x7fffeb0fd440> +;; which is not of the expected type %TYPED-PATTERN. +;; (define-public ecl-cxml-rng +;; (sbcl-package->ecl-package sbcl-cxml-rng)) -(define-public sbcl-cl-freetype2 - (let ((commit "8bcb232b319a66fb700eaea88d0b308a837bce04") +(define-public sbcl-daemon + (let ((commit "d5652f4332c3cee21e9bf83b9237129605004597") (revision "1")) (package - (name "sbcl-cl-freetype2") - (version (git-version "1.1" revision commit)) + (name "sbcl-daemon") + (version (git-version "0.0.4" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/rpav/cl-freetype2") + (url "https://github.com/snmsts/daemon") (commit commit))) - (file-name (git-file-name "cl-freetype2" version)) + (file-name (git-file-name "daemon" version)) (sha256 - (base32 "1nhq3qslja0bcgpbmzfycqhd4vw1l58zh4ia15m1h6535qxliy0q")))) + (base32 "1kdxfnhh9fz34j8qs7pn7mwjz3v33q4v9nh0hqkyzraq5xs2j3f4")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-fiveam)) (inputs - (list freetype - sbcl-alexandria - sbcl-cffi - sbcl-trivial-garbage)) - (arguments - `(#:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "src/ffi/ft2-lib.lisp" - (("\"libfreetype\"") - (string-append "\"" (assoc-ref inputs "freetype") - "/lib/libfreetype\""))) - (substitute* "src/ffi/grovel/grovel-freetype2.lisp" - (("-I/usr/include/freetype") - (string-append "-I" (assoc-ref inputs "freetype") - "/include/freetype"))) - #t))))) - (home-page "https://github.com/rpav/cl-freetype2") - (synopsis "Common Lisp bindings for Freetype 2") + (list sbcl-trivial-features)) + (home-page "https://github.com/snmsts/daemon") + (synopsis "Daemonize Common Lisp processes") (description - "This is a general Freetype 2 wrapper for Common Lisp using CFFI. It's -geared toward both using Freetype directly by providing a simplified API, as -well as providing access to the underlying C structures and functions for use -with other libraries which may also use Freetype.") - (license license:bsd-3)))) + "DAEMON provides the functionality of daemonizing Common Lisp processes +on UNIX like platforms.") + (license license:expat)))) -(define-public cl-freetype2 - (sbcl-package->cl-source-package sbcl-cl-freetype2)) +(define-public cl-daemon + (sbcl-package->cl-source-package sbcl-daemon)) -(define-public ecl-cl-freetype2 - (sbcl-package->ecl-package sbcl-cl-freetype2)) +(define-public ecl-daemon + (sbcl-package->ecl-package sbcl-daemon)) -(define-public sbcl-opticl-core - (let ((commit "b7cd13d26df6b824b216fbc360dc27bfadf04999") - (revision "0")) +(define-public sbcl-data-format-validation + (let ((commit "95d44766e829582598f9dcdc5c23719c462d5bfb") + (revision "1")) (package - (name "sbcl-opticl-core") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-data-format-validation") + (version (git-version "0.2.0" revision commit)) (source (origin (method git-fetch) - (uri (git-reference - (url "https://github.com/slyrus/opticl-core") - (commit commit))) - (file-name (git-file-name name version)) + (uri + (git-reference + (url "https://github.com/willijar/cl-data-format-validation/") + (commit commit))) + (file-name (git-file-name "data-format-validation" version)) (sha256 - (base32 "0458bllabcdjghfrqx6aki49c9qmvfmkk8jl75cfpi7q0i12kh95")))) + (base32 + "0zmk47xmicyqvp1impn8kgh5373ysmx3gfpqcvbi9r31qsir2nqa")))) (build-system asdf-build-system/sbcl) (inputs - (list sbcl-alexandria)) - (home-page "https://github.com/slyrus/opticl-core") - (synopsis "Core classes and pixel access macros for Opticl") + (list sbcl-cl-ppcre)) + (synopsis "Validation and conversion between user and internal data") (description - "This Common Lisp library contains the core classes and pixel access -macros for the Opticl image processing library.") - (license license:bsd-2)))) - -(define-public cl-opticl-core - (sbcl-package->cl-source-package sbcl-opticl-core)) - -(define-public ecl-opticl-core - (sbcl-package->ecl-package sbcl-opticl-core)) + "@code{data-format-validation} is a library for Common Lisp providing a +consistent regular interface for converting (and validating) external data (in +the form of strings usually) into internal data types and for formatting +internal data back into external presentable strings, all according to a +conversion or type specification.") + (home-page "http://www.jarw.org.uk/lisp/cl-data-format-validation.html") + (license license:gpl3)))) -(define-public sbcl-retrospectiff - (let ((commit "2fbf8c687799487654d988c7036d19d75a7fc67d") - (revision "1")) +(define-public sbcl-data-frame + (let ((commit "6f02e58312654ddf19d686f234dcf699fc4cd0f5") + (revision "0")) (package - (name "sbcl-retrospectiff") - (version (git-version "0.2" revision commit)) + (name "sbcl-data-frame") + (version (git-version "1.1.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/slyrus/retrospectiff") + (url "https://github.com/Lisp-Stat/data-frame") (commit commit))) - (file-name (git-file-name "cl-retrospectiff" version)) + (file-name (git-file-name "cl-data-frame" version)) (sha256 - (base32 "1vfcbfzhkm2wkxnjg7y6gg93wlib9cqpbdbhyqcm5kc7170ci3vz")))) + (base32 "0bs1jh66bml25bj1lxdzz8cjhj3g060yyd5ggqsnsr4l2j0zyszv")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-fiveam)) + (native-inputs (list sbcl-clunit2)) (inputs - (list sbcl-cl-jpeg - sbcl-com.gigamonkeys.binary-data - sbcl-deflate - sbcl-flexi-streams - sbcl-ieee-floats - sbcl-opticl-core)) - (home-page "https://github.com/slyrus/retrospectiff") - (synopsis "Common Lisp library for TIFF images") - (description - "Retrospectiff is a common lisp library for reading and writing images -in the TIFF (Tagged Image File Format) format.") - (license license:bsd-2)))) + (list sbcl-alexandria + sbcl-alexandria-plus + sbcl-anaphora + sbcl-array-operations + sbcl-duologue + sbcl-let-plus + sbcl-numerical-utilities + sbcl-select + sbcl-serapeum + sbcl-statistics)) + (home-page "https://lisp-stat.dev/docs/manuals/data-frame/") + (synopsis "Data frames for Common Lisp") + (description "This package provides data frames for Common Lisp, a +two-dimensional array-like structure in which each column contains values +of one variable and each row contains one set of values from each column.") + (license license:ms-pl)))) -(define-public cl-retrospectif - (sbcl-package->cl-source-package sbcl-retrospectiff)) +(define-public cl-data-frame + (sbcl-package->cl-source-package sbcl-data-frame)) -(define-public ecl-retrospectiff - (sbcl-package->ecl-package sbcl-retrospectiff)) +;; The data-frame system depends on the sb-cltl2 system, which is only +;; available with SBCL. +;; (define-public ecl-data-frame +;; (sbcl-package->ecl-package sbcl-data-frame)) -(define-public sbcl-mmap - (let ((commit "ba2e98c67e25f0fb8ff838238561120a23903ce7") +(define-public sbcl-data-lens + (let ((commit "801bc1e0331f19fdc38be314c86ccac9362fde78") (revision "0")) (package - (name "sbcl-mmap") - (version (git-version "1.0.0" revision commit)) - (source + (name "sbcl-data-lens") + (version (git-version "0.0.0" revision commit)) + (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/Shinmera/mmap") + (url "https://github.com/fiddlerwoaroof/data-lens") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-data-lens" version)) (sha256 - (base32 "0qd0xp20i1pcfn12kkapv9pirb6hd4ns7kz4zf1mmjwykpsln96q")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-alexandria sbcl-cffi sbcl-parachute - sbcl-trivial-features)) - (inputs - (list sbcl-cffi sbcl-documentation-utils)) - (home-page "https://shinmera.github.io/mmap/") - (synopsis "File memory mapping for Common Lisp") - (description - "This is a utility library providing access to the @emph{mmap} family of -functions in a portable way. It allows you to directly map a file into the -address space of your process without having to manually read it into memory -sequentially. Typically this is much more efficient for files that are larger -than a few Kb.") - (license license:zlib)))) + (base32 "1w4rvhcnss037q0bb1j70kdlhfh9085hy95d9q56sk519alhzhrp")))) + (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-fiveam)) + (inputs + (list sbcl-cl-ppcre + sbcl-alexandria + sbcl-serapeum)) + (synopsis "Functional utilities for Common Lisp") + (description + "The @code{cl-data-lens} library provides a language for expressing data +manipulations as the composition of more primitive operations.") + (home-page "https://fiddlerwoaroof.github.io/data-lens/") + (license license:asl2.0)))) -(define-public cl-mmap - (sbcl-package->cl-source-package sbcl-mmap)) +(define-public cl-data-lens + (sbcl-package->cl-source-package sbcl-data-lens)) -(define-public ecl-mmap - (sbcl-package->ecl-package sbcl-mmap)) +(define-public ecl-data-lens + (sbcl-package->ecl-package sbcl-data-lens)) -(define-public sbcl-marray - (let ((commit "0352f316b6830f0b119088ba9be836e4726bd7d8") - (revision "0")) +(define-public sbcl-data-sift + (let ((commit "fd617d8200cdcc1b87ecf45ab59bb38e8b16ef7e") + (revision "1")) (package - (name "sbcl-marray") + (name "sbcl-data-sift") (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/death/marray") + (url "https://github.com/archimag/data-sift") (commit commit))) - (file-name (git-file-name "cl-marray" version)) + (file-name (git-file-name "cl-data-sift" version)) (sha256 - (base32 "0l4kvzpiw14vqhlsaflp3c7y51vznjjgbdi0q3axqk1wxvzy1zlx")))) + (base32 "1v7gf0x4ibjzp0c56n9m77hxdgwcm9356zlk5n4l3fx4i0hj6146")))) (build-system asdf-build-system/sbcl) (arguments - '(#:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-dependencies - (lambda _ - (substitute* "marray.asd" - ((":components") - ":depends-on (#+sbcl \"sb-posix\")\n :components"))))))) - (home-page "https://github.com/death/marray") - (synopsis "Memory-mapped files as Common Lisp arrays") + ;; All test cases test a function that has been removed. + `(#:tests? #f)) + (inputs + `(("alexandria" ,sbcl-alexandria) + ("cl-ppcre" ,sbcl-cl-ppcre) + ("parse-number" ,sbcl-parse-number) + ("puri" ,sbcl-puri))) + (native-inputs + (list sbcl-lift)) + (home-page "https://github.com/archimag/data-sift") + (synopsis + "Common Lisp library for validation and transformation of string data") (description - "MARRAY is a library which provides access to memory-mapped files -through Common Lisp arrays.") - (license license:expat)))) + "@code{DATA-SIFT} is a Common Lisp data validation and transformation +library inspired by @code{cl-data-format-validation} and WTForms validators.") + (license license:llgpl)))) -(define-public cl-marray - (sbcl-package->cl-source-package sbcl-marray)) +(define-public cl-data-sift + (sbcl-package->cl-source-package sbcl-data-sift)) -;; ECL support not implemented yet. -;; (define-public ecl-marray -;; (sbcl-package->ecl-package sbcl-marray)) +(define-public ecl-data-sift + (sbcl-package->ecl-package sbcl-data-sift)) -(define-public sbcl-3bz - (let ((commit "569614c40408f3aefc77ba233e0e4bd66d3850ad") +(define-public sbcl-datafly + (let ((commit "adece27fcbc4b5ea39ad1a105048b6b7166e3b0d") (revision "1")) (package - (name "sbcl-3bz") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-datafly") + (version (git-version "0.1" revision commit)) + (home-page "https://github.com/fukamachi/datafly") (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/3b/3bz") + (url home-page) (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 "0kvvlvf50jhhw1s510f3clpr1a68632bq6d698yxcrx722igcrg4")))) + (base32 "16b78kzmglp2a4nxlxxl7rpf5zaibsgagn0p3c56fsxvx0c4hszv")))) (build-system asdf-build-system/sbcl) (inputs - (list sbcl-alexandria - sbcl-babel - sbcl-cffi - sbcl-mmap - sbcl-nibbles - sbcl-trivial-features)) - (home-page "https://github.com/3b/3bz") - (synopsis "Deflate decompression for Common Lisp") - (description - "3bz is an implementation of Deflate decompression (RFC 1951) optionally -with zlib (RFC 1950) or gzip (RFC 1952) wrappers, with support for reading from -foreign pointers (for use with mmap and similar, etc), and from CL octet -vectors and streams.") - (license license:expat)))) - -(define-public cl-3bz - (sbcl-package->cl-source-package sbcl-3bz)) - -(define-public ecl-3bz - (sbcl-package->ecl-package sbcl-3bz)) - -(define-public sbcl-zpb-exif - (package - (name "sbcl-zpb-exif") - (version "1.2.5") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/xach/zpb-exif") - (commit (string-append "release-" version)))) - (file-name (git-file-name "cl-zpb-exif" version)) - (sha256 - (base32 "0h1n36lfl8xn8rfyl5jxz9m8zlg0if2avmryas79f684yczrvdnd")))) - (build-system asdf-build-system/sbcl) - (home-page "https://xach.com/lisp/zpb-exif/") - (synopsis "EXIF information extractor for Common Lisp") - (description - "This is a Common Lisp library to extract EXIF information from image -files.") - (license license:bsd-2))) + `(("alexandria" ,sbcl-alexandria) + ("iterate" ,sbcl-iterate) + ("optima" ,sbcl-optima) + ("trivial-types" ,sbcl-trivial-types) + ("closer-mop" ,sbcl-closer-mop) + ("cl-syntax" ,sbcl-cl-syntax) + ("sxql" ,sbcl-sxql) + ("dbi" ,sbcl-dbi) + ("babel" ,sbcl-babel) + ("local-time" ,sbcl-local-time) + ("function-cache" ,sbcl-function-cache) + ("jonathan" ,sbcl-jonathan) + ("kebab" ,sbcl-kebab) + ("log4cl" ,sbcl-log4cl))) + (native-inputs + (list sbcl-prove)) + (arguments + ;; TODO: Tests fail with + ;; While evaluating the form starting at line 22, column 0 + ;; of #P"/tmp/guix-build-sbcl-datafly-0.1-1.adece27.drv-0/source/t/datafly.lisp": + ;; Unhandled SQLITE:SQLITE-ERROR in thread #<SB-THREAD:THREAD "main thread" RUNNING + ;; {10009F8083}>: + ;; Error when binding parameter 1 to value NIL. + ;; Code RANGE: column index out of range. + `(#:tests? #f)) + (synopsis "Lightweight database library for Common Lisp") + (description "Datafly is a lightweight database library for Common Lisp.") + (license license:bsd-3)))) -(define-public cl-zpb-exif - (sbcl-package->cl-source-package sbcl-zpb-exif)) +(define-public cl-datafly + (sbcl-package->cl-source-package sbcl-datafly)) -(define-public ecl-zpb-exif - (sbcl-package->ecl-package sbcl-zpb-exif)) +(define-public ecl-datafly + (sbcl-package->ecl-package sbcl-datafly)) -(define-public sbcl-pngload - (let ((commit "91f1d703c65bb6a94d6fee06ddbbbbbc5778b71f") - (revision "2")) +(define-public sbcl-db3 + (let ((commit "38e5ad35f025769fb7f8dcdc6e56df3e8efd8e6d") + (revision "1")) (package - (name "sbcl-pngload") - (version (git-version "2.0.0" revision commit)) + (name "sbcl-db3") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://git.mfiano.net/mfiano/pngload.git") + (url "https://github.com/dimitri/cl-db3") (commit commit))) - (file-name (git-file-name "pngload" version)) + (file-name (git-file-name "cl-db3" version)) (sha256 - (base32 "0s94fdbrbqj12qvgyn2g4lfwvz7qhhzbclrpz5ni7adwxgrmvxl1")))) + (base32 "1i7j0mlri6kbklcx1lsm464s8kmyhhij5c4xh4aybrw8m4ixn1s5")))) (build-system asdf-build-system/sbcl) - (inputs - `(("3bz" ,sbcl-3bz) - ("alexandria" ,sbcl-alexandria) - ("cffi" ,sbcl-cffi) - ("mmap" ,sbcl-mmap) - ("parse-float" ,sbcl-parse-float) - ("static-vectors" ,sbcl-static-vectors) - ("swap-bytes" ,sbcl-swap-bytes) - ("zpb-exif" ,sbcl-zpb-exif))) - (arguments - ;; Test suite disabled because of a dependency cycle. - ;; pngload tests depend on opticl which depends on pngload. - '(#:tests? #f)) - (home-page "https://git.mfiano.net/mfiano/pngload.git") - (synopsis "PNG image decoder for Common Lisp") + (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 to load images in the PNG image format, -both from files on disk, or streams in memory.") - (license license:expat)))) + "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 cl-pngload - (sbcl-package->cl-source-package sbcl-pngload)) +(define-public cl-db3 + (sbcl-package->cl-source-package sbcl-db3)) -(define-public ecl-pngload - (sbcl-package->ecl-package sbcl-pngload)) +(define-public ecl-db3 + (sbcl-package->ecl-package sbcl-db3)) -(define-public sbcl-opticl - (let ((commit "f6fc4dc5fa61ae3f2527b77e4bda99001ba37dcb") - (revision "1")) +(define-public sbcl-dbi + (let ((commit "738a74dd69adb2a7c21fa67e140d89c7df25b227") + (revision "2")) (package - (name "sbcl-opticl") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-dbi") + (version (git-version "0.9.5" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/slyrus/opticl") + (url "https://github.com/fukamachi/cl-dbi") (commit commit))) - (file-name (git-file-name "cl-opticl" version)) + (file-name (git-file-name "cl-dbi" version)) (sha256 - (base32 "1jx9n78d4lf53iz24yid34l92zrpqxfihv6049ixcy0xigf7j4ac")))) + (base32 "0f8z7an8ssg8mdf9k781r4ygdppv798v6f08ibgpd8mv8a6491fg")))) (build-system asdf-build-system/sbcl) (native-inputs - (list sbcl-fiveam)) + `(("alexandria" ,sbcl-alexandria) + ("rove" ,sbcl-rove) + ("trivial-types" ,sbcl-trivial-types))) (inputs - (list sbcl-alexandria - sbcl-cl-jpeg - sbcl-cl-tga - sbcl-opticl-core - sbcl-png-read - sbcl-pngload - sbcl-retrospectiff - sbcl-skippy - sbcl-zpng)) - (home-page "https://github.com/slyrus/opticl") - (synopsis "Image processing library for Common Lisp") + `(("bordeaux-threads" ,sbcl-bordeaux-threads) + ("cl-mysql" ,sbcl-cl-mysql) + ("cl-sqlite" ,sbcl-cl-sqlite) + ("closer-mop" ,sbcl-closer-mop) + ("postmodern" ,sbcl-postmodern) + ("split-sequence" ,sbcl-split-sequence) + ("trivial-garbage" ,sbcl-trivial-garbage))) + (arguments + `(#:asd-systems '("dbi" + "dbd-mysql" + "dbd-postgres" + "dbd-sqlite3"))) + (synopsis "Database independent interface for Common Lisp") (description - "Opticl is a Common Lisp library for representing, processing, loading, -and saving 2-dimensional pixel-based images.") - (license license:bsd-2)))) + "@code{dbi} is a Common Lisp library providing a database independent +interface for MySQL, PostgreSQL and SQLite.") + (home-page "https://github.com/fukamachi/cl-dbi") + (license license:llgpl)))) -(define-public cl-opticl - (sbcl-package->cl-source-package sbcl-opticl)) +(define-public cl-dbi + (sbcl-package->cl-source-package sbcl-dbi)) -(define-public ecl-opticl - (sbcl-package->ecl-package sbcl-opticl)) +(define-public ecl-dbi + (sbcl-package->ecl-package sbcl-dbi)) -(define-public sbcl-cl-dejavu - (let ((commit "9d68ced4edee6f96fead42cb4835d0ff4a158373") +(define-public sbcl-dbus + (let ((commit "24b452df3a45ca5dc95015500f34baad175c981a") (revision "1")) (package - (name "sbcl-cl-dejavu") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-dbus") + (version (git-version "20190408" revision commit)) + (home-page "https://github.com/death/dbus") (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/dkochmanski/cl-dejavu") + (url home-page) (commit commit))) - (file-name (git-file-name "cl-dejavu" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "1lbxiq21bxj8r11c58cqskgn8gnl2p8q1ydkhdsv7i7xnhv2y7r0")))) + (base32 + "0fw2q866yddbf23nk9pxphm9gsasx35vjyss82xzvndnjmzlqfl5")))) (build-system asdf-build-system/sbcl) - (home-page "https://github.com/dkochmanski/cl-dejavu") - (synopsis "DejaVu fonts for Common Lisp") - (description - "This is a repackage of the original DejaVu Fonts with some convenience -functions.") - (license (list license:cc0 - (license:x11-style "http://dejavu-fonts.org/")))))) + (inputs + (list sbcl-alexandria + sbcl-trivial-garbage + sbcl-babel + sbcl-iolib + sbcl-ieee-floats + sbcl-flexi-streams + sbcl-cl-xmlspam + sbcl-ironclad)) + (synopsis "D-Bus client library for Common Lisp") + (description "This is a Common Lisp library that publishes D-Bus +objects as well as send and notify other objects connected to a bus.") + (license license:bsd-2)))) -(define-public cl-dejavu - (sbcl-package->cl-source-package sbcl-cl-dejavu)) +(define-public cl-dbus + (sbcl-package->cl-source-package sbcl-dbus)) -(define-public ecl-dejavu - (sbcl-package->ecl-package sbcl-cl-dejavu)) +(define-public ecl-dbus + (sbcl-package->ecl-package sbcl-dbus)) -(define-public sbcl-mcclim +(define-public sbcl-decimals (package - (name "sbcl-mcclim") - (version "0.9.8") + (name "sbcl-decimals") + (version "2021") (source (origin (method git-fetch) (uri (git-reference - (url "https://codeberg.org/McCLIM/McCLIM") - (commit (string-append version "-yule")))) - (file-name (git-file-name "cl-mcclim" version)) + (url "https://github.com/tlikonen/cl-decimals") + (commit version))) + (file-name (git-file-name "cl-decimals" version)) (sha256 - (base32 "0gbi61jnnsz6fvhv18mf57jkq46bvcd0355vqdcnrni7xyi10sk8")))) + (base32 "0wn5hq1pwd3wpjqqhpjzarcdk1q6416g8y447iaf55j5nbhlmbn6")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-fiveam pkg-config)) - (inputs - (list fontconfig - freetype - harfbuzz - sbcl-alexandria - sbcl-babel - sbcl-bordeaux-threads - sbcl-cffi - sbcl-cl-base64 - sbcl-cl-dejavu - sbcl-cl-freetype2 - sbcl-cl-pdf - sbcl-cl-unicode - sbcl-cl-vectors - sbcl-cl-who - sbcl-closer-mop - sbcl-cluffer - sbcl-clx - sbcl-flexi-streams - sbcl-flexichain - sbcl-log4cl - sbcl-lorem-ipsum - sbcl-opticl - sbcl-slime-swank - sbcl-spatial-trees - sbcl-trivial-features - sbcl-trivial-garbage - sbcl-trivial-gray-streams - sbcl-zpb-ttf)) - (arguments - '(#:asd-systems '("mcclim" - "clim-examples" - ;; clim-debugger is required by cleavir. - "clim-debugger") - #:phases - (modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "Extensions/fontconfig/src/functions.lisp" - (("libfontconfig\\.so") - (search-input-file inputs "/lib/libfontconfig.so"))) - (substitute* "Extensions/harfbuzz/src/functions.lisp" - (("libharfbuzz\\.so") - (search-input-file inputs "/lib/libharfbuzz.so")))))))) - (home-page "https://mcclim.common-lisp.dev/") - (synopsis "Common Lisp GUI toolkit") - (description - "McCLIM is an implementation of the @emph{Common Lisp Interface Manager -specification}, a toolkit for writing GUIs in Common Lisp.") - (license license:lgpl2.1+))) + (home-page "https://github.com/tlikonen/cl-decimals") + (synopsis "Decimal number parser and formatting package for Common Lisp") + (description "This Common Lisp package offers functions for parsing and +formatting decimal numbers. The package's main interface are the functions +@code{parse-decimal-number} and @code{format-decimal-number}. The former is +for parsing strings for decimal numbers and the latter for pretty-printing +them as strings.") + (license license:cc0))) -(define-public cl-mcclim - (sbcl-package->cl-source-package sbcl-mcclim)) +(define-public cl-decimals + (sbcl-package->cl-source-package sbcl-decimals)) -(define-public ecl-mcclim - (let ((pkg (sbcl-package->ecl-package sbcl-mcclim))) - (package - (inherit pkg) - (arguments - (substitute-keyword-arguments (package-arguments pkg) - ;; Tests fail with "FUNCTION: Not a valid argument (R1 - ;; (GENERATE-REGION))." on ECL. - ((#:tests? _ #f) #f)))))) +(define-public ecl-decimals + (sbcl-package->ecl-package sbcl-decimals)) -(define-public sbcl-cl-inflector - (let ((commit "f1ab16919ccce3bd82a0042677d9616dde2034fe") - (revision "1")) +(define-public sbcl-deeds + ;; taged branch is outdated + (let ((revision "1") + (commit "f5df54eac79b58a34030e0eb8acf3952c788410d")) (package - (name "sbcl-cl-inflector") - (version (git-version "0.2" revision commit)) + (name "sbcl-deeds") + (version (git-version "1.1.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/AccelerationNet/cl-inflector") + (url "https://github.com/Shinmera/deeds") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 "1xwwlhik1la4fp984qnx2dqq24v012qv4x0y49sngfpwg7n0ya7y")))) + (base32 "062cnb2dwli6pw3zvv46jfxyxdzcbzwsck5pa6nw03qf1j1hyg3k")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-lisp-unit2)) (inputs - (list sbcl-alexandria sbcl-cl-ppcre)) - (home-page "https://github.com/AccelerationNet/cl-inflector") - (synopsis "Library to pluralize/singularize English and Portuguese words") + (list sbcl-bordeaux-threads sbcl-closer-mop sbcl-form-fiddle + sbcl-lambda-fiddle)) + (home-page "https://github.com/Shinmera/deeds") + (synopsis "Extensible Event Delivery System") (description - "This is a common lisp library to easily pluralize and singularize -English and Portuguese words. This is a port of the ruby ActiveSupport -Inflector module.") - (license license:expat)))) + "@code{deeds} allows for efficient event delivery to multiple handlers +with a complex event filtering system.") + (license license:zlib)))) -(define-public cl-inflector - (sbcl-package->cl-source-package sbcl-cl-inflector)) +(define-public cl-deeds + (sbcl-package->cl-source-package sbcl-deeds)) -(define-public ecl-cl-inflector - (sbcl-package->ecl-package sbcl-cl-inflector)) +(define-public ecl-deeds + (sbcl-package->ecl-package sbcl-deeds)) -(define-public sbcl-ixf - (let ((commit "ed26f87e4127e4a9e3aac4ff1e60d1f39cca5183") - (revision "1")) +(define-public sbcl-definitions + (let ((commit "1f4bd7a634a2299aea19cefb5da8041bbb27f2ec")) (package - (name "sbcl-ixf") - (version (git-version "0.1.0" revision commit)) + (name "sbcl-definitions") + (version (git-version "1.0.0" "1" commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/dimitri/cl-ixf") + (url "https://github.com/Shinmera/definitions/") (commit commit))) - (file-name (git-file-name "cl-ixf" version)) + (file-name (git-file-name "cl-definitions" version)) (sha256 - (base32 "1wjdnf4vr9z7lcfc49kl43g6l2i23q9n81siy494k17d766cdvqa")))) + (base32 "16dh9iy3v344xj4qllsp47007px3yx26fxxh9gh2cvs8dqgk3kch")))) (build-system asdf-build-system/sbcl) (inputs - (list sbcl-alexandria - sbcl-babel - sbcl-cl-ppcre - sbcl-ieee-floats - sbcl-local-time - sbcl-md5 - sbcl-split-sequence)) - (home-page "https://github.com/dimitri/cl-ixf") - (synopsis "Parse IBM IXF file format") + (list sbcl-documentation-utils)) + (home-page "https://shinmera.github.io/definitions") + (synopsis "General definitions reflection library") (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)))) + "This system implements a general definitions introspection library. +It gives you the ability to retrieve definitions or bindings associated with +designators such as symbols, packages, and names in general. For instance, it +allows you to retrieve all function, type, variable, method, etc. definitions +of a symbol.") + (license license:zlib)))) -(define-public ecl-ixf - (sbcl-package->ecl-package sbcl-ixf)) +(define-public cl-definitions + (sbcl-package->cl-source-package sbcl-definitions)) -(define-public cl-ixf - (sbcl-package->cl-source-package sbcl-ixf)) +(define-public ecl-definitions + (sbcl-package->ecl-package sbcl-definitions)) -(define-public sbcl-qbase64 +(define-public sbcl-definitions-systems (package - (name "sbcl-qbase64") - (version "0.3.0") + (name "sbcl-definitions-systems") + (version "2.0.1") (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/chaitanyagupta/qbase64") - (commit version))) - (file-name (git-file-name name version)) + (url "https://github.com/Hexstream/definitions-systems") + (commit (string-append "v" version)))) + (file-name (git-file-name "cl-definitions-systems" version)) (sha256 - (base32 "1dir0s70ca3hagxv9x15zq4p4ajgl7jrcgqsza2n2y7iqbxh0dwi")))) + (base32 "009392mj0qdq4jy0dw5r41schnygwj286759yvyg7xja30a0psfq")))) (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-metabang-bind sbcl-trivial-gray-streams)) (native-inputs - (list sbcl-fiveam)) - (home-page "https://github.com/chaitanyagupta/qbase64") - (synopsis "Base64 encoder and decoder for Common Lisp") - (description "@code{qbase64} provides a fast and flexible base64 encoder -and decoder for Common Lisp.") - (license license:bsd-3))) + (list sbcl-parachute)) + (inputs + (list sbcl-canonicalized-initargs + sbcl-enhanced-defclass + sbcl-enhanced-find-class + sbcl-shared-preferences)) + (home-page "https://www.hexstreamsoft.com/libraries/definitions-systems/") + (synopsis "Unified extensible way of processing named definitions") + (description + "@code{definitions-systems} provides a simple unified extensible way of +processing named definitions.") + (license license:unlicense))) -(define-public cl-qbase64 - (sbcl-package->cl-source-package sbcl-qbase64)) +(define-public cl-definitions-systems + (sbcl-package->cl-source-package sbcl-definitions-systems)) -(define-public ecl-qbase64 - (sbcl-package->ecl-package sbcl-qbase64)) +(define-public ecl-definitions-systems + (sbcl-package->ecl-package sbcl-definitions-systems)) -(define-public sbcl-lw-compat - ;; No release since 2013. - (let ((commit "aabfe28c6c1a4949f9d7b3cb30319367c9fd1c0d")) +(define-public sbcl-deflate + (package + (name "sbcl-deflate") + (version "1.0.3") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/pmai/Deflate") + (commit (string-append "release-" version)))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1jpdjnxh6cw2d8hk70r2sxn92is52s9b855irvwkdd777fdciids")))) + (build-system asdf-build-system/sbcl) + (home-page "https://github.com/pmai/Deflate") + (synopsis "Native deflate decompression for Common Lisp") + (description + "This library is an implementation of Deflate (RFC 1951) decompression, +with optional support for ZLIB-style (RFC 1950) and gzip-style (RFC 1952) +wrappers of deflate streams. It currently does not handle compression.") + (license license:expat))) + +(define-public cl-deflate + (sbcl-package->cl-source-package sbcl-deflate)) + +(define-public ecl-deflate + (sbcl-package->ecl-package sbcl-deflate)) + +(define-public sbcl-defpackage-plus + (let ((revision "0") + (commit "5492e27e0bdb7b75fa5177ea4388519dc7a75f11")) (package - (name "sbcl-lw-compat") - (version (git-version "1.0.0" "1" commit)) + (name "sbcl-defpackage-plus") + (version (git-version "1.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/pcostanza/lw-compat/") + (url "https://github.com/rpav/defpackage-plus") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 "131rq5k2mlv9bfhmafiv6nfsivl4cxx13d9wr06v5jrqnckh4aav")))) + (base32 "0lzljvf343xb6mlh6lni2i27hpm5qd376522mk6hr2pa20vd6rdq")))) (build-system asdf-build-system/sbcl) - (home-page "https://github.com/pcostanza/lw-compat/") - (synopsis "LispWorks utilities ported to other Common Lisp implementations") - (description "This package contains a few utility functions from the -LispWorks library that are used in software such as ContextL.") - (license license:expat)))) + (inputs + (list sbcl-alexandria)) + (home-page "https://github.com/rpav/defpackage-plus") + (synopsis "Extensible @code{DEFPACKAGE} variant with version support") + (description + "@code{DEFPACKAGE-PLUS} is an extensible @code{DEFPACKAGE} variant with +predictable cross-platform behavior and some utilities useful for versioning.") + (license license:bsd-2)))) -(define-public cl-lw-compat - (sbcl-package->cl-source-package sbcl-lw-compat)) +(define-public cl-defpackage-plus + (sbcl-package->cl-source-package sbcl-defpackage-plus)) -(define-public ecl-lw-compat - (sbcl-package->ecl-package sbcl-lw-compat)) +(define-public ecl-defpackage-plus + (sbcl-package->ecl-package sbcl-defpackage-plus)) -(define-public sbcl-contextl - ;; No release since 2013. - (let ((commit "f4fb3f59b0844788613fc4d1cc0d2b08df9488bb") +(define-public sbcl-defstar + (let ((commit "132829dac9f84fa7202a0c5793aa6accb8d2662a")) + (package + (name "sbcl-defstar") + (version (git-version "1.0.0" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "http://bitbucket.org/eeeickythump/defstar/") + (commit commit))) + (file-name (git-file-name "cl-defstar" version)) + (sha256 + (base32 "0n6m3aqvdfnsrhlhqjcy72d1i55lbkjg13ij5c7vw003p1n78wxi")))) + (build-system asdf-build-system/sbcl) + (home-page "http://bitbucket.org/eeeickythump/defstar/") + (synopsis "Easy inline (return) type declarations for functions") + (description + "Defstar is a collection of Common Lisp macros that can be used in +place of @code{defun}, @code{defmethod}, @code{defgeneric}, @code{defvar}, +@code{defparameter}, @code{flet}, @code{labels}, @code{let*} and +@code{lambda}. Each macro has the same name as the form it replaces, with a +star added at the end, e.g. @code{defun}. (the exception is the @code{let*} +replacement, which is called @code{*let}).") + (license license:gpl3)))) + +(define-public cl-defstar + (sbcl-package->cl-source-package sbcl-defstar)) + +(define-public ecl-defstar + (sbcl-package->ecl-package sbcl-defstar)) + +(define-public sbcl-deploy + (let ((commit "9b20e64fe924b9e31832304d87a3a72c383dc6d8") (revision "2")) (package - (name "sbcl-contextl") + (name "sbcl-deploy") (version (git-version "1.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/pcostanza/contextl/") + (url "https://github.com/Shinmera/deploy") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "deploy" version)) (sha256 - (base32 "0apgznz4g6lpmd86lq7w0xddfjgnirk83ig7p0j6i93xadhy9wh0")))) + (base32 "07pfkibaridihg8lbq2czwa4iqifqk24n6rx7bfnv7i49p1ppja1")))) (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-cl-mpg123 sbcl-cl-out123)) (inputs - (list sbcl-closer-mop sbcl-lw-compat)) - (home-page "https://github.com/pcostanza/contextl") - (synopsis "Context-oriented programming for Common Lisp") - (description "ContextL is a CLOS extension for Context-Oriented -Programming (COP). - -Find overview of ContextL's features in an overview paper: -@url{http://www.p-cos.net/documents/contextl-soa.pdf}. See also this general -overview article about COP which also contains some ContextL examples: -@url{http://www.jot.fm/issues/issue_2008_03/article4/}.") - (license license:expat)))) + (list sbcl-cffi sbcl-documentation-utils sbcl-trivial-features)) + (home-page "https://shinmera.github.io/deploy/") + (synopsis "Deployment tools for standalone Common Lisp application") + (description + "This is a system to help you easily and quickly deploy standalone +common lisp applications as binaries. Specifically it is geared towards +applications with foreign library dependencies that run some kind of GUI.") + (license license:artistic2.0)))) -(define-public cl-contextl - (sbcl-package->cl-source-package sbcl-contextl)) +(define-public cl-deploy + (sbcl-package->cl-source-package sbcl-deploy)) -(define-public ecl-contextl - (sbcl-package->ecl-package sbcl-contextl)) +(define-public ecl-deploy + (sbcl-package->ecl-package sbcl-deploy)) -(define-public sbcl-hu.dwim.common-lisp - (let ((commit "90558195773383142a57a16687d5e7f4adea6418")) +(define-public sbcl-depot + (let ((commit "73822d9f480cbad00971b45ee80117297a67fb53") + (revision "1")) (package - (name "sbcl-hu.dwim.common-lisp") - (version "2021-01-27") + (name "sbcl-depot") + (version (git-version "1.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/hu-dwim/hu.dwim.common-lisp/") + (url "https://github.com/Shinmera/depot/") (commit commit))) - (file-name (git-file-name name version)) (sha256 - (base32 "06zkdw3scnaw0d4nmsgkv7pi7sw00dikdgfgsqmbqfbz2yrsdabk")))) + (base32 "1v42pirdwbxy8l8i9a2jmbpri8a62vh0r4vm25xwaak0y4gr71va")) + (file-name (git-file-name "depot" version)))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-hu.dwim.asdf)) - (home-page "http://dwim.hu/project/hu.dwim.common-lisp") - (synopsis "Redefine some standard Common Lisp names") - (description "This library is a redefinition of the standard Common Lisp -package that includes a number of renames and shadows.") - (license license:public-domain)))) + (inputs + (list sbcl-atomics + sbcl-babel + sbcl-documentation-utils + sbcl-trivial-features + sbcl-trivial-gray-streams + sbcl-zippy)) + ;; TODO: Some 6 tests fail, why? See https://github.com/Shinmera/depot/issues/2. + (arguments + '(#:asd-systems '("depot" + "depot-in-memory" + "depot-virtual" + "depot-zip"))) + (synopsis "Protocol for transparent collections of files") + (description "This is a system presenting a protocol for \"file +systems\": things that present a collection of \"files,\" which are things +that have several attributes, and a central data payload. Most notably this +includes the OS filesystem, but can also be used to address other +filesystem-like things like archives, object stores, etc. in the same +manner.") + (home-page "https://shinmera.github.io/depot/") + (license license:zlib)))) -(define-public cl-hu.dwim.common-lisp - (sbcl-package->cl-source-package sbcl-hu.dwim.common-lisp)) +(define-public cl-depot + (sbcl-package->cl-source-package sbcl-depot)) -(define-public ecl-hu.dwim.common-lisp - (sbcl-package->ecl-package sbcl-hu.dwim.common-lisp)) +(define-public ecl-depot + (sbcl-package->ecl-package sbcl-depot)) -(define-public sbcl-hu.dwim.common - (package - (name "sbcl-hu.dwim.common") - (version "2015-07-09") - (source - (origin - (method url-fetch) - (uri (string-append - "http://beta.quicklisp.org/archive/hu.dwim.common/" - version "/hu.dwim.common-" - (string-replace-substring version "-" "") - "-darcs.tgz")) - (sha256 - (base32 "12l1rr6w9m99w0b5gc6hv58ainjfhbc588kz6vwshn4gqsxyzbhp")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-hu.dwim.asdf)) - (inputs - (list sbcl-alexandria - sbcl-anaphora - sbcl-closer-mop - sbcl-hu.dwim.common-lisp - sbcl-iterate - sbcl-metabang-bind)) - (home-page "https://dwim.hu/") - (synopsis "Common Lisp library shared by other hu.dwim systems") - (description "This package contains a support library for other -hu.dwim systems.") - (license license:public-domain))) +(define-public sbcl-dexador + (let ((commit "051cbb784ea3015cef9731eb5a624f3122de84b5") + (revision "2")) + (package + (name "sbcl-dexador") + (build-system asdf-build-system/sbcl) + (version (git-version "0.9.15" revision commit)) + (home-page "https://github.com/fukamachi/dexador") + (source + (origin + (method git-fetch) + (uri (git-reference + (url home-page) + (commit commit))) + (file-name (git-file-name "cl-dexador" version)) + (sha256 + (base32 "1sggpi43la8dai102fmkzysh7760hvk6q68f0pkbb9187vz8nd3y")))) + (inputs + (list sbcl-alexandria + sbcl-babel + sbcl-bordeaux-threads + sbcl-chipz + sbcl-chunga + sbcl-cl+ssl + sbcl-cl-base64 + sbcl-cl-cookie + sbcl-cl-ppcre + sbcl-fast-http + sbcl-fast-io + sbcl-quri + sbcl-trivial-garbage + sbcl-trivial-gray-streams + sbcl-trivial-mimes + sbcl-usocket)) + ;; These native-inputs are for tests only, which are disabled. + ;; Leave them commented since they add a lot to the closure size. + ;; (native-inputs + ;; (list sbcl-clack + ;; sbcl-lack + ;; sbcl-rove)) + (arguments + ;; TODO: Circular dependency: tests depend on clack-test which depends on dexador. + `(#:tests? #f + #:phases + (modify-phases %standard-phases + (add-after 'unpack 'fix-permissions + (lambda _ (make-file-writable "t/data/test.gz") #t))))) + (synopsis "Yet another HTTP client for Common Lisp") + (description "Dexador is yet another HTTP client for Common Lisp with +neat APIs and connection-pooling. It is meant to supersede Drakma.") + (license license:expat)))) -(define-public cl-hu.dwim.common - (sbcl-package->cl-source-package sbcl-hu.dwim.common)) +(define-public cl-dexador + (package + (inherit (sbcl-package->cl-source-package sbcl-dexador)) + (arguments + `(#:phases + ;; asdf-build-system/source has its own phases and does not inherit + ;; from asdf-build-system/sbcl phases. + (modify-phases %standard-phases/source + ;; Already done in SBCL package. + (delete 'reset-gzip-timestamps)))))) -(define-public ecl-hu.dwim.common - (sbcl-package->ecl-package sbcl-hu.dwim.common)) +(define-public ecl-dexador + (sbcl-package->ecl-package sbcl-dexador)) -(define-public sbcl-hu.dwim.defclass-star - (let ((commit "3086878a485074f9b2913c58267a9b764cd632fd")) +(define-public sbcl-dfio + (let ((commit "5caf473acb9bc464839e87395724cbd941167915") + (revision "0")) (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" "2" commit)) + (name "sbcl-dfio") + (version (git-version "1.0.2" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/hu-dwim/hu.dwim.defclass-star") + (url "https://github.com/Lisp-Stat/dfio") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-dfio" version)) (sha256 - (base32 "19ipds9r71qymfdp4izg0l7zmvinp06adr8rdalhaq7v7mzpg83z")))) + (base32 "1p53r7773939jnap518xp4b4wfvc1kbrz9jp6yd40xq0jpf9pbqg")))) (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-alexandria + sbcl-anaphora + sbcl-data-frame + sbcl-dexador + sbcl-fare-csv + sbcl-let-plus + sbcl-yason)) (native-inputs - (list ;; 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) - sbcl-hu.dwim.asdf)) - (arguments - `(;; 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 -@item Automatically export all or select slots at compile time. -@item Define the @code{:initarg} and @code{:accessor} automatically. -@item Specify a name transformer for both the @code{:initarg} and -@code{:accessor}, etc. -@item Specify the @code{:initform} as second slot value. -@end itemize - -See -@url{https://common-lisp.net/project/defclass-star/configuration.lisp.html} -for an example.") - (license license:public-domain)))) + (list sbcl-clunit2)) + (home-page "https://lisp-stat.dev/docs/manuals/data-frame/") + (synopsis "Read data to and from data frames") + (description "This package provides tools for manipulating data +in files using data frames.") + (license license:ms-pl)))) -(define-public cl-hu.dwim.defclass-star - (sbcl-package->cl-source-package sbcl-hu.dwim.defclass-star)) +(define-public cl-dfio + (sbcl-package->cl-source-package sbcl-dfio)) -(define-public ecl-hu.dwim.defclass-star - (sbcl-package->ecl-package sbcl-hu.dwim.defclass-star)) +;; This depends on ecl-data-frame, which doesn't work yet. +;; (define-public ecl-dfio +;; (sbcl-package->ecl-package sbcl-dfio)) -(define-public sbcl-livesupport - (let ((commit "71e6e412df9f3759ad8378fabb203913d82e228a") - (revision "1")) +(define-public sbcl-diff + (let ((commit "9c84befa598d4e07c3d223242b5b3f83cd94f301") + (revision "1")) (package - (name "sbcl-livesupport") - (version (git-version "0.0.0" revision commit)) + (name "sbcl-diff") + (version (git-version "0.4" revision commit)) (source (origin (method git-fetch) |