;;; Copyright © 2020, 2021 Sharlatan Hellseher <sharlatanus@gmail.com>
;;; Copyright © 2021 Aurora <rind38@disroot.org>
;;; Copyright © 2021 Matthew Kraai <kraai@ftbfs.org>
+;;; Copyright © 2021 André A. Gomes <andremegafone@gmail.com>
+;;; Copyright © 2021 Cage <cage-dev@twistfold.it>
;;;
;;; This file is part of GNU Guix.
;;;
#:use-module (gnu packages imagemagick)
#:use-module (gnu packages libevent)
#:use-module (gnu packages libffi)
+ #:use-module (gnu packages linux)
#:use-module (gnu packages lisp)
#:use-module (gnu packages maths)
+ #:use-module (gnu packages mp3)
+ #:use-module (gnu packages ncurses)
#:use-module (gnu packages networking)
#:use-module (gnu packages pkg-config)
#:use-module (gnu packages python)
(define-public ecl-alexandria
(sbcl-package->ecl-package sbcl-alexandria))
+(define-public sbcl-golden-utils
+ (let ((commit "9424419d867d5c2f819196ee41667a818a5058e7")
+ (revision "1"))
+ (package
+ (name "sbcl-golden-utils")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://git.mfiano.net/mfiano/golden-utils")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "15x0phm6820yj3h37ibi06gjyh6z45sd2nz2n8lcbfflwm086q0h"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)))
+ (home-page "https://git.mfiano.net/mfiano/golden-utils")
+ (synopsis "Common Lisp utility library")
+ (description
+ "This is a Common Lisp library providing various utilities.")
+ (license license:expat))))
+
+(define-public ecl-golden-utils
+ (sbcl-package->ecl-package sbcl-golden-utils))
+
+(define-public cl-golden-utils
+ (sbcl-package->cl-source-package sbcl-golden-utils))
+
(define-public sbcl-asdf-finalizers
(let ((commit "7f537f6c598b662ae987c6acc268dd27c25977e0")
(revision "1"))
(define-public ecl-fiveam
(sbcl-package->ecl-package sbcl-fiveam))
+(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
+ ;; Tests only.
+ `(("rt" ,sbcl-rt)))
+ (inputs
+ `(("cl+ssl" ,sbcl-cl+ssl)
+ ("flexi-streams" ,sbcl-flexi-streams)
+ ("split-sequence" ,sbcl-split-sequence)
+ ("usocket" ,sbcl-usocket)))
+ (arguments
+ `(#:asd-systems '("cl-irc") ;; Some inexisting "c" system is
+ ;; found by guix otherwise.
+ #:asd-files '("cl-irc.asd")
+ #:test-asd-file "test/cl-irc-test.asd"))
+ (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).
+
+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 cl-irc
+ (sbcl-package->cl-source-package sbcl-cl-irc))
+
+(define-public ecl-cl-irc
+ (sbcl-package->ecl-package sbcl-cl-irc))
+
+(define-public sbcl-trivial-timeout
+ (let ((commit "feb869357f40f5e109570fb40abad215fb370c6c")
+ (revision "1"))
+ (package
+ (name "sbcl-trivial-timeout")
+ (version (git-version "0.1.5" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/gwkkwg/trivial-timeout/")
+ (commit commit)))
+ (file-name (git-file-name "trivial-timeout" version))
+ (sha256
+ (base32 "1kninxwvvih9nhh7a9y8lfgi7pdr76675y1clw4ss17vz8fbim5p"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("lift" ,sbcl-lift)))
+ (arguments
+ ;; NOTE: (Sharlatan-20210202T231437+0000): Due to the age of this library
+ ;; tests use some deprecated functionality and keep failing.
+ `(#:tests? #f))
+ (home-page "https://github.com/gwkkwg/trivial-timeout/")
+ (synopsis "Timeout library for Common Lisp")
+ (description
+ "This library provides an OS and implementation independent access to
+timeouts.")
+ (license license:expat))))
+
+(define-public ecl-trivial-timeout
+ (sbcl-package->ecl-package sbcl-trivial-timeout))
+
+(define-public cl-trivial-timeout
+ (sbcl-package->cl-source-package sbcl-trivial-timeout))
+
(define-public sbcl-bordeaux-threads
(package
(name "sbcl-bordeaux-threads")
(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")
(description
(sbcl-package->ecl-package sbcl-clx-truetype))
(define-public sbcl-slynk
- (let ((commit "dffdf3caa12e964127d6eb45ba92ac0442cc5a48"))
+ (let ((commit "fb84318c08f59bc786e047006fc81e2ace568309"))
(package
(name "sbcl-slynk")
- (version (git-version "1.0.43" "1" commit))
+ (version (git-version "1.0.43" "4" commit))
(source
(origin
(method git-fetch)
(url "https://github.com/joaotavora/sly")
(commit commit)))
(sha256
- (base32 "0vv185gz3rkfng5y79dijfnc11p92qdz2kdza05avjbpqfs6l0zn"))
+ (base32 "0z123k9ak7yjb9bxb5qx48f33ma8066rhkqh8xc14z7shk75jybj"))
(file-name (git-file-name "slynk" version))))
(build-system asdf-build-system/sbcl)
(outputs '("out" "image"))
(sbcl-package->ecl-package sbcl-trivial-features))
(define-public sbcl-hu.dwim.asdf
- (package
- (name "sbcl-hu.dwim.asdf")
- (version "20190521")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "http://beta.quicklisp.org/archive/hu.dwim.asdf/"
- "2019-05-21/hu.dwim.asdf-" version "-darcs.tgz"))
- (sha256
- (base32
- "0rsbv71vyszy8w35yjwb5h6zcmknjq223hkzir79y72qdsc6sabn"))))
- (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
+ (let ((commit "67cdf84390e530af4303cc4bc815fdf2a5e48f59"))
+ (package
+ (name "sbcl-hu.dwim.asdf")
+ (version "20200724")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/hu-dwim/hu.dwim.asdf")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0p81jalilkaqw832a12s35q0z6rrarxjasm1jy6h4fvyj9pf0zkx"))))
+ (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)))
+ (license license:public-domain))))
(define-public cl-hu.dwim.asdf
(sbcl-package->cl-source-package sbcl-hu.dwim.asdf))
(sbcl-package->ecl-package sbcl-hu.dwim.asdf))
(define-public sbcl-hu.dwim.stefil
- (let ((commit "ab6d1aa8995878a1b66d745dfd0ba021090bbcf9"))
+ (let ((commit "414902c6f575818c39a8a156b8b61b1adfa73dad"))
(package
(name "sbcl-hu.dwim.stefil")
- (version (git-version "0.0.0" "1" commit))
+ (version (git-version "0.0.0" "2" commit))
(source
(origin
(method git-fetch)
(uri
(git-reference
- (url "https://gitlab.common-lisp.net/xcvb/hu.dwim.stefil.git")
+ (url "https://github.com/hu-dwim/hu.dwim.stefil")
(commit commit)))
(sha256
- (base32 "1d8yccw65zj3zh46cbi3x6nmn1dwdb76s9d0av035077mvyirqqp"))
+ (base32 "14izmjjim590rh74swrssavdmdznj2z8vhqixy780sjhpcr5pmkc"))
(file-name (git-file-name "hu.dwim.stefil" version))))
(build-system asdf-build-system/sbcl)
(native-inputs
`(("asdf:cl-hu.dwim.asdf" ,sbcl-hu.dwim.asdf)))
(inputs
`(("sbcl-alexandria" ,sbcl-alexandria)))
- (home-page "https://hub.darcs.net/hu.dwim/hu.dwim.stefil")
+ (home-page "http://dwim.hu/project/hu.dwim.stefil")
(synopsis "Simple test framework")
(description "Stefil is a simple test framework for Common Lisp,
with a focus on interactive development.")
(define-public ecl-jpl-util
(sbcl-package->ecl-package sbcl-jpl-util))
+(define-public sbcl-piping
+ (let ((commit "c7a4163c00dea7e72bf6ad33d6abac0d5826a656")
+ (revision "1"))
+ (package
+ (name "sbcl-piping")
+ (version (git-version "2.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Shinmera/piping/")
+ (commit commit)))
+ (file-name (git-file-name "piping" version))
+ (sha256
+ (base32 "0in84qnfkynm36d4n4d6v87vprpi27xrydnga462wfhplji6klv5"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://shinmera.github.io/piping/")
+ (synopsis "Library to enable simple message pipelines")
+ (description
+ "This is a Common Lisp library to enable simple message pipelines.")
+ (license license:zlib))))
+
+(define-public ecl-piping
+ (sbcl-package->ecl-package sbcl-piping))
+
+(define-public cl-piping
+ (sbcl-package->cl-source-package sbcl-piping))
+
+(define-public sbcl-cl-pcg
+ (let ((commit "8263d85ab0ca17fb05637a4430c2d564456bce8f")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-pcg")
+ (version (git-version "1.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sjl/cl-pcg")
+ (commit commit)))
+ (file-name (git-file-name "cl-pcg" version))
+ (sha256
+ (base32 "0s57wvvlvshp1gcp9i9d3qcmqhswnxps3i0y7wbb0v8i1a3p46m4"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("1am" ,sbcl-1am)))
+ (home-page "https://github.com/sjl/cl-pcg")
+ (synopsis "Permuted congruential generators in Common Lisp")
+ (description
+ "This is a bare-bones Permuted Congruential Generator implementation in
+pure Common Lisp.")
+ (license license:expat))))
+
+(define-public ecl-cl-pcg
+ (sbcl-package->ecl-package sbcl-cl-pcg))
+
+(define-public cl-pcg
+ (sbcl-package->cl-source-package sbcl-cl-pcg))
+
+(define-public sbcl-seedable-rng
+ (let ((commit "aa1a1564b6e07e2698df37c7a98348c4f762cb15")
+ (revision "1"))
+ (package
+ (name "sbcl-seedable-rng")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://git.mfiano.net/mfiano/seedable-rng")
+ (commit commit)))
+ (file-name (git-file-name "seedable-rng" version))
+ (sha256
+ (base32 "1ldpsbp3qrfzvknclsxj3sdyms1jf9ad20dvh4w0kw3zgahn2nr5"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("cl-pcg" ,sbcl-cl-pcg)
+ ("golden-utils" ,sbcl-golden-utils)
+ ("ironclad" ,sbcl-ironclad)))
+ (home-page "https://git.mfiano.net/mfiano/seedable-rng")
+ (synopsis "Common Lisp random number generator")
+ (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")
(sbcl-package->ecl-package sbcl-colorize))
(define-public sbcl-3bmd
- (let ((commit "192ea13435b605a96ef607df51317056914cabbd"))
+ (let ((commit "6fc5759448f6f6df6f6df556e020a289a2643288")
+ (revision "2"))
(package
(name "sbcl-3bmd")
- (version (git-version "0.0.0" "1" commit))
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(url "https://github.com/3b/3bmd")
(commit commit)))
(sha256
- (base32
- "1rgv3gi7wf963ikmmpk132wgn0icddf226gq3bmcnk1fr3v9gf2f"))
+ (base32 "1avmbp8xdjlbqpqk7p3vmj7abiw5p3vb5mrxp4wlvgql4sf6z3p4"))
(file-name (git-file-name "3bmd" version))))
(build-system asdf-build-system/sbcl)
(arguments
- ;; FIXME: We need to specify the name because the build-system thinks
- ;; "3" is a version marker.
- `(#:asd-systems '("3bmd"
- "3bmd-ext-code-blocks")))
+ ;; FIXME: #41437 - Build fails when package name starts from a digit
+ `(#:asd-systems
+ '("3bmd"
+ "3bmd-ext-definition-lists"
+ "3bmd-ext-math"
+ "3bmd-ext-tables"
+ "3bmd-ext-wiki-links"
+ "3bmd-youtube"
+ "3bmd-ext-code-blocks")))
(inputs
- `(("colorize" ,sbcl-colorize)
+ `(("alexandria" ,sbcl-alexandria)
+ ("colorize" ,sbcl-colorize)
("esrap" ,sbcl-esrap)
("split-sequence" ,sbcl-split-sequence)))
+ (home-page "https://github.com/3b/3bmd")
(synopsis "Markdown processor in Command Lisp using esrap parser")
(description
- "Common Lisp Markdown -> HTML converter, using @command{esrap} for
-parsing, and grammar based on @command{peg-markdown}.")
- (home-page "https://github.com/3b/3bmd")
+ "This is a Common Lisp Markdown to HTML converter, using @command{esrap}
+for parsing, and grammar based on @command{peg-markdown}.")
(license license:expat))))
(define-public cl-3bmd
(define-public ecl-cl-fad
(sbcl-package->ecl-package sbcl-cl-fad))
+(define-public sbcl-fn
+ (let ((commit "8d8587d03a7b5e26b306fc90018e385d9e5acc2c")
+ (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
+ `(("named-readtables" ,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))
+
(define-public sbcl-rt
(let ((commit "a6a7503a0b47953bc7579c90f02a6dba1f6e4c5a")
(revision "1"))
(sbcl-package->ecl-package sbcl-ironclad))
(define-public sbcl-named-readtables
- (let ((commit "64bd53f37a1694cfde48fc38b8f03901f6f0c05b")
- (revision "2"))
+ (let ((commit "585a28eee8b1b1999279b48cb7e9731187e14b66")
+ (revision "3"))
(package
(name "sbcl-named-readtables")
(version (git-version "0.9" revision commit))
(url "https://github.com/melisgl/named-readtables")
(commit commit)))
(sha256
- (base32 "01l4831m7k84qvhzyx0qgdl50isr4zmp40qf6dfq2iqcaj8y4h3n"))
+ (base32 "072p5djqq9pliw9r20rmpz5r5q5yn6rhbp98vkkp7gfcnp5ppj51"))
(file-name (git-file-name "named-readtables" version))))
(build-system asdf-build-system/sbcl)
- (arguments
- ;; Tests seem to be broken.
- `(#: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.")
+ (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->ecl-package sbcl-slime-swank))
(define-public sbcl-mgl-pax
- (let ((commit "818448418d6b9de74620f606f5b23033c6082769"))
+ (let ((commit "4ada6eb26364e71addb169ce58e4ba83bc7a8eaa")
+ (revision "2"))
(package
(name "sbcl-mgl-pax")
- (version (git-version "0.0.0" "1" commit))
+ (version (git-version "0.0.3" revision commit))
(source
(origin
(method git-fetch)
(url "https://github.com/melisgl/mgl-pax")
(commit commit)))
(sha256
- (base32
- "1p97zfkh130bdxqqxwaw2j9psv58751wakx7czbfpq410lg7dd7i"))
+ (base32 "1s38crgvmd9hgqwsscqpj6m6c10a074zjgg8k5sl15yih1wkpssm"))
(file-name (git-file-name "mgl-pax" version))))
(build-system asdf-build-system/sbcl)
(inputs
(sbcl-package->cl-source-package sbcl-mgl-pax))
(define-public ecl-mgl-pax
- (let ((pkg (sbcl-package->ecl-package sbcl-mgl-pax)))
- (package
- (inherit pkg)
- (arguments
- (substitute-keyword-arguments (package-arguments pkg)
- ;; TODO: Find why the tests fail on ECL.
- ((#:tests? _ #f) #f))))))
+ (sbcl-package->ecl-package sbcl-mgl-pax))
(define-public sbcl-mssql
(let ((commit "045602a19a32254108f2b75871049293f49731eb")
(sbcl-package->ecl-package sbcl-anaphora))
(define-public sbcl-lift
- (let ((commit "7d49a66c62759535624037826891152223d4206c"))
+ (let ((commit "2594160d6ca3a77d8750110dfa63214256aab852")
+ (revision "2"))
(package
(name "sbcl-lift")
- (version (git-version "1.7.1" "1" commit))
+ (version (git-version "1.7.1" revision commit))
(source
(origin
(method git-fetch)
(url "https://github.com/gwkkwg/lift")
(commit commit)))
(sha256
- (base32
- "127v5avpz1i4m0lkaxqrq8hrl69rdazqaxf6s8awf0nd7wj2g4dp"))
+ (base32 "01xvz9sl5l5lai4h9dabmcjnm659wf5zllaxqbs55lffskp6jwq3"))
(file-name (git-file-name "lift" version))
(modules '((guix build utils)))
(snippet
(sbcl-package->ecl-package sbcl-proc-parse))
(define-public sbcl-parse-float
- (let ((commit "2aae569f2a4b2eb3bfb5401a959425dcf151b09c"))
+ (let ((commit "3074765101e41222b6b624a66aaf1e6416379f9c")
+ (revision "2"))
(package
(name "sbcl-parse-float")
- (version (git-version "0.0.0" "1" commit))
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(url "https://github.com/soemraws/parse-float")
(commit commit)))
(sha256
- (base32
- "08xw8cchhmqcc0byng69m3f5a2izc9y2290jzz2k0qrbibp1fdk7"))
+ (base32 "0jd2spawc3v8vzqf8ky4cngl45jm65fhkrdf20mf6dcbn3mzpkmr"))
(file-name (git-file-name "proc-parse" version))))
(build-system asdf-build-system/sbcl)
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("babel" ,sbcl-babel)))
- (native-inputs
- `(("prove" ,sbcl-prove)))
(arguments
- ;; TODO: Tests don't find "proc-parse-test", why?
- `(#:tests? #f))
+ ;; FIXME: https://github.com/soemraws/parse-float/issues/12
+ `(#:asd-systems '("parse-float" "parse-float-tests")))
+ (native-inputs
+ `(("lisp-unit" ,sbcl-lisp-unit)))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)))
+ (home-page "https://github.com/soemraws/parse-float")
(synopsis "Parse a floating point value from a string in Common Lisp")
(description
"This package exports the following function to parse floating-point
values from a string in Common Lisp.")
- (home-page "https://github.com/soemraws/parse-float")
(license license:public-domain))))
(define-public cl-parse-float
(sbcl-package->ecl-package sbcl-ptester))
(define-public sbcl-puri
- (let ((commit "ef5afb9e5286c8e952d4344f019c1a636a717b97")
- (revision "1"))
+ (let ((commit "4bbab89d9ccbb26346899d1f496c97604fec567b")
+ (revision "2"))
(package
(name "sbcl-puri")
(version (git-version "1.5.7" revision commit))
(uri (git-reference
(url "http://git.kpe.io/puri.git")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "puri" version))
(sha256
- (base32 "1vm25pdl92laj72p5vyd538kf3cjy2655z6bdc99h20ana2p231s"))))
+ (base32 "0gq2rsr0aihs0z20v4zqvmdl4szq53b52rh97pvnmwrlbn4mapmd"))))
(build-system asdf-build-system/sbcl)
(native-inputs
`(("ptester" ,sbcl-ptester)))
- (home-page "http://quickdocs.org/puri/")
+ (home-page "http://puri.kpe.io/")
(synopsis "Portable URI Library")
(description
"This is a portable Universal Resource Identifier library for Common
(define-public ecl-queues
(sbcl-package->ecl-package sbcl-queues))
+(define-public sbcl-glsl-packing
+ (let ((commit "03628159468a8e5b7f2a1d5e78b77053e136794a")
+ (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
+ `(("alexandria" ,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))))
+
+(define-public ecl-glsl-packing
+ (sbcl-package->ecl-package sbcl-glsl-packing))
+
+(define-public cl-glsl-packing
+ (sbcl-package->cl-source-package sbcl-glsl-packing))
+
+(define-public sbcl-glsl-spec
+ (let ((commit "f04476f7da89355ae6856b33283c60ba95c6555d")
+ (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))))
+
+(define-public ecl-glsl-spec
+ (sbcl-package->ecl-package sbcl-glsl-spec))
+
+(define-public cl-glsl-spec
+ (sbcl-package->cl-source-package sbcl-glsl-spec))
+
+(define-public sbcl-varjo
+ (let ((commit "9e77f30220053155d2ef8870ceba157f75e538d4")
+ (revision "1"))
+ (package
+ (name "sbcl-varjo")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/cbaggers/varjo")
+ (commit commit)))
+ (file-name (git-file-name "varjo" version))
+ (sha256
+ (base32 "1p9x1wj576x5d31yvls9r1avkjkyhri7kyxbjfkg9z93a1w18j9z"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("documentation-utils" ,sbcl-documentation-utils)
+ ("fn" ,sbcl-fn)
+ ("glsl-spec" ,sbcl-glsl-spec)
+ ("named-readtables" ,sbcl-named-readtables)
+ ("parse-float" ,sbcl-parse-float)
+ ("vas-string-metrics" ,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))
+
+(define-public cl-varjo
+ (sbcl-package->cl-source-package sbcl-varjo))
+
(define-public sbcl-cffi
(package
(name "sbcl-cffi")
(define-public ecl-cffi
(sbcl-package->ecl-package sbcl-cffi))
-(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
+(define-public sbcl-cffi-c-ref
+ (let ((commit "8123cbb6034c5f7921a0766107cfb8c4e8efd5ce")
+ (revision "0"))
+ (package
+ (name "sbcl-cffi-c-ref")
+ (version (git-version "1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/borodust/cffi-c-ref")
+ (commit commit)))
+ (sha256
+ (base32 "1a3pp6xcisabqir3rp1gvvjfdxcvpm8yr35p38nri9azsinmmc7z"))
+ (file-name (git-file-name "cffi-c-ref" version))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cffi" ,sbcl-cffi)))
+ (synopsis "Streamlined access to foreign memory")
+ (description
+ "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-cffi-c-ref
+ (sbcl-package->cl-source-package sbcl-cffi-c-ref))
+
+(define-public ecl-cffi-c-ref
+ (sbcl-package->ecl-package sbcl-cffi-c-ref))
+
+(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
(sbcl-package->ecl-package sbcl-cl-cffi-gtk))
(define-public sbcl-cl-webkit
- (let ((commit "5ce3ea1fbf2b21e7ccb98402a818508ca9b79395"))
+ (let ((commit "0bc05cc73257670ab241853b9cc9ccb68940fe44"))
(package
(name "sbcl-cl-webkit")
(version (git-version "2.4" "10" commit))
(file-name (git-file-name "cl-webkit" version))
(sha256
(base32
- "0zgd8hp2nalh0v4xgjvqxd6rf95f7mci181xbg3gmqxxwxd4mkpk"))))
+ "1kg6illspvb5647pm0x819ag2n7njnqvrm18jzgd28vk6nlkrcmq"))))
(build-system asdf-build-system/sbcl)
(inputs
`(("cffi" ,sbcl-cffi)
(sbcl-package->cl-source-package sbcl-trivial-arguments))
(define-public sbcl-trivial-clipboard
- (let ((commit "afcd3743b842f5a81fc86dba60f9db59970f49c5"))
+ (let ((commit "8a580cb97196be7cf096548eb1f46794cd22bb39"))
(package
(name "sbcl-trivial-clipboard")
- (version (git-version "0.0.0.0" "3" commit))
+ (version (git-version "0.0.0.0" "4" commit))
(source
(origin
(method git-fetch)
(file-name (git-file-name "trivial-clipboard" version))
(sha256
(base32
- "1qfbvkzmvkbqpc5s3sx31c5653sy6qlcixafgzd10qpykb843prr"))))
+ "0apkgqrscylw3hhm5x2vs0z3hz6h7zd7dl5y3wr2zl8qjpvpc80k"))))
(build-system asdf-build-system/sbcl)
(inputs
`(("xclip" ,xclip)))
(add-after 'unpack 'fix-paths
(lambda* (#:key inputs #:allow-other-keys)
(substitute* "src/text.lisp"
- (("\\(executable-find \"xclip\"\\)")
- (string-append "(executable-find \""
- (assoc-ref inputs "xclip")
- "/bin/xclip\")"))))))))
+ (("\"xclip\"")
+ (string-append "\"" (assoc-ref inputs "xclip") "/bin/xclip\""))))))))
(home-page "https://github.com/snmsts/trivial-clipboard")
(synopsis "Access system clipboard in Common Lisp")
(description
(sbcl-package->ecl-package sbcl-map-set))
(define-public sbcl-quri
- (let ((commit "b53231c5f19446dd7c24b15a249fefa45ae94f9a")
- (revision "2"))
+ (let ((commit "d7f2720568146c6674187f625f115925e6364a7f")
+ (revision "4"))
(package
(name "sbcl-quri")
(version (git-version "0.1.0" revision commit))
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "0cansr63m690ymvhway419178mq2sqnmxm4rdxclbsrnjwwbi36m"))))
+ (base32 "0yrcvz5ksfr7x8yx741vp65il0fxxaskppq3iyk9bq895s1jn37w"))))
(build-system asdf-build-system/sbcl)
(arguments
- ;; Tests fail with: Component QURI-ASD::QURI-TEST not found,
- ;; required by #<SYSTEM "quri">. Why?
- '(#:tests? #f))
+ ;; Test system must be loaded before, otherwise tests fail with:
+ ;; Component QURI-ASD::QURI-TEST not found, required by #<SYSTEM
+ ;; "quri">.
+ '(#:asd-systems '("quri-test"
+ "quri")))
(native-inputs `(("sbcl-prove" ,sbcl-prove)))
(inputs `(("sbcl-babel" ,sbcl-babel)
("sbcl-split-sequence" ,sbcl-split-sequence)
(define-public sbcl-static-vectors
(package
(name "sbcl-static-vectors")
- (version "1.8.4")
+ (version "1.8.6")
(source
(origin
(method git-fetch)
(commit (string-append "v" version))))
(file-name (git-file-name name version))
(sha256
- (base32 "0qvf9z6bhwhm8n45fjwkm7j8dcb58szfvndky65cyn4lpdval7m1"))))
+ (base32 "01hwxzhyjkhsd3949g70120g7msw01byf0ia0pbj319q1a3cq7j9"))))
(native-inputs
`(("sbcl-fiveam" ,sbcl-fiveam)))
(inputs
- `(("sbcl-cffi" ,sbcl-cffi)))
+ `(("sbcl-alexandria" ,sbcl-alexandria)
+ ("sbcl-cffi" ,sbcl-cffi)))
(build-system asdf-build-system/sbcl)
(home-page "https://github.com/sionescu/static-vectors")
(synopsis "Allocate SIMPLE-ARRAYs in static memory")
(sbcl-package->ecl-package sbcl-cl-log))
(define-public sbcl-log4cl
- (let ((commit "611e094458504b938d49de904eab141285328c7c")
+ (let ((commit "8c48d6f41d3a1475d0a91eed0638b9eecc398e35")
(revision "1"))
(package
(name "sbcl-log4cl")
- (build-system asdf-build-system/sbcl)
- (version "1.1.2")
+ (version (git-version "1.1.3" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/sharplispers/log4cl")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "log4cl" version))
(sha256
- (base32
- "08jly0s0g26b56hhpfizxsb4j0yvbh946sd205gr42dkzv8l7dsc"))))
- ;; FIXME: tests require stefil, sbcl-hu.dwim.stefil wont work
- (arguments
- `(#:tests? #f))
- (inputs `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
- (synopsis "Common Lisp logging framework, modeled after Log4J")
+ (base32 "0166d9aip366pbpdk5gsi2f6xad6q61lssxgbrypa8zslwjn8736"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("stefil" ,sbcl-stefil)))
+ (inputs
+ `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
(home-page "https://github.com/7max/log4cl")
- (description "This is a Common Lisp logging framework that can log at
-various levels and mix text with expressions.")
+ (synopsis "Common Lisp logging framework, modeled after Log4J")
+ (description
+ "This is a Common Lisp logging framework that can log at various levels
+and mix text with expressions.")
(license license:asl2.0))))
(define-public cl-log4cl
(define-public ecl-log4cl
(sbcl-package->ecl-package sbcl-log4cl))
+(define-public sbcl-printv
+ (let ((commit "646d31978dbbb460fffb160fd65bb2be9a5a434e")
+ (revision "1"))
+ (package
+ (name "sbcl-printv")
+ (version (git-version "0.1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/danlentz/printv")
+ (commit commit)))
+ (file-name (git-file-name "printv" version))
+ (sha256
+ (base32 "08jvy82abm7qi3wrxh6gvmwg9gy0zzhg4cfqajdwrggbah8mj5a6"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/danlentz/printv")
+ (synopsis "Common Lisp tracing and debug-logging macro")
+ (description
+ "@code{PRINTV} is a \"batteries-included\" tracing and debug-logging
+macro for Common Lisp.")
+ (license license:asl2.0))))
+
+(define-public ecl-printv
+ (sbcl-package->ecl-package sbcl-printv))
+
+(define-public cl-printv
+ (sbcl-package->cl-source-package sbcl-printv))
+
+(define-public sbcl-verbose
+ (let ((commit "c5b7ecd465be61b35af17ef57564697b88397174")
+ (revision "1"))
+ (package
+ (name "sbcl-verbose")
+ (version (git-version "2.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Shinmera/verbose/")
+ (commit commit)))
+ (file-name (git-file-name "verbose" version))
+ (sha256
+ (base32 "0r51ydj5v7afi2jrlscbhxprv13d9vzg5316g1yzwaxc1kzsdsw6"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("dissect" ,sbcl-dissect)
+ ("documentation-utils" ,sbcl-documentation-utils)
+ ("local-time" ,sbcl-local-time)
+ ("piping" ,sbcl-piping)))
+ (home-page "https://shinmera.github.io/verbose/")
+ (synopsis "Logging framework using the piping library")
+ (description
+ "This is a Common Lisp library providing logging faciltiy similar to
+@code{CL-LOG} and @code{LOG4CL}.")
+ (license license:zlib))))
+
+(define-public ecl-verbose
+ (sbcl-package->ecl-package sbcl-verbose))
+
+(define-public cl-verbose
+ (sbcl-package->cl-source-package sbcl-verbose))
+
(define-public sbcl-find-port
(let ((commit "00c96a25af93a0f8681d34ec548861f2d7485478")
(revision "1"))
;;; Split the trivia package in two to work around the circular dependency
;;; between guicho271828/trivia and guicho271828/type-i.
(define-public sbcl-trivia.trivial
- (let ((commit "37698b47a14c2007630468de7a993694ef7bd475")
- (revision "2"))
+ (let ((commit "7286d5d2a4f685f1cac8370816f95276c0851111")
+ (revision "3"))
(package
(name "sbcl-trivia.trivial")
(version (git-version "0.0.0" revision commit))
(file-name (git-file-name "trivia" version))
(sha256
(base32
- "0rsbwbw3ipxxgr6zzhci12nilq8zky475kmhz1rcxy4q8a85vn72"))))
+ "0ln0sj3jry7kzbmxhnin66kpbqan1wp8wwgdbw4k29afbdblkcca"))))
(build-system asdf-build-system/sbcl)
(inputs
`(("alexandria" ,sbcl-alexandria)
(define-public ecl-cl-store
(sbcl-package->ecl-package sbcl-cl-store))
+(define-public sbcl-specialization-store
+ (let ((commit "8d39a866a6f24986aad3cc52349e9cb2653496f3")
+ (revision "1"))
+ (package
+ (name "sbcl-specialization-store")
+ (version (git-version "0.0.5" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/markcox80/specialization-store")
+ (commit commit)))
+ (file-name (git-file-name "specialization-store" version))
+ (sha256
+ (base32 "0r0bgb46q4gy72l78s7djkxq8ibb4bb3yh9brsry5lih7br8lhi0"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("introspect-environment" ,sbcl-introspect-environment)))
+ (home-page "https://github.com/markcox80/specialization-store")
+ (synopsis "Different type of generic function for Common Lisp")
+ (description
+ "SPECIALIZATION-STORE system provides a new kind of function, called
+a store function, whose behavior depends on the types of objects passed to the
+function.")
+ (license license:bsd-2))))
+
+(define-public ecl-specialization-store
+ (package
+ (inherit (sbcl-package->ecl-package sbcl-specialization-store))
+ (arguments
+ ;; TODO: Find why the tests get stuck forever; disable them for now.
+ `(#:tests? #f))))
+
+(define-public cl-specialization-store
+ (sbcl-package->cl-source-package sbcl-specialization-store))
+
(define-public sbcl-cl-gobject-introspection
(let ((commit "d0136c8d9ade2560123af1fc55bbf70d2e3db539")
(revision "1"))
(define-public ecl-cl-gobject-introspection
(sbcl-package->ecl-package sbcl-cl-gobject-introspection))
+(define-public sbcl-cl-slug
+ (let ((commit "ffb229d10f0d3f7f54e706791725225e200bf749")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-slug")
+ (version (git-version "0.4.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/EuAndreh/cl-slug")
+ (commit commit)))
+ (file-name (git-file-name "cl-slug" version))
+ (sha256
+ (base32 "1asdq6xllmsvfw5fky9wblqcx9isac9jrrlkfl7vyxcq1wxrnflx"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:asd-files '("cl-slug-test.asd" "cl-slug.asd")
+ #:asd-systems '("cl-slug-test" "cl-slug")))
+ (native-inputs
+ `(("prove" ,sbcl-prove)))
+ (inputs
+ `(("ppcre" ,sbcl-cl-ppcre)))
+ (home-page "https://github.com/EuAndreh/cl-slug")
+ (synopsis "Multi-language slug formater")
+ (description
+ "This is a small Common Lisp library to make slugs, mainly for URIs,
+from english and beyond.")
+ (license license:llgpl))))
+
+(define-public ecl-cl-slug
+ (sbcl-package->ecl-package sbcl-cl-slug))
+
+(define-public cl-slug
+ (sbcl-package->cl-source-package sbcl-cl-slug))
+
(define-public sbcl-string-case
(let ((commit "718c761e33749e297cd2809c7ba3ade1985c49f7")
(revision "0"))
(sbcl-package->ecl-package sbcl-trivial-macroexpand-all))
(define-public sbcl-serapeum
- (let ((commit "c5e352a9f04a84a93742193c01734f4fb31d9f82")
- (revision "3"))
+ (let ((commit "263f415a350736b44e3878524ff3997e656fca32")
+ (revision "4"))
(package
(name "sbcl-serapeum")
(version (git-version "0.0.0" revision commit))
(file-name (git-file-name name version))
(sha256
(base32
- "16767pxl766c15jznr4srcbp7cnxf8w9lkyaqpp5w5crqymw84nw"))))
+ "1669yidvxq41s3g6hb2jk21bcb5s2bnfsacpyd5b0hdxbmc7knq3"))))
(build-system asdf-build-system/sbcl)
(inputs
`(("alexandria" ,sbcl-alexandria)
(define-public ecl-cl-coroutine
(sbcl-package->ecl-package sbcl-cl-coroutine))
+(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
+ `(#:test-asd-file "test.vas-string-metrics.asd"))
+ (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-vas-string-metrics
+ (sbcl-package->ecl-package sbcl-vas-string-metrics))
+
+(define-public cl-vas-string-metrics
+ (sbcl-package->cl-source-package sbcl-vas-string-metrics))
+
(define-public sbcl-vom
(let ((commit "1aeafeb5b74c53741b79497e0ef4acf85c92ff24")
(revision "1"))
(define-public ecl-salza2
(sbcl-package->ecl-package sbcl-salza2))
+(define-public sbcl-origin
+ (let ((commit "d646134302456408d6d43580bb05299f1695ab8e")
+ (revision "1"))
+ (package
+ (name "sbcl-origin")
+ (version (git-version "2.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://git.mfiano.net/mfiano/origin")
+ (commit commit)))
+ (file-name (git-file-name "origin" version))
+ (sha256
+ (base32 "1n9aszaif3yh8prs5r8v51fbj4r5jd1a048mivd5yij3hplkm82b"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("parachute" ,sbcl-parachute)))
+ (inputs
+ `(("golden-utils" ,sbcl-golden-utils)
+ ("specialization-store" ,sbcl-specialization-store)))
+ (home-page "https://git.mfiano.net/mfiano/origin")
+ (synopsis "Common Lisp graphics math library")
+ (description
+ "This is a native Common Lisp graphics math library with an emphasis on
+performance and correctness.")
+ (license license:expat))))
+
+(define-public ecl-origin
+ (sbcl-package->ecl-package sbcl-origin))
+
+(define-public cl-origin
+ (sbcl-package->cl-source-package sbcl-origin))
+
(define-public sbcl-png-read
(let ((commit "ec29f38a689972b9f1373f13bbbcd6b05deada88")
(revision "1"))
(define-public ecl-png-read
(sbcl-package->ecl-package sbcl-png-read))
+(define-public sbcl-3b-bmfont
+ (let ((commit "d1b5bec0de580c2d08ec947a93c56b1400f2a37a")
+ (revision "1"))
+ (package
+ (name "sbcl-3b-bmfont")
+ (version (git-version "0.0.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/3b/3b-bmfont/")
+ (commit commit)))
+ (file-name (git-file-name "3b-bmfont" version))
+ (sha256
+ (base32 "12sgf7m0h6fqzhvkas7vmci6mprj3j3fnz778jlbqbsydln6v2yc"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:asd-systems
+ '("3b-bmfont"
+ "3b-bmfont/text"
+ "3b-bmfont/common"
+ "3b-bmfont/xml"
+ "3b-bmfont/json")))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cxml" ,sbcl-cxml)
+ ("flexi-streams" ,sbcl-flexi-streams)
+ ("jsown" ,sbcl-jsown)
+ ("split-sequence" ,sbcl-split-sequence)))
+ (home-page "https://github.com/3b/3b-bmfont/")
+ (synopsis "Read/write bmfont metadata files")
+ (description
+ "This is a Common Lisp library which provides functionality to
+read/write Bit Map Font (BMF) into text, JSON and XML.")
+ (license license:expat))))
+
+(define-public ecl-3b-bmfont
+ (sbcl-package->ecl-package sbcl-3b-bmfont))
+
+(define-public cl-3b-bmfont
+ (sbcl-package->cl-source-package sbcl-3b-bmfont))
+
(define-public sbcl-zpng
(package
(name "sbcl-zpng")
((#:tests? _ #f) #f))))))
(define-public sbcl-numcl
- (let ((commit "3e8d40bf774e070e7af1d3dbf01bc8c37dbebd3a")
- (revision "2"))
+ (let ((commit "d19f36356be900c600ef08560c9e1af441a166cb")
+ (revision "1"))
(package
(name "sbcl-numcl")
- (version (git-version "0.1.0" revision commit))
+ (version (git-version "0.2.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/numcl/numcl")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "numcl" version))
(sha256
- (base32 "1hqpr68f6xkxaj1hjjayyh97wcdmj51k20qrd3nsv1rcpmdc5ll4"))))
+ (base32 "0q4ylfr7hl0gz2ynr0c15h09dmnli2x6ndnm5wr58wfplf1wfj31"))))
(build-system asdf-build-system/sbcl)
- (synopsis "Numpy clone in Common Lisp")
- (description
- "This is a Numpy clone in Common Lisp. At the moment the
-library is written in pure Common Lisp, focusing more on correctness
-and usefulness, not speed. Track the progress at
-@url{https://github.com/numcl/numcl/projects/1}.")
- (home-page "https://github.com/numcl/numcl")
- (license license:lgpl3+)
+ (arguments
+ `(#:test-asd-file "numcl.test.asd"
+ #:asd-files '("numcl.asd")))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
(inputs
- `(("trivia" ,sbcl-trivia)
- ("alexandria" ,sbcl-alexandria)
- ("iterate" ,sbcl-iterate)
- ("lisp-namespace" ,sbcl-lisp-namespace)
- ("type-r" ,sbcl-type-r)
- ("constantfold" ,sbcl-constantfold)
+ `(("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)
- ("gtype" ,sbcl-gtype)))
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)))
- (arguments
- `(#:asd-files '("numcl.asd")
- #:test-asd-file "numcl.test.asd"
- ;; Tests fail on SBCL with "Heap exhausted, game over",
- ;; but they pass on ECL.
- #:tests? #f)))))
+ ("trivia" ,sbcl-trivia)
+ ("type-r" ,sbcl-type-r)))
+ (home-page "https://numcl.github.io/numcl/")
+ (synopsis "Numpy clone in Common Lisp")
+ (description
+ "This package is a Python Numpy clone implemented in pure Common Lisp.")
+ (license license:lgpl3+))))
(define-public cl-numcl
(sbcl-package->cl-source-package sbcl-numcl))
(define-public ecl-numcl
- (let ((pkg (sbcl-package->ecl-package sbcl-numcl)))
- (package
- (inherit pkg)
- (arguments
- (substitute-keyword-arguments (package-arguments pkg)
- ((#:tests? _ #f) #t))))))
+ (sbcl-package->ecl-package sbcl-numcl))
(define-public sbcl-pzmq
(let ((commit "7c7390eedc469d033c72dc497984d1536ee75826")
(sbcl-package->ecl-package sbcl-enchant))
(define-public sbcl-cl-change-case
- (let ((commit "5ceff2a5f8bd845b6cb510c6364176b27a238fd3"))
+ (let ((commit "45c70b601125889689e0c1c37d7e727a3a0af022")
+ (revision "1"))
(package
(name "sbcl-cl-change-case")
- (version (git-version "0.1.0" "1" commit))
+ (version (git-version "0.2.0" revision commit))
(home-page "https://github.com/rudolfochrist/cl-change-case")
(source
(origin
(uri (git-reference
(url home-page)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-change-case" version))
(sha256
- (base32 "1afyglglk9z3yg8gylcl301bl2r8vq3sllyznzj9s5xi5gs6qyf2"))))
+ (base32 "0qmk341zzcsbf8sq0w9ix3r080zg4ri6vzxym63lhdjfzwz3y8if"))))
(build-system asdf-build-system/sbcl)
(inputs
`(("cl-ppcre" ,sbcl-cl-ppcre)
("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)))
(native-inputs
`(("fiveam" ,sbcl-fiveam)))
- (arguments
- '(;; FIXME: Test pass but phase fails with 'Component
- ;; "cl-change-case-test" not found, required by'.
- #:tests? #f
- #:test-asd-file "cl-change-case-test.asd"))
- (synopsis "Convert Common Lisp strings between camelCase, PascalCase and more")
+ (synopsis
+ "Convert Common Lisp strings between camelCase, PascalCase and more")
(description
- "@code{cl-change-case} is library to convert strings between camelCase,
-PascalCase, snake_case, param-case, CONSTANT_CASE and more.")
+ "@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-change-case
(define-public sbcl-cl-rdkafka
(package
(name "sbcl-cl-rdkafka")
- (version "1.0.2")
+ (version "1.1.0")
(source
(origin
(method git-fetch)
(file-name (git-file-name name version))
(sha256
(base32
- "1qcgfd4h7syilzmrmd4z2vknbvawda3q3ykw7xm8n381syry4g82"))))
+ "0z2g0k0xy8k1p9g93h8dy9wbygaq7ziwagm4yz93zk67mhc0b84v"))))
(build-system asdf-build-system/sbcl)
(arguments
`(#:tests? #f ; Attempts to connect to locally running Kafka
(sbcl-package->ecl-package sbcl-cl-libsvm-format))
(define-public sbcl-cl-online-learning
- (let ((commit "fc7a34f4f161cd1c7dd747d2ed8f698947781423")
- (revision "0"))
+ (let ((commit "87fbef8a340219e853adb3a5bf44a0470da76964")
+ (revision "1"))
(package
(name "sbcl-cl-online-learning")
(version (git-version "0.5" revision commit))
(uri (git-reference
(url "https://github.com/masatoi/cl-online-learning")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-online-learning" version))
(sha256
(base32
- "14x95rlg80ay5hv645ki57pqvy12v28hz4k1w0f6bsfi2rmpxchq"))))
+ "1lfq04lnxivx59nq5dd02glyqsqzf3vdn4s9b8wnaln5fs8g2ph9"))))
(build-system asdf-build-system/sbcl)
(native-inputs
`(("prove" ,sbcl-prove)))
`(("cl-libsvm-format" ,sbcl-cl-libsvm-format)
("cl-store" ,sbcl-cl-store)))
(arguments
- `(;; FIXME: Tests pass but then the check phase crashes
- #:tests? #f))
+ `(#:test-asd-file "cl-online-learning-test.asd"
+ #:asd-systems '("cl-online-learning-test"
+ "cl-online-learning")))
+ (home-page "https://github.com/masatoi/cl-online-learning")
(synopsis "Online Machine Learning for Common Lisp")
(description
"This library contains a collection of machine learning algorithms for
online linear classification written in Common Lisp.")
- (home-page "https://github.com/masatoi/cl-online-learning")
(license license:expat))))
(define-public cl-online-learning
(define-public ecl-cl-online-learning
(sbcl-package->ecl-package sbcl-cl-online-learning))
-(define-public sbcl-cl-random-forest
- (let ((commit "fedb36ce99bb6f4d7e3a7dd6d8b058f331308f91")
+(define-public sbcl-cl-mpg123
+ (let ((commit "5f042c839d2ea4a2ff2a7b60c839d8633d64161d")
(revision "1"))
(package
- (name "sbcl-cl-random-forest")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-cl-mpg123")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/masatoi/cl-random-forest")
+ (url "https://github.com/Shirakumo/cl-mpg123")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-mpg123" version))
(sha256
- (base32
- "0wqh4dxy5hrvm14jgyfypwhdw35f24rsksid4blz5a6l2z16rlmq"))))
+ (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
- `(("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")
- (description
+ `(#:asd-files '("cl-mpg123.asd" "cl-mpg123-example.asd")
+ #:asd-systems '("cl-mpg123" "cl-mpg123-example")
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "low-level.lisp"
+ (("libmpg123.so" all)
+ (string-append (assoc-ref inputs "libmpg123")
+ "/lib/" all))))))))
+ (inputs
+ `(("cffi" ,sbcl-cffi)
+ ("cl-out123" ,sbcl-cl-out123)
+ ("documentation-utils" ,sbcl-documentation-utils)
+ ("libmpg123" ,mpg123)
+ ("trivial-features" ,sbcl-trivial-features)
+ ("trivial-garbage" ,sbcl-trivial-garbage)
+ ("verbose" ,sbcl-verbose)))
+ (home-page "https://shirakumo.github.io/cl-mpg123/")
+ (synopsis "Common Lisp bindings to libmpg123")
+ (description
+ "This is a bindings and wrapper library to @code{libmpg123} allowing for
+convenient, extensive, and fast decoding of MPEG1/2/3 (most prominently mp3)
+files.")
+ (license license:zlib))))
+
+(define-public ecl-cl-mpg123
+ (sbcl-package->ecl-package sbcl-cl-mpg123))
+
+(define-public cl-mpg123
+ (sbcl-package->cl-source-package sbcl-cl-mpg123))
+
+(define-public sbcl-cl-out123
+ (let ((commit "6b58d3f8c2a28ad09059ac4c60fb3c781b9b421b")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-out123")
+ (version (git-version "1.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Shirakumo/cl-out123")
+ (commit commit)))
+ (file-name (git-file-name "cl-out123" version))
+ (sha256
+ (base32 "0mdwgfax6sq68wvdgjjp78i40ah7wqkpqnvaq8a1c509k7ghdgv1"))
+ (modules '((guix build utils)))
+ (snippet
+ '(begin
+ ;; Remove bundled pre-compiled libraries.
+ (delete-file-recursively "static")
+ #t))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "low-level.lisp"
+ (("libout123.so" all)
+ (string-append (assoc-ref inputs "libout123")
+ "/lib/" all)))))
+ ;; NOTE: (Sharlatan-20210129T134529+0000): ECL package `ext' has no
+ ;; exported macro `without-interrupts' it's moved to `mp' package
+ ;; https://github.com/Shirakumo/cl-out123/issues/2
+ ;; https://gitlab.com/embeddable-common-lisp/ecl/-/blob/develop/src/lsp/mp.lsp
+ (add-after 'unpack 'fix-ecl-package-name
+ (lambda _
+ (substitute* "wrapper.lisp"
+ (("ext:without-interrupts.*") "mp:without-interrupts\n"))
+ #t)))))
+ (inputs
+ `(("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("cffi" ,sbcl-cffi)
+ ("documentation-utils" ,sbcl-documentation-utils)
+ ("libout123" ,mpg123)
+ ("trivial-features" ,sbcl-trivial-features)
+ ("trivial-garbage" ,sbcl-trivial-garbage)))
+ (home-page "https://shirakumo.github.io/cl-out123/")
+ (synopsis "Common Lisp bindings to libout123")
+ (description
+ "This is a bindings library to @code{libout123} which allows easy
+cross-platform audio playback.")
+ (license license:zlib))))
+
+(define-public ecl-cl-out123
+ (sbcl-package->ecl-package sbcl-cl-out123))
+
+(define-public cl-out123
+ (sbcl-package->cl-source-package sbcl-cl-out123))
+
+(define-public sbcl-cl-random-forest
+ (let ((commit "fedb36ce99bb6f4d7e3a7dd6d8b058f331308f91")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-random-forest")
+ (version (git-version "0.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/masatoi/cl-random-forest")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0wqh4dxy5hrvm14jgyfypwhdw35f24rsksid4blz5a6l2z16rlmq"))))
+ (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")
+ (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.")
(sbcl-package->ecl-package sbcl-mmap))
(define-public sbcl-3bz
- (let ((commit "d6119083b5e0b0a6dd3abc2877936c51f3f3deed")
- (revision "0"))
+ (let ((commit "569614c40408f3aefc77ba233e0e4bd66d3850ad")
+ (revision "1"))
(package
(name "sbcl-3bz")
(version (git-version "0.0.0" revision commit))
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "0fyxzyf2b6sc0w8d9g4nlva861565z6f3xszj0lw29x526dd9rhj"))))
+ (base32 "0kvvlvf50jhhw1s510f3clpr1a68632bq6d698yxcrx722igcrg4"))))
(build-system asdf-build-system/sbcl)
(inputs
`(("alexandria" ,sbcl-alexandria)
("nibbles" ,sbcl-nibbles)
("trivial-features" ,sbcl-trivial-features)))
(arguments
- ;; FIXME: Without the following line, the build fails (see issue 41437).
+ ;; FIXME: #41437 - Build fails when package name starts from a digit
`(#:asd-systems '("3bz")))
(home-page "https://github.com/3b/3bz")
(synopsis "Deflate decompression for Common Lisp")
(sbcl-package->ecl-package sbcl-zpb-exif))
(define-public sbcl-pngload
- (package
- (name "sbcl-pngload")
- (version "2.0.0")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/bufferswap/pngload")
- (commit version)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "1ix8dd0fxlf8xm0bszh1s7sx83hn0vqq8b8c9gkrd5m310w8mpvh"))))
- (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://github.com/bufferswap/pngload")
- (synopsis "PNG image decoder for Common Lisp")
- (description
- "This is a Common Lisp library to load images in the PNG image format,
+ (let ((commit "91f1d703c65bb6a94d6fee06ddbbbbbc5778b71f")
+ (revision "2"))
+ (package
+ (name "sbcl-pngload")
+ (version (git-version "2.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://git.mfiano.net/mfiano/pngload.git")
+ (commit commit)))
+ (file-name (git-file-name "pngload" version))
+ (sha256
+ (base32 "0s94fdbrbqj12qvgyn2g4lfwvz7qhhzbclrpz5ni7adwxgrmvxl1"))))
+ (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")
+ (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)))
+ (license license:expat))))
(define-public cl-pngload
(sbcl-package->cl-source-package sbcl-pngload))
(sbcl-package->ecl-package sbcl-contextl))
(define-public sbcl-hu.dwim.common-lisp
- (package
- (name "sbcl-hu.dwim.common-lisp")
- (version "2015-07-09")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "http://beta.quicklisp.org/archive/hu.dwim.common-lisp/"
- version "/hu.dwim.common-lisp-"
- (string-replace-substring version "-" "")
- "-darcs.tgz"))
- (sha256
- (base32 "13cxrvh55rw080mvfir7s7k735l9rcfh3khxp97qfwd5rz0gadb9"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- `(("hu.dwim.asdf" ,sbcl-hu.dwim.asdf)))
- (home-page "http://dwim.hu/")
- (synopsis "Redefine some standard Common Lisp names")
- (description "This library is a redefinition of the standard Common Lisp
+ (let ((commit "90558195773383142a57a16687d5e7f4adea6418"))
+ (package
+ (name "sbcl-hu.dwim.common-lisp")
+ (version "2021-01-27")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/hu-dwim/hu.dwim.common-lisp/")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "06zkdw3scnaw0d4nmsgkv7pi7sw00dikdgfgsqmbqfbz2yrsdabk"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("hu.dwim.asdf" ,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)))
+ (license license:public-domain))))
(define-public cl-hu.dwim.common-lisp
(sbcl-package->cl-source-package sbcl-hu.dwim.common-lisp))
(sbcl-package->ecl-package sbcl-hu.dwim.common))
(define-public sbcl-hu.dwim.defclass-star
- (package
- (name "sbcl-hu.dwim.defclass-star")
- (version "2015-07-09")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "http://beta.quicklisp.org/archive/hu.dwim.defclass-star/"
- version "/hu.dwim.defclass-star-"
- (string-replace-substring version "-" "")
- "-darcs.tgz"))
- (sha256
- (base32 "032982lyp0hm0ssxlyh572whi2hr4j1nqkyqlllaj373v0dbs3vs"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- `(;; These 2 inputs are only needed tests which are disabled, see below.
- ;; ("hu.dwim.common" ,sbcl-hu.dwim.common)
- ;; Need cl- package for the :hu.dwim.stefil+hu.dwim.def+swank system.
- ;; ("hu.dwim.stefil" ,cl-hu.dwim.stefil)
- ("hu.dwim.asdf" ,sbcl-hu.dwim.asdf)))
- (arguments
- `(#:test-asd-file "hu.dwim.defclass-star.test.asd"
- ;; Tests require a circular dependency: hu.dwim.stefil -> hu.dwim.def
- ;; -> hu.dwim.util -> hu.dwim.defclass-star.
- #:tests? #f))
- (home-page "http://dwim.hu/?_x=dfxn&_f=mRIMfonK")
- (synopsis "Simplify definitions with defclass* and friends in Common Lisp")
- (description "@code{defclass-star} provides defclass* and defcondition* to
+ (let ((commit "39d458f1b1bc830d1f5e18a6a35bf0e96a2cfd61"))
+ (package
+ (name "sbcl-hu.dwim.defclass-star")
+ ;; We used to set version from the date when it was a darcs repo, so we
+ ;; keep the year so that package gets updated on previous installs.
+ (version (git-version "2021" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/hu-dwim/hu.dwim.defclass-star")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0hfkq2wad98vkyxdg1wh18y86d9w9yqkm8lxkk96szvpwymm7lmq"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `( ;; These 2 inputs are only needed tests which are disabled, see below.
+ ;; ("hu.dwim.common" ,sbcl-hu.dwim.common)
+ ;; Need cl- package for the :hu.dwim.stefil+hu.dwim.def+swank system.
+ ;; ("hu.dwim.stefil" ,cl-hu.dwim.stefil)
+ ("hu.dwim.asdf" ,sbcl-hu.dwim.asdf)))
+ (arguments
+ `(#:test-asd-file "hu.dwim.defclass-star.test.asd"
+ ;; Tests require a circular dependency: hu.dwim.stefil -> hu.dwim.def
+ ;; -> hu.dwim.util -> hu.dwim.defclass-star.
+ #:tests? #f))
+ (home-page "https://github.com/hu-dwim/hu.dwim.defclass-star")
+ (synopsis "Simplify definitions with defclass* and friends in Common Lisp")
+ (description "@code{defclass-star} provides defclass* and defcondition* to
simplify class and condition declarations. Features include:
@itemize
See
@url{https://common-lisp.net/project/defclass-star/configuration.lisp.html}
for an example.")
- (license license:public-domain)))
+ (license license:public-domain))))
(define-public cl-hu.dwim.defclass-star
(sbcl-package->cl-source-package sbcl-hu.dwim.defclass-star))
(base32
"18r3wfarr7lgn78m6c66r0r9aazirv07gy7xgvqkl9pmrz1bc47m"))))
(build-system asdf-build-system/sbcl)
- (propagated-inputs
- `(("alexandria" ,cl-alexandria)
- ("anaphora" ,cl-anaphora)
- ("collectors" ,cl-collectors)
- ("optima" ,cl-optima)))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("anaphora" ,sbcl-anaphora)
+ ("collectors" ,sbcl-collectors)
+ ("optima" ,sbcl-optima)))
(native-inputs
`(("prove" ,sbcl-prove)))
(home-page "https://github.com/alex-gutev/cl-environments")
(sbcl-package->ecl-package sbcl-cl-environments))
(define-public sbcl-static-dispatch
- (package
- (name "sbcl-static-dispatch")
- (version "0.3")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/alex-gutev/static-dispatch")
- (commit (string-append "v" version))))
- (file-name (git-file-name name version))
- (sha256
- (base32 "1wp5yz8liqqic3yifqf33qhccd755pd7ycvsq1j4i7k3f1wm18i0"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("agutil" ,sbcl-agutil)
- ("alexandria" ,sbcl-alexandria)
- ("anaphora" ,sbcl-anaphora)
- ("arrows" ,sbcl-arrows)
- ("closer-mop" ,sbcl-closer-mop)
- ("iterate" ,sbcl-iterate)
- ("trivia" ,sbcl-trivia)))
- (propagated-inputs
- ;; FIXME: `sbcl-cl-environments' input fails with
- ;;
- ;; compiling #<CL-SOURCE-FILE "collectors" "collectors">
- ;; Unhandled SB-INT:SIMPLE-FILE-ERROR in thread #<SB-THREAD:THREAD "main thread" RUNNING
- ;; {1008238213}>:
- ;; Error opening #P"/.../cl-environments/src/common/package-tmp5GEXGEG5.fasl":
- ;; Permission denied
- `(("cl-environments" ,cl-environments)))
- (native-inputs
- `(("prove" ,sbcl-prove)))
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- ;; Use `arrows' instead of cl-arrows which is abandoned and unlicensed.
- ;; https://github.com/nightfly19/cl-arrows/issues/5
- (add-after 'unpack 'use-arrows-instead-of-cl-arrows
- (lambda _
- (for-each
- (lambda (file)
- (substitute* file
- ((":cl-arrows") ":arrows")))
- '("static-dispatch.asd"
- "src/package.lisp"
- "test/methods.lisp"
- "test/test.lisp")))))))
- (home-page "https://github.com/alex-gutev/static-dispatch")
- (synopsis "Static generic function dispatch for Common Lisp")
- (description "Static dispatch is a Common Lisp library, inspired by
+ (let ((commit "6243afcd152854c52ba33daef7394367b657d9c6")
+ (revision "1"))
+ (package
+ (name "sbcl-static-dispatch")
+ (version (git-version "0.3" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/alex-gutev/static-dispatch")
+ (commit commit)))
+ (file-name (git-file-name "static-dispatch" version))
+ (sha256
+ (base32 "1lli9ar1xbnhkgb5d01rlw4pvfylg2arrw68np2c07fpkkafimg7"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("prove" ,sbcl-prove)))
+ (inputs
+ `(("agutil" ,sbcl-agutil)
+ ("alexandria" ,sbcl-alexandria)
+ ("anaphora" ,sbcl-anaphora)
+ ("arrows" ,sbcl-arrows)
+ ("cl-environments" ,sbcl-cl-environments)
+ ("closer-mop" ,sbcl-closer-mop)
+ ("iterate" ,sbcl-iterate)
+ ("trivia" ,sbcl-trivia)))
+ (home-page "https://github.com/alex-gutev/static-dispatch")
+ (synopsis "Static generic function dispatch for Common Lisp")
+ (description "Static dispatch is a Common Lisp library, inspired by
@code{inlined-generic-function}, which allows standard Common Lisp generic
function dispatch to be performed statically (at compile time) rather than
dynamically (runtime). This is similar to what is known as \"overloading\" in
example of such a case is a generic equality comparison function. Currently
generic functions are considered far too slow to implement generic arithmetic
and comparison operations when used heavily in numeric code.")
- (license license:expat)))
+ (license license:expat))))
(define-public cl-static-dispatch
(sbcl-package->cl-source-package sbcl-static-dispatch))
("anaphora" ,sbcl-anaphora)
("arrows" ,sbcl-arrows)
("cl-custom-hash-table" ,sbcl-custom-hash-table)
+ ("static-dispatch" ,sbcl-static-dispatch)
("trivia" ,sbcl-trivia)))
- (propagated-inputs
- ;; FIXME: Same error as for `sbcl-static-dispatch'.
- `(("static-dispatch" ,cl-static-dispatch)))
(native-inputs
`(("prove" ,sbcl-prove)))
(arguments
(sbcl-package->ecl-package sbcl-defpackage-plus))
(define-public sbcl-deploy
- ;; tagged branch is outdated
- (let ((revision "1")
- (commit "59fd49719ef651a8fc11750bcfb337f132cff75f"))
+ (let ((commit "9b20e64fe924b9e31832304d87a3a72c383dc6d8")
+ (revision "2"))
(package
(name "sbcl-deploy")
(version (git-version "1.0.0" revision commit))
(uri (git-reference
(url "https://github.com/Shinmera/deploy")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "deploy" version))
(sha256
- (base32 "1vl2116z4kw2pd3qd3n6mmg8g0mnwxr9dgddk86g7j1bis1z8k9a"))))
+ (base32 "07pfkibaridihg8lbq2czwa4iqifqk24n6rx7bfnv7i49p1ppja1"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:test-asd-file "deploy-test.asd"
+ #:asd-files '("deploy.asd"
+ "deploy-test.asd")))
+ (native-inputs
+ `(("cl-mpg123" ,sbcl-cl-mpg123)
+ ("cl-out123" ,sbcl-cl-out123)))
(inputs
`(("cffi" ,sbcl-cffi)
- ("documentation-utils" ,sbcl-documentation-utils)))
- (arguments
- '(#:asd-files '("deploy.asd")))
+ ("documentation-utils" ,sbcl-documentation-utils)
+ ("trivial-features" ,sbcl-trivial-features)))
(home-page "https://shinmera.github.io/deploy/")
(synopsis "Deployment tools for standalone Common Lisp application")
(description
(sbcl-package->cl-source-package sbcl-clml))
(define-public sbcl-utm-ups
- (let ((commit "780f1d8ab6290ad2be0f40e2cddc2535fa6fe979")
+ (let ((commit "ffcb7b6d5a56fb7d4b2b95b83bbd28ffe6e6961f")
(revision "0"))
(package
(name "sbcl-utm-ups")
- (version (git-version "1.0" revision commit))
+ (version (git-version "1.1" revision commit))
(source
(origin
(method git-fetch)
(commit commit)))
(file-name (git-file-name "utm-ups" version))
(sha256
- (base32 "0l3kr2m56skf5cx3kkkdcis7msmidcsixx9fqjapkcjsj8x67aqq"))))
+ (base32 "1rvyh0srgd81kvbzmq4ysd9y6c0qdwh23naqxc9asw1vh7fq08x1"))))
(build-system asdf-build-system/sbcl)
(native-inputs
`(("fiveam" ,sbcl-fiveam)))
(define-public ecl-clesh
(sbcl-package->ecl-package sbcl-clesh))
+(define-public sbcl-trivial-channels
+ (let ((commit "e2370118d8983ba69c0360a7695f8f2e2fd6a8a6")
+ (revision "1"))
+ (package
+ (name "sbcl-trivial-channels")
+ (version (git-version "1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/rpav/trivial-channels")
+ (commit commit)))
+ (file-name (git-file-name "trivial-channels" version))
+ (sha256
+ (base32 "04wnxcgk40x8p0gxnz9arv1a5wasdqrdxa8c4p5v7r2mycfps6jj"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("trivial-timeout" ,sbcl-trivial-timeout)))
+ (home-page "https://github.com/rpav/trivial-channels")
+ (synopsis "Common Lisp simple thread-safe channels with timeout")
+ (description
+ "It's very basic implementation of channels and queue for Common Lisp.")
+ (license license:bsd-2))))
+
+(define-public ecl-trivial-channels
+ (sbcl-package->ecl-package sbcl-trivial-channels))
+
+(define-public cl-trivial-channels
+ (sbcl-package->cl-source-package sbcl-trivial-channels))
+
(define-public sbcl-trivial-download
(let ((commit "d2472061d86b1cf3d32f388daacd4e32a13af699"))
(package
(sbcl-package->ecl-package sbcl-cl-progress-bar))
(define-public sbcl-repl-utilities
- (let ((commit "e0de9c92e774f77cab1a4cd92e2ac922ac3a807e"))
+ (let ((commit "7e300df663177ea4581f4e7e9c601377881dd986"))
(package
(name "sbcl-repl-utilities")
(version (git-version "0.0.0" "1" commit))
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "1r5icmw3ha5y77kvzqni3a9bcd66d9pz5mjsbw04xg3jk0d15cgz"))))
+ (base32 "1hh56pq5nw3l4b83dzlyss69f06r038byj2cnjwvci4hfjhdfcc3"))))
(build-system asdf-build-system/sbcl)
(home-page "https://github.com/m-n/repl-utilities")
(synopsis "Ease common tasks at the Common Lisp REPL")
(sbcl-package->cl-source-package sbcl-shlex))
(define-public sbcl-cmd
- (let ((commit "e6a54dbf660bf229c80abc124fa47e7bb6d20c93"))
+ (let ((commit "bc5a3bee8f22917126e4c3d05b33f766e562dbd8"))
(package
(name "sbcl-cmd")
- (version (git-version "0.0.1" "2" commit))
+ (version (git-version "0.0.1" "3" commit))
(source
(origin
(method git-fetch)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "1i0l8ci4cnkx84q4afmpkq51nxah24fqpi6k9kgjbxz6li3zp8hy"))))
+ (base32 "1sjlabrknw1kjb2y89vssjhcqh3slgly8wnr3152zgis8lsj2yc7"))))
(build-system asdf-build-system/sbcl)
(inputs
`(("alexandria" ,sbcl-alexandria)
("coreutils" ,coreutils)
+ ("procps" ,procps)
("serapeum" ,sbcl-serapeum)
("shlex" ,sbcl-shlex)
("trivia" ,sbcl-trivia)))
(modify-phases %standard-phases
(add-after 'unpack 'fix-paths
(lambda* (#:key inputs #:allow-other-keys)
- (let ((bin (string-append (assoc-ref inputs "coreutils") "/bin")))
+ (let ((bin (string-append (assoc-ref inputs "coreutils") "/bin"))
+ (ps-bin (string-append (assoc-ref inputs "procps") "/bin")))
(substitute* "cmd.lisp"
- (("\"env\"") (format #f "\"~a/env\"" bin))
- (("\"pwd\"") (format #f "\"~a/pwd\"" bin)))))))))
+ (("\\(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)))))))))
(home-page "https://github.com/ruricolist/cmd")
(synopsis "Conveniently run external programs from Common Lisp")
(description
(sbcl-package->cl-source-package sbcl-trivial-do))
(define-public sbcl-common-lisp-jupyter
- (let ((commit "61a9a8e7a18e2abd7af7c697ba5146fd19bd9d62"))
+ (let ((commit "011f60b69a3b8c70eefeafe7acb724cd00dd3e62"))
(package
(name "sbcl-common-lisp-jupyter")
- (version (git-version "0.1" "1" commit))
+ (version (git-version "0.1" "2" commit))
(source
(origin
(method git-fetch)
(commit commit)))
(file-name (git-file-name name commit))
(sha256
- (base32 "0zyzl55l45w9z65ygi5pcwda5w5p1j1bb0p2zg2n5cpv8344dkh2"))))
+ (base32 "10jdghlcmp9p6ygrvw7g49i8f9jy71ybzn29n544fzb6g47siqhw"))))
(build-system asdf-build-system/sbcl)
(inputs
`(("alexandria" ,sbcl-alexandria)
(define-public cl-common-lisp-jupyter
(sbcl-package->cl-source-package sbcl-common-lisp-jupyter))
+
+(define-public sbcl-radiance
+ (let ((commit "5ffbe1f157edd17a13194495099efd81e052df85")
+ (revision "1"))
+ (package
+ (name "sbcl-radiance")
+ (version (git-version "2.1.2" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Shirakumo/radiance")
+ (commit commit)))
+ (file-name (git-file-name "radiance" version))
+ (sha256
+ (base32 "0hbkcnmnlj1cqzbv18zmla2iwbl65kxilz9764hndf8x8as1539c"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:tests? #f ; TODO: The tests require some configuration.
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'disable-quicklisp
+ (lambda _
+ ;; Disable the automatic installation of systems by Quicklisp.
+ ;; (Maybe there would be a way to package Quicklisp and make it
+ ;; install things in the user's directory instead of
+ ;; /gnu/store/...).
+ (substitute* "interfaces.lisp"
+ (("\\(unless \\(asdf:find-system configured-implementation NIL\\)"
+ all)
+ (string-append "#+quicklisp " all))))))))
+ (native-inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("dexador" ,sbcl-dexador)
+ ("parachute" ,sbcl-parachute)
+ ("verbose" ,sbcl-verbose)))
+ (inputs
+ `(("babel" ,sbcl-babel)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("closer-mop" ,sbcl-closer-mop)
+ ("documentation-utils" ,sbcl-documentation-utils)
+ ("deploy" ,sbcl-deploy)
+ ("form-fiddle" ,sbcl-form-fiddle)
+ ("lambda-fiddle" ,sbcl-lambda-fiddle)
+ ("local-time" ,sbcl-local-time)
+ ("modularize-hooks" ,sbcl-modularize-hooks)
+ ("modularize-interfaces" ,sbcl-modularize-interfaces)
+ ("puri" ,sbcl-puri)
+ ("trivial-indent" ,sbcl-trivial-indent)
+ ("trivial-mimes" ,sbcl-trivial-mimes)
+ ("ubiquitous-concurrent" ,sbcl-ubiquitous)))
+ (home-page "https://shirakumo.github.io/radiance/")
+ (synopsis "Common Lisp web application environment")
+ (description
+ "Radiance is a web application environment, which is sort of like a web
+framework, but more general, more flexible. It should let you write personal
+websites and generally deployable applications easily and in such a way that
+they can be used on practically any setup without having to undergo special
+adaptations.")
+ (license license:zlib))))
+
+(define-public ecl-radiance
+ (sbcl-package->ecl-package sbcl-radiance))
+
+(define-public cl-radiance
+ (sbcl-package->cl-source-package sbcl-radiance))
+
+(define-public sbcl-daemon
+ (let ((commit "d5652f4332c3cee21e9bf83b9237129605004597")
+ (revision "1"))
+ (package
+ (name "sbcl-daemon")
+ (version (git-version "0.0.4" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/snmsts/daemon")
+ (commit commit)))
+ (file-name (git-file-name "daemon" version))
+ (sha256
+ (base32 "1kdxfnhh9fz34j8qs7pn7mwjz3v33q4v9nh0hqkyzraq5xs2j3f4"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("trivial-features" ,sbcl-trivial-features)))
+ (home-page "https://github.com/snmsts/daemon")
+ (synopsis "Daemonize Common Lisp processes")
+ (description
+ "DAEMON provides the functionality of daemonizing Common Lisp processes
+on UNIX like platforms.")
+ (license license:expat))))
+
+(define-public ecl-daemon
+ (sbcl-package->ecl-package sbcl-daemon))
+
+(define-public cl-daemon
+ (sbcl-package->cl-source-package sbcl-daemon))
+
+(define-public sbcl-file-attributes
+ (let ((commit "bbde396438f37d676de9775239115410bec4da2d"))
+ (package
+ (name "sbcl-file-attributes")
+ (version (git-version "1.0.0" "2" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Shinmera/file-attributes/")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0n8q818ry2shggjfhp8gjby8v5mla9pg97c5g19pcglpnwim7a74"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("cffi" ,sbcl-cffi)
+ ("documentation-utils" ,sbcl-documentation-utils)
+ ("trivial-features" ,sbcl-trivial-features)))
+ (home-page "https://shinmera.github.io/file-attributes/")
+ (synopsis "Access to common file attributes in Common Lisp")
+ (description
+ "This is a small OS portability library to retrieve and set file
+attributes not supported by the Common Lisp standard functions.")
+ (license license:zlib))))
+
+(define-public ecl-file-attributes
+ (sbcl-package->ecl-package sbcl-file-attributes))
+
+(define-public cl-file-attributes
+ (sbcl-package->cl-source-package sbcl-file-attributes))
+
+(define-public sbcl-cl-difflib
+ (let ((commit "98eb335c693f1881584b83ca7be4a0fe05355c4e")
+ (revision "0"))
+ (package
+ (name "sbcl-cl-difflib")
+ (version (git-version "0.2" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/wiseman/cl-difflib")
+ (commit commit)))
+ (file-name
+ (git-file-name name version))
+ (sha256
+ (base32 "08if0abhqg191xcz9s7xv8faqq51nswzp8hw423fkqjzr24pmq48"))))
+ (build-system asdf-build-system/sbcl)
+ ;; Due to the age of this library tests use some deprecated
+ ;; functionality and keep failing.
+ (arguments
+ '(#:tests? #f
+ #:asd-files '("cl-difflib.asd")))
+ (home-page "https://github.com/wiseman/cl-difflib")
+ (synopsis "Compute differences between pairs of sequences")
+ (description
+ "A Common Lisp library for computing differences between
+sequences based on the Python difflib module.")
+ (license license:expat))))
+
+(define-public ecl-cl-difflib
+ (sbcl-package->ecl-package sbcl-cl-difflib))
+
+(define-public cl-difflib
+ (sbcl-package->cl-source-package sbcl-cl-difflib))
+
+(define-public sbcl-cl-html-diff
+ (let ((commit "5a0b39d1c524278d6f60851d7786bb2585614310")
+ (revision "0"))
+ (package
+ (name "sbcl-cl-html-diff")
+ (version (git-version "0.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/wiseman/cl-html-diff")
+ (commit commit)))
+ (file-name
+ (git-file-name name version))
+ (sha256
+ (base32 "1varnijivzd4jpimn1cz8p5ks713zzha5cgl4vmb0xr8ahravwzb"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("cl-difflib" ,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 ecl-cl-html-diff
+ (sbcl-package->ecl-package sbcl-cl-html-diff))
+
+(define-public cl-html-diff
+ (sbcl-package->cl-source-package sbcl-cl-html-diff))
+
+(define-public sbcl-tooter
+ (let ((commit "b8d4b245b1d946bc9da6f51a3d8c2dc43e4d3868")
+ (revision "1"))
+ (package
+ (name "sbcl-tooter")
+ (version (git-version "1.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Shinmera/tooter")
+ (commit commit)))
+ (file-name (git-file-name "tooter" version))
+ (sha256
+ (base32 "0g40dlis4dbw4p3zxz3scx27b9zm8zlzihywapf5zqrdqfx5hpq9"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
+ ("sbcl-documentation-utils" ,sbcl-documentation-utils)
+ ("sbcl-drakma" ,sbcl-drakma)
+ ("sbcl-yason" ,sbcl-yason)))
+ (synopsis "Common Lisp client library for Mastodon instances")
+ (description
+ "This is a Common Lisp library implementing the full v1 REST API
+protocol for Mastodon.")
+ (home-page "https://shinmera.github.io/tooter/")
+ (license license:zlib))))
+
+(define-public ecl-tooter
+ (sbcl-package->ecl-package sbcl-tooter))
+
+(define-public cl-tooter
+ (sbcl-package->cl-source-package sbcl-tooter))
+
+(define-public sbcl-croatoan
+ (let ((commit "89ecd147cf1548f569f23353b3ab656cfb74de1f")
+ (revision "1"))
+ (package
+ (name "sbcl-croatoan")
+ (version (git-version "0.0.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/McParen/croatoan")
+ (commit commit)))
+ (file-name (git-file-name "croatoan" version))
+ (sha256
+ (base32 "0pk4mym88531jx0f1zmm6gmvrmdjzj2zcl2cdywdsxvjygr53zyx"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "ncurses/ncurses.lisp"
+ (("libncursesw" all)
+ (string-append (assoc-ref inputs "ncurses")
+ "/lib/"
+ all))))))))
+ (inputs
+ `(("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("cffi" ,sbcl-cffi)
+ ("ncurses" ,ncurses)
+ ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
+ (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 ecl-croatoan
+ (sbcl-package->ecl-package sbcl-croatoan))
+
+(define-public cl-croatoan
+ (sbcl-package->cl-source-package sbcl-croatoan))
+
+(define-public sbcl-cl-spark
+ (let ((commit "4e34bcebdcf8e45265986eb43ad4ad03bb41a581")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-spark")
+ (version (git-version "0.1.13" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/tkych/cl-spark")
+ (commit commit)))
+ (file-name (git-file-name "cl-spark" version))
+ (sha256
+ (base32 "0my1fsgi2rjaqkpk934f2bjy63pmnj7faza3fzvnk6k3l66y19nk"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("fiveam" ,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 ecl-cl-spark
+ (sbcl-package->ecl-package sbcl-cl-spark))
+
+(define-public cl-spark
+ (sbcl-package->cl-source-package sbcl-cl-spark))
+
+(define-public sbcl-access
+ (let ((commit "1b26db3760018cdc4624f880f0a1e0155d8f6c50")
+ (revision "1"))
+ (package
+ (name "sbcl-access")
+ (version (git-version "1.5.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sharplispers/access")
+ (commit commit)))
+ (file-name (git-file-name "access" version))
+ (sha256
+ (base32 "1knd3n4mpzkc97i1znbas32pscd30416isvmx2pjmgvar6k93pl5"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("lisp-unit2" ,sbcl-lisp-unit2)))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("anaphora" ,sbcl-anaphora)
+ ("closer-mop" ,sbcl-closer-mop)
+ ("interpol" ,sbcl-cl-interpol)
+ ("iterate" ,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/sharplispers/access")
+ (license license:bsd-3))))
+
+(define-public ecl-access
+ (sbcl-package->ecl-package sbcl-access))
+
+(define-public cl-access
+ (sbcl-package->cl-source-package sbcl-access))
+
+(define-public sbcl-sxql-composer
+ (let ((commit "2b2230cb01ae1b68e28921d99e4814046867fb75")
+ (revision "1"))
+ (package
+ (name "sbcl-sxql-composer")
+ (version (git-version "0.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/mmontone/sxql-composer")
+ (commit commit)))
+ (file-name (git-file-name "sxql-composer" version))
+ (sha256
+ (base32 "1agkrj3ymskzc3c7pxbrj123d1kygjqcls145m0ap3i07q96hh1r"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("sxql" ,sbcl-sxql)))
+ (synopsis "Build and compose SXQL queries dynamically")
+ (description
+ "This is a Common Lisp library to build and compose SXQL queries
+dynamically.")
+ (home-page "https://github.com/mmontone/sxql-composer")
+ (license license:expat))))
+
+(define-public ecl-sxql-composer
+ (sbcl-package->ecl-package sbcl-sxql-composer))
+
+(define-public cl-sxql-composer
+ (sbcl-package->cl-source-package sbcl-sxql-composer))
HCoop / jackhill / guix / guix.git / blobdiff