;;; Copyright © 2015 Taylan Ulrich Bayırlı/Kammer <taylanbayirli@gmail.com>
;;; Copyright © 2015 Mark H Weaver <mhw@netris.org>
;;; Copyright © 2016 Federico Beffa <beffa@fbengineering.ch>
-;;; Copyright © 2016, 2017 ng0 <ng0@n0.is>
+;;; Copyright © 2016, 2017 Nikita <nikita@n0.is>
;;; Copyright © 2016, 2017 Andy Patterson <ajpatter@uwaterloo.ca>
;;; Copyright © 2017, 2019, 2020 Ricardo Wurmus <rekado@elephly.net>
;;; Copyright © 2017, 2018, 2019 Efraim Flashner <efraim@flashner.co.il>
(sbcl-package->ecl-package sbcl-cl-strings))
(define-public sbcl-trivial-features
- (package
- (name "sbcl-trivial-features")
- (version "0.8")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/trivial-features/trivial-features.git")
- (commit (string-append "v" version))))
- (file-name (git-file-name "trivial-features" version))
- (sha256
- (base32 "0ccv7dqyrk55xga78i5vzlic7mdwp28in3g1a8fqhlk6626scsq9"))))
- (build-system asdf-build-system/sbcl)
- (arguments '(#:tests? #f))
- (home-page "https://cliki.net/trivial-features")
- (synopsis "Ensures consistency of @code{*FEATURES*} in Common Lisp")
- (description "Trivial-features ensures that @code{*FEATURES*} is
+ ;; No release since 2014.
+ (let ((commit "870d03de0ed44067963350936856e17ee725153e"))
+ (package
+ (name "sbcl-trivial-features")
+ (version (git-version "0.8" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/trivial-features/trivial-features.git")
+ (commit commit)))
+ (file-name (git-file-name "trivial-features" version))
+ (sha256
+ (base32 "14pcahr8r2j3idhyy216zyw8jnj1dnrx0qbkkbdqkvwzign1ah4j"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments '(#:tests? #f))
+ (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)))
+ (license license:expat))))
(define-public cl-trivial-features
(sbcl-package->cl-source-package sbcl-trivial-features))
(sbcl-package->ecl-package sbcl-ironclad))
(define-public sbcl-named-readtables
- (let ((commit "4dfb89fa1af6b305b6492b8af042f5190c11e9fc")
- (revision "1"))
+ (let ((commit "64bd53f37a1694cfde48fc38b8f03901f6f0c05b")
+ (revision "2"))
(package
(name "sbcl-named-readtables")
- (version (string-append "0.9-" revision "." (string-take commit 7)))
+ (version (git-version "0.9" revision commit))
(source
(origin
(method git-fetch)
(url "https://github.com/melisgl/named-readtables.git")
(commit commit)))
(sha256
- (base32 "083kgh5462iqbb4px6kq8s7sggvpvkm36hx4qi9rnaw53b6ilqkk"))
+ (base32 "01l4831m7k84qvhzyx0qgdl50isr4zmp40qf6dfq2iqcaj8y4h3n"))
(file-name (git-file-name "named-readtables" version))))
(build-system asdf-build-system/sbcl)
(arguments
(add-after 'unpack 'fix-paths
(lambda* (#:key inputs #:allow-other-keys)
(substitute* "libffi/libffi.lisp"
- (("libffi.so.6" all) (string-append
+ (("libffi.so.7" all) (string-append
(assoc-ref inputs "libffi")
"/lib/" all)))
(substitute* "toolchain/c-toolchain.lisp"
(inputs
`(("iterate" ,sbcl-iterate)
("cffi" ,sbcl-cffi)
- ("trivial-features" ,sbcl-trivial-features)))
+ ("trivial-features" ,sbcl-trivial-features)
+ ("glib" ,glib)
+ ("cairo" ,cairo)
+ ("pango" ,pango)
+ ("gdk-pixbuf" ,gdk-pixbuf)
+ ("gtk" ,gtk+)))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "glib/glib.init.lisp"
+ (("libglib|libgthread" all)
+ (string-append (assoc-ref inputs "glib") "/lib/" all)))
+ (substitute* "gobject/gobject.init.lisp"
+ (("libgobject" all)
+ (string-append (assoc-ref inputs "glib") "/lib/" all)))
+ (substitute* "gio/gio.init.lisp"
+ (("libgio" all)
+ (string-append (assoc-ref inputs "glib") "/lib/" all)))
+ (substitute* "cairo/cairo.init.lisp"
+ (("libcairo" all)
+ (string-append (assoc-ref inputs "cairo") "/lib/" all)))
+ (substitute* "pango/pango.init.lisp"
+ (("libpango" all)
+ (string-append (assoc-ref inputs "pango") "/lib/" all)))
+ (substitute* "gdk-pixbuf/gdk-pixbuf.init.lisp"
+ (("libgdk_pixbuf" all)
+ (string-append (assoc-ref inputs "gdk-pixbuf") "/lib/" all)))
+ (substitute* "gdk/gdk.init.lisp"
+ (("libgdk" all)
+ (string-append (assoc-ref inputs "gtk") "/lib/" all)))
+ (substitute* "gdk/gdk.package.lisp"
+ (("libgtk" all)
+ (string-append (assoc-ref inputs "gtk") "/lib/" all))))))))
(home-page "https://github.com/Ferada/cl-cffi-gtk/")
(synopsis "Common Lisp binding for GTK+3")
(description
(inherit sbcl-cl-cffi-gtk-boot0)
(name "sbcl-cl-cffi-gtk-glib")
(inputs
- `(("glib" ,glib)
- ("bordeaux-threads" ,sbcl-bordeaux-threads)
+ `(("bordeaux-threads" ,sbcl-bordeaux-threads)
,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
(arguments
- `(#:asd-file "glib/cl-cffi-gtk-glib.asd"
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "glib/glib.init.lisp"
- (("libglib|libgthread" all)
- (string-append (assoc-ref inputs "glib") "/lib/" all))))))))))
+ (substitute-keyword-arguments (package-arguments sbcl-cl-cffi-gtk-boot0)
+ ((#:asd-file _ "") "glib/cl-cffi-gtk-glib.asd")))))
(define-public sbcl-cl-cffi-gtk-gobject
(package
(inherit sbcl-cl-cffi-gtk-boot0)
(name "sbcl-cl-cffi-gtk-gobject")
(inputs
- `(("glib" ,glib)
- ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
+ `(("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
("trivial-garbage" ,sbcl-trivial-garbage)
("bordeaux-threads" ,sbcl-bordeaux-threads)
("closer-mop" ,sbcl-closer-mop)
,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
(arguments
- `(#:asd-file "gobject/cl-cffi-gtk-gobject.asd"
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "gobject/gobject.init.lisp"
- (("libgobject" all) (string-append
- (assoc-ref inputs "glib") "/lib/" all)))))
- (add-after 'install 'link-source
- ;; Since source is particularly heavy (16MiB+), let's reuse it
- ;; across the different components of cl-ffi-gtk.
- (lambda* (#:key inputs outputs #:allow-other-keys)
- (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
- "/share/common-lisp/sbcl-source/"
- "cl-cffi-gtk-glib"))
- (out-source (string-append (assoc-ref outputs "out")
- "/share/common-lisp/sbcl-source/"
- "cl-cffi-gtk-gobject")))
- (delete-file-recursively out-source)
- (symlink glib-source out-source)
- #t))))))))
+ (substitute-keyword-arguments (package-arguments sbcl-cl-cffi-gtk-boot0)
+ ((#:asd-file _ "") "gobject/cl-cffi-gtk-gobject.asd")
+ ((#:phases phases)
+ `(modify-phases ,phases
+ (add-after 'install 'link-source
+ ;; Since source is particularly heavy (16MiB+), let's reuse it
+ ;; across the different components of cl-ffi-gtk.
+ (lambda* (#:key inputs outputs #:allow-other-keys)
+ (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
+ "/share/common-lisp/sbcl-source/"
+ "cl-cffi-gtk-glib"))
+ (out-source (string-append (assoc-ref outputs "out")
+ "/share/common-lisp/sbcl-source/"
+ "cl-cffi-gtk-gobject")))
+ (delete-file-recursively out-source)
+ (symlink glib-source out-source)
+ #t)))))))))
(define-public sbcl-cl-cffi-gtk-gio
(package
(inherit sbcl-cl-cffi-gtk-boot0)
(name "sbcl-cl-cffi-gtk-gio")
(inputs
- `(("glib" ,glib)
- ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
+ `(("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
(arguments
- `(#:asd-file "gio/cl-cffi-gtk-gio.asd"
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "gio/gio.init.lisp"
- (("libgio" all)
- (string-append
- (assoc-ref inputs "glib") "/lib/" all)))))
- (add-after 'install 'link-source
- ;; Since source is particularly heavy (16MiB+), let's reuse it
- ;; across the different components of cl-ffi-gtk.
- (lambda* (#:key inputs outputs #:allow-other-keys)
- (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
- "/share/common-lisp/sbcl-source/"
- "cl-cffi-gtk-glib"))
- (out-source (string-append (assoc-ref outputs "out")
- "/share/common-lisp/sbcl-source/"
- "cl-cffi-gtk-gio")))
- (delete-file-recursively out-source)
- (symlink glib-source out-source)
- #t))))))))
+ (substitute-keyword-arguments (package-arguments sbcl-cl-cffi-gtk-boot0)
+ ((#:asd-file _ "") "gio/cl-cffi-gtk-gio.asd")
+ ((#:phases phases)
+ `(modify-phases ,phases
+ (add-after 'install 'link-source
+ ;; Since source is particularly heavy (16MiB+), let's reuse it
+ ;; across the different components of cl-ffi-gtk.
+ (lambda* (#:key inputs outputs #:allow-other-keys)
+ (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
+ "/share/common-lisp/sbcl-source/"
+ "cl-cffi-gtk-glib"))
+ (out-source (string-append (assoc-ref outputs "out")
+ "/share/common-lisp/sbcl-source/"
+ "cl-cffi-gtk-gio")))
+ (delete-file-recursively out-source)
+ (symlink glib-source out-source)
+ #t)))))))))
(define-public sbcl-cl-cffi-gtk-cairo
(package
(inherit sbcl-cl-cffi-gtk-boot0)
(name "sbcl-cl-cffi-gtk-cairo")
(inputs
- `(("cairo" ,cairo)
- ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
+ `(("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
(arguments
- `(#:asd-file "cairo/cl-cffi-gtk-cairo.asd"
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "cairo/cairo.init.lisp"
- (("libcairo" all)
- (string-append
- (assoc-ref inputs "cairo") "/lib/" all)))))
- (add-after 'install 'link-source
- ;; Since source is particularly heavy (16MiB+), let's reuse it
- ;; across the different components of cl-ffi-gtk.
- (lambda* (#:key inputs outputs #:allow-other-keys)
- (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
- "/share/common-lisp/sbcl-source/"
- "cl-cffi-gtk-glib"))
- (out-source (string-append (assoc-ref outputs "out")
- "/share/common-lisp/sbcl-source/"
- "cl-cffi-gtk-cairo")))
- (delete-file-recursively out-source)
- (symlink glib-source out-source)
- #t))))))))
+ (substitute-keyword-arguments (package-arguments sbcl-cl-cffi-gtk-boot0)
+ ((#:asd-file _ "") "cairo/cl-cffi-gtk-cairo.asd")
+ ((#:phases phases)
+ `(modify-phases ,phases
+ (add-after 'install 'link-source
+ ;; Since source is particularly heavy (16MiB+), let's reuse it
+ ;; across the different components of cl-ffi-gtk.
+ (lambda* (#:key inputs outputs #:allow-other-keys)
+ (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
+ "/share/common-lisp/sbcl-source/"
+ "cl-cffi-gtk-glib"))
+ (out-source (string-append (assoc-ref outputs "out")
+ "/share/common-lisp/sbcl-source/"
+ "cl-cffi-gtk-cairo")))
+ (delete-file-recursively out-source)
+ (symlink glib-source out-source)
+ #t)))))))))
(define-public sbcl-cl-cffi-gtk-pango
(package
(inherit sbcl-cl-cffi-gtk-boot0)
(name "sbcl-cl-cffi-gtk-pango")
(inputs
- `(("pango" ,pango)
- ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
+ `(("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
("cl-cffi-gtk-cairo" ,sbcl-cl-cffi-gtk-cairo)
,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
(arguments
- `(#:asd-file "pango/cl-cffi-gtk-pango.asd"
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "pango/pango.init.lisp"
- (("libpango" all)
- (string-append
- (assoc-ref inputs "pango") "/lib/" all)))))
- (add-after 'install 'link-source
- ;; Since source is particularly heavy (16MiB+), let's reuse it
- ;; across the different components of cl-ffi-gtk.
- (lambda* (#:key inputs outputs #:allow-other-keys)
- (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
- "/share/common-lisp/sbcl-source/"
- "cl-cffi-gtk-glib"))
- (out-source (string-append (assoc-ref outputs "out")
- "/share/common-lisp/sbcl-source/"
- "cl-cffi-gtk-pango")))
- (delete-file-recursively out-source)
- (symlink glib-source out-source)
- #t))))))))
+ (substitute-keyword-arguments (package-arguments sbcl-cl-cffi-gtk-boot0)
+ ((#:asd-file _ "") "pango/cl-cffi-gtk-pango.asd")
+ ((#:phases phases)
+ `(modify-phases ,phases
+ (add-after 'install 'link-source
+ ;; Since source is particularly heavy (16MiB+), let's reuse it
+ ;; across the different components of cl-ffi-gtk.
+ (lambda* (#:key inputs outputs #:allow-other-keys)
+ (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
+ "/share/common-lisp/sbcl-source/"
+ "cl-cffi-gtk-glib"))
+ (out-source (string-append (assoc-ref outputs "out")
+ "/share/common-lisp/sbcl-source/"
+ "cl-cffi-gtk-pango")))
+ (delete-file-recursively out-source)
+ (symlink glib-source out-source)
+ #t)))))))))
(define-public sbcl-cl-cffi-gtk-gdk-pixbuf
(package
(inherit sbcl-cl-cffi-gtk-boot0)
(name "sbcl-cl-cffi-gtk-gdk-pixbuf")
(inputs
- `(("gdk-pixbuf" ,gdk-pixbuf)
- ("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
+ `(("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
(arguments
- `(#:asd-file "gdk-pixbuf/cl-cffi-gtk-gdk-pixbuf.asd"
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "gdk-pixbuf/gdk-pixbuf.init.lisp"
- (("libgdk_pixbuf" all)
- (string-append
- (assoc-ref inputs "gdk-pixbuf") "/lib/" all)))))
- (add-after 'install 'link-source
- ;; Since source is particularly heavy (16MiB+), let's reuse it
- ;; across the different components of cl-ffi-gtk.
- (lambda* (#:key inputs outputs #:allow-other-keys)
- (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
- "/share/common-lisp/sbcl-source/"
- "cl-cffi-gtk-glib"))
- (out-source (string-append (assoc-ref outputs "out")
- "/share/common-lisp/sbcl-source/"
- "cl-cffi-gtk-gdk-pixbuf")))
- (delete-file-recursively out-source)
- (symlink glib-source out-source)
- #t))))))))
+ (substitute-keyword-arguments (package-arguments sbcl-cl-cffi-gtk-boot0)
+ ((#:asd-file _ "") "gdk-pixbuf/cl-cffi-gtk-gdk-pixbuf.asd")
+ ((#:phases phases)
+ `(modify-phases ,phases
+ (add-after 'install 'link-source
+ ;; Since source is particularly heavy (16MiB+), let's reuse it
+ ;; across the different components of cl-ffi-gtk.
+ (lambda* (#:key inputs outputs #:allow-other-keys)
+ (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
+ "/share/common-lisp/sbcl-source/"
+ "cl-cffi-gtk-glib"))
+ (out-source (string-append (assoc-ref outputs "out")
+ "/share/common-lisp/sbcl-source/"
+ "cl-cffi-gtk-gdk-pixbuf")))
+ (delete-file-recursively out-source)
+ (symlink glib-source out-source)
+ #t)))))))))
(define-public sbcl-cl-cffi-gtk-gdk
(package
(inherit sbcl-cl-cffi-gtk-boot0)
(name "sbcl-cl-cffi-gtk-gdk")
(inputs
- `(("gtk" ,gtk+)
- ("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
+ `(("cl-cffi-gtk-glib" ,sbcl-cl-cffi-gtk-glib)
("cl-cffi-gtk-gobject" ,sbcl-cl-cffi-gtk-gobject)
("cl-cffi-gtk-gio" ,sbcl-cl-cffi-gtk-gio)
("cl-cffi-gtk-gdk-pixbuf" ,sbcl-cl-cffi-gtk-gdk-pixbuf)
("cl-cffi-gtk-pango" ,sbcl-cl-cffi-gtk-pango)
,@(package-inputs sbcl-cl-cffi-gtk-boot0)))
(arguments
- `(#:asd-file "gdk/cl-cffi-gtk-gdk.asd"
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "gdk/gdk.init.lisp"
- (("libgdk" all)
- (string-append
- (assoc-ref inputs "gtk") "/lib/" all)))
- (substitute* "gdk/gdk.package.lisp"
- (("libgtk" all)
- (string-append
- (assoc-ref inputs "gtk") "/lib/" all)))))
- (add-after 'install 'link-source
- ;; Since source is particularly heavy (16MiB+), let's reuse it
- ;; across the different components of cl-ffi-gtk.
- (lambda* (#:key inputs outputs #:allow-other-keys)
- (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
- "/share/common-lisp/sbcl-source/"
- "cl-cffi-gtk-glib"))
- (out-source (string-append (assoc-ref outputs "out")
- "/share/common-lisp/sbcl-source/"
- "cl-cffi-gtk-gdk")))
- (delete-file-recursively out-source)
- (symlink glib-source out-source)
- #t))))))))
+ (substitute-keyword-arguments (package-arguments sbcl-cl-cffi-gtk-boot0)
+ ((#:asd-file _ "") "gdk/cl-cffi-gtk-gdk.asd")
+ ((#:phases phases)
+ `(modify-phases ,phases
+ (add-after 'install 'link-source
+ ;; Since source is particularly heavy (16MiB+), let's reuse it
+ ;; across the different components of cl-ffi-gtk.
+ (lambda* (#:key inputs outputs #:allow-other-keys)
+ (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
+ "/share/common-lisp/sbcl-source/"
+ "cl-cffi-gtk-glib"))
+ (out-source (string-append (assoc-ref outputs "out")
+ "/share/common-lisp/sbcl-source/"
+ "cl-cffi-gtk-gdk")))
+ (delete-file-recursively out-source)
+ (symlink glib-source out-source)
+ #t)))))))))
(define-public sbcl-cl-cffi-gtk
(package
(native-inputs
`(("fiveam" ,sbcl-fiveam)))
(arguments
- `(#:asd-file "gtk/cl-cffi-gtk.asd"
- #:test-asd-file "test/cl-cffi-gtk-test.asd"
+ (substitute-keyword-arguments (package-arguments sbcl-cl-cffi-gtk-boot0)
+ ((#:asd-file _ "") "gtk/cl-cffi-gtk.asd")
+ ((#:test-asd-file _ "") "test/cl-cffi-gtk-test.asd")
;; TODO: Tests fail with memory fault.
;; See https://github.com/Ferada/cl-cffi-gtk/issues/24.
- #:tests? #f
- #:phases
- (modify-phases %standard-phases
- (add-after 'install 'link-source
- ;; Since source is particularly heavy (16MiB+), let's reuse it
- ;; across the different components of cl-ffi-gtk.
- (lambda* (#:key inputs outputs #:allow-other-keys)
- (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
- "/share/common-lisp/sbcl-source/"
- "cl-cffi-gtk-glib"))
- (out-source (string-append (assoc-ref outputs "out")
- "/share/common-lisp/sbcl-source/"
- "cl-cffi-gtk")))
- (delete-file-recursively out-source)
- (symlink glib-source out-source)
- #t))))))))
+ ((#:tests? _ #f) #f)
+ ((#:phases phases)
+ `(modify-phases ,phases
+ (add-after 'install 'link-source
+ ;; Since source is particularly heavy (16MiB+), let's reuse it
+ ;; across the different components of cl-ffi-gtk.
+ (lambda* (#:key inputs outputs #:allow-other-keys)
+ (let ((glib-source (string-append (assoc-ref inputs "cl-cffi-gtk-glib")
+ "/share/common-lisp/sbcl-source/"
+ "cl-cffi-gtk-glib"))
+ (out-source (string-append (assoc-ref outputs "out")
+ "/share/common-lisp/sbcl-source/"
+ "cl-cffi-gtk")))
+ (delete-file-recursively out-source)
+ (symlink glib-source out-source)
+ #t)))))))))
(define-public cl-cffi-gtk
(sbcl-package->cl-source-package sbcl-cl-cffi-gtk))
`(("alexandria" ,sbcl-alexandria)
("bordeaux-threads" ,sbcl-bordeaux-threads)
("trivial-garbage" ,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
(home-page "https://common-lisp.net/project/trivial-backtrace/")
(synopsis "Portable simple API to work with backtraces in Common Lisp")
(description
- "On of the many things that didn't quite get into the Common Lisp
+ "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
(sbcl-package->cl-source-package sbcl-map-set))
(define-public sbcl-quri
- (let ((commit "76b75103f21ead092c9f715512fa82441ef61185")
- (revision "1"))
+ (let ((commit "b53231c5f19446dd7c24b15a249fefa45ae94f9a")
+ (revision "2"))
(package
(name "sbcl-quri")
(version (git-version "0.1.0" revision commit))
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "1ccbxsgzdibmzq33mmbmmz9vwl6l03xh6nbpsh1hkdvdcl7q0a60"))))
+ (base32 "0cansr63m690ymvhway419178mq2sqnmxm4rdxclbsrnjwwbi36m"))))
(build-system asdf-build-system/sbcl)
(arguments
;; Tests fail with: Component QURI-ASD::QURI-TEST not found,
(let ((python (assoc-ref inputs "python")))
(setenv "BB_PYTHON3_INCLUDE_DIR"
(string-append python "/include/python"
- (python-version python)
- "m"))
+ (python-version python)))
(setenv "BB_PYTHON3_DYLIB"
(string-append python "/lib/libpython3.so"))
- #t))))))
+ #t)))
+ (add-after 'unpack 'adjust-for-python-3.8
+ (lambda _
+ ;; This method is no longer part of the public API.
+ (substitute* "ffi-interface.lisp"
+ ((".*PyEval_ReInitThreads.*")
+ ""))
+ #t)))))
(native-inputs
`(("sbcl-cl-fad" ,sbcl-cl-fad)
("sbcl-lift" ,sbcl-lift)
(synopsis "Base package for IOLib, a Common Lisp I/O library")))
(define-public sbcl-iolib.grovel
- (package
- (inherit sbcl-iolib.asdf)
- (name "sbcl-iolib.grovel")
- (inputs
- `(("iolib.asdf" ,sbcl-iolib.asdf)
- ("iolib.conf" ,sbcl-iolib.conf)
- ("iolib.base", sbcl-iolib.base)
- ("cffi", sbcl-cffi)))
- (arguments
- '(#:asd-file "iolib.grovel.asd"
- #:phases
- (modify-phases %standard-phases
- (add-after 'install 'install-header
- (lambda* (#:key outputs #:allow-other-keys)
- ;; This header is required by sbcl-iolib.
- (install-file "src/grovel/grovel-common.h"
- (string-append (assoc-ref outputs "out")
- "/lib/sbcl"))
- #t)))))
- (synopsis "CFFI Groveller for IOLib, a Common Lisp I/O library")))
+ (deprecated-package "sbcl-iolib.grovel" sbcl-cffi-grovel))
(define sbcl-iolib+syscalls
(package
((#:asd-system-name _) "iolib")))))
(define-public cl-iolib
- (sbcl-package->cl-source-package sbcl-iolib))
+ (let ((parent (sbcl-package->cl-source-package sbcl-iolib)))
+ (package
+ (inherit parent)
+ (propagated-inputs
+ ;; Need header to compile.
+ `(("libfixposix" ,libfixposix)
+ ,@(package-propagated-inputs parent))))))
(define-public sbcl-ieee-floats
(let ((commit "566b51a005e81ff618554b9b2f0b795d3b29398d")
;; asdf-build-system/source has its own phases and does not inherit
;; from asdf-build-system/sbcl phases.
(modify-phases %standard-phases/source
- (add-after 'unpack 'fix-permissions
- (lambda _ (make-file-writable "t/data/test.gz") #t)))))))
+ ;; Already done in SBCL package.
+ (delete 'reset-gzip-timestamps))))))
(define-public ecl-dexador
(sbcl-package->ecl-package sbcl-dexador))
(sbcl-package->cl-source-package sbcl-lisp-namespace))
(define-public sbcl-trivial-cltl2
- (let ((commit "8eec8407df833e8f27df8a388bc10913f16d9e83")
- (revision "1"))
+ (let ((commit "8a3bda30dc25d2f65fcf514d0eb6e6db75252c61")
+ (revision "2"))
(package
(name "sbcl-trivial-cltl2")
(build-system asdf-build-system/sbcl)
(file-name (git-file-name name version))
(sha256
(base32
- "1dyyxz17vqv8hlfwq287gl8xxbvcnq798ajb7p5jdjz91wqf4bgk"))))
+ "08cnzb9rnczn4pn2zpf0587ny4wjy1mjndy885fz9pw7xrlx37ip"))))
(synopsis "Simple CLtL2 compatibility layer for Common Lisp")
(description "This library is a portable compatibility layer around
\"Common Lisp the Language, 2nd
(sbcl-package->cl-source-package sbcl-introspect-environment))
(define-public sbcl-type-i
- (let ((commit "dea233f45f94064105ec09f0767de338f67dcbe2")
- (revision "1"))
+ (let ((commit "d34440ab4ebf5a46a58deccb35950b15670e3667")
+ (revision "2"))
(package
(name "sbcl-type-i")
(build-system asdf-build-system/sbcl)
(file-name (git-file-name name version))
(sha256
(base32
- "039g5pbrhh65s0bhr9314gmd2nwc2y5lp2377c5qrc2lxky89qs3"))))
+ "12wsga0pwjkkr176lnjwkmmlm3ccp0n310sjj9h20lk53iyd0z69"))))
(inputs
`(("alexandria" ,sbcl-alexandria)
("introspect-environment" ,sbcl-introspect-environment)
@code{fare-quasiquote-optima}.")))
(define-public sbcl-trivia.level0
- (let ((commit "574901ac376ae54c9d37169fd5efab9b3b8fcc63")
- (revision "1"))
+ (let ((commit "37698b47a14c2007630468de7a993694ef7bd475")
+ (revision "2"))
(package
(name "sbcl-trivia.level0")
(build-system asdf-build-system/sbcl)
(file-name (git-file-name name version))
(sha256
(base32
- "0hf53n71xzr9sjwrxis5fivx3drclf4s39h5ck8vh21ndqj9zvdk"))))
+ "0rsbwbw3ipxxgr6zzhci12nilq8zky475kmhz1rcxy4q8a85vn72"))))
(inputs
`(("alexandria" ,sbcl-alexandria)))
(synopsis "Pattern matching in Common Lisp")
(sbcl-package->cl-source-package sbcl-array-utils))
(define-public sbcl-plump
- (let ((commit "16f1231bf706cfbc54d9e55a853ca945e4452a08")
- (revision "0"))
+ (let ((commit "34f890fe46efdebe7bb70d218f1937e98f632bf9")
+ (revision "1"))
(package
(name "sbcl-plump")
(version (git-version "2.0.0" revision commit))
(file-name (git-file-name name version))
(sha256
(base32
- "0705k8pbip51v74rccgwscwph439f2pma9f915qf1h4bhjx999ip"))))
+ "0a0x8wn6vv1ylxcwck12k18gy0a366kdm6ddxxk7yynl4mwnqgkh"))))
(build-system asdf-build-system/sbcl)
(inputs
`(("array-utils" ,sbcl-array-utils)
(define-public cl-osicat
(sbcl-package->cl-source-package sbcl-osicat))
+
+(define-public sbcl-clx-xembed
+ (let ((commit "a5c4b844d31ee68ffa58c933cc1cdddde6990743")
+ (revision "1"))
+ (package
+ (name "sbcl-clx-xembed")
+ (version (git-version "0.1" revision commit))
+ (home-page "https://github.com/laynor/clx-xembed")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/laynor/clx-xembed.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1abx4v36ycmfjdwpjk4hh8058ya8whwia7ds9vd96q2qsrs57f12"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:asd-system-name "xembed"))
+ (inputs
+ `(("sbcl-clx" ,sbcl-clx)))
+ (synopsis "CL(x) xembed protocol implementation ")
+ (description "CL(x) xembed protocol implementation")
+ ;; MIT License
+ (license license:expat))))
+
+(define-public cl-clx-xembed
+ (sbcl-package->cl-source-package sbcl-clx-xembed))
+
+(define-public ecl-clx-xembed
+ (sbcl-package->ecl-package sbcl-clx-xembed))
+
+(define-public sbcl-quantile-estimator
+ (package
+ (name "sbcl-quantile-estimator")
+ (version "0.0.1")
+ (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))
+ (sha256
+ (base32
+ "0rlswkf0siaabsvvch3dgxmg45fw5w8pd9b7ri2w7a298aya52z9"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-system-name "quantile-estimator"))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)))
+ (home-page "https://github.com/deadtrickster/quantile-estimator.cl")
+ (synopsis
+ "Effective computation of biased quantiles over data streams")
+ (description
+ "Common Lisp implementation of Graham Cormode and S.
+Muthukrishnan's Effective Computation of Biased Quantiles over Data
+Streams in ICDE’05.")
+ (license license:expat)))
+
+(define-public cl-quantile-estimator
+ (sbcl-package->cl-source-package sbcl-quantile-estimator))
+
+(define-public ecl-quantile-estimator
+ (sbcl-package->ecl-package sbcl-quantile-estimator))
+
+(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.git")
+ (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)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("local-time" ,sbcl-local-time)
+ ("quantile-estimator" ,sbcl-quantile-estimator)))
+ (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 cl-prometheus
+ (sbcl-package->cl-source-package sbcl-prometheus))
+
+(define-public ecl-prometheus
+ (sbcl-package->ecl-package sbcl-prometheus))
+
+(define-public sbcl-prometheus.collectors.sbcl
+ (package
+ (inherit sbcl-prometheus)
+ (name "sbcl-prometheus.collectors.sbcl")
+ (inputs `(("prometheus" ,sbcl-prometheus)))
+ (synopsis "Prometheus collector for SBCL metrics")
+ (description "Prometheus collector for SBCL metrics.")))
+
+(define-public cl-prometheus.collectors.sbcl
+ (sbcl-package->cl-source-package sbcl-prometheus.collectors.sbcl))
+
+(define-public sbcl-prometheus.collectors.process
+ (package
+ (inherit sbcl-prometheus)
+ (name "sbcl-prometheus.collectors.process")
+ (inputs
+ `(("cffi" ,sbcl-cffi)
+ ("cffi-grovel" ,sbcl-cffi-grovel)
+ ("cl-fad" ,sbcl-cl-fad)
+ ("prometheus" ,sbcl-prometheus)
+ ("split-sequence" ,sbcl-split-sequence)))
+ (synopsis "Prometheus collector for process metrics")
+ (description "Prometheus collector for process metrics.")))
+
+(define-public cl-prometheus.collectors.process
+ (sbcl-package->cl-source-package sbcl-prometheus.collectors.process))
+
+(define-public ecl-prometheus.collectors.process
+ (sbcl-package->ecl-package sbcl-prometheus.collectors.process))
+
+(define-public sbcl-prometheus.formats.text
+ (package
+ (inherit sbcl-prometheus)
+ (name "sbcl-prometheus.formats.text")
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("prometheus" ,sbcl-prometheus)))
+ (synopsis "Prometheus client text format")
+ (description "Prometheus client text format.")))
+
+(define-public cl-prometheus.formats.text
+ (sbcl-package->cl-source-package sbcl-prometheus.formats.text))
+
+(define-public ecl-prometheus.formats.text
+ (sbcl-package->ecl-package sbcl-prometheus.formats.text))
+
+(define-public sbcl-prometheus.exposers.hunchentoot
+ (package
+ (inherit sbcl-prometheus)
+ (name "sbcl-prometheus.exposers.hunchentoot")
+ (inputs
+ `(("hunchentoot" ,sbcl-hunchentoot)
+ ("prometheus" ,sbcl-prometheus)
+ ("prometheus.formats.text" ,sbcl-prometheus.formats.text)
+ ("salza2" ,sbcl-salza2)
+ ("trivial-utf-8" ,sbcl-trivial-utf-8)))
+ (synopsis "Prometheus collector for Hunchentoot metrics")
+ (description "Prometheus collector for Hunchentoot metrics")))
+
+(define-public cl-prometheus.exposers.hunchentoot
+ (sbcl-package->cl-source-package sbcl-prometheus.exposers.hunchentoot))
+
+(define-public sbcl-prometheus.pushgateway
+ (package
+ (inherit sbcl-prometheus)
+ (name "sbcl-prometheus.pushgateway")
+ (inputs
+ `(("drakma" ,sbcl-drakma)
+ ("prometheus" ,sbcl-prometheus)
+ ("prometheus.formats.text" ,sbcl-prometheus.formats.text)))
+ (synopsis "Prometheus Pushgateway client")
+ (description "Prometheus Pushgateway client.")))
+
+(define-public cl-prometheus.pushgateway
+ (sbcl-package->cl-source-package sbcl-prometheus.pushgateway))
+
+(define-public ecl-prometheus.pushgateway
+ (sbcl-package->ecl-package sbcl-prometheus.pushgateway))
+
+(define-public sbcl-uuid
+ (let ((commit "e7d6680c3138385c0708f7aaf0c96622eeb140e8"))
+ (package
+ (name "sbcl-uuid")
+ (version (git-version "2012.12.26" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/dardoria/uuid.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0jnyp2kibcf5cwi60l6grjrj8wws9chasjvsw7xzwyym2lyid46f"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("ironclad" ,sbcl-ironclad)
+ ("trivial-utf-8" ,sbcl-trivial-utf-8)))
+ (home-page "https://github.com/dardoria/uuid")
+ (synopsis
+ "Common Lisp implementation of UUIDs according to RFC4122")
+ (description
+ "Common Lisp implementation of UUIDs according to RFC4122.")
+ (license license:llgpl))))
+
+(define-public cl-uuid
+ (sbcl-package->cl-source-package sbcl-uuid))
+
+(define-public ecl-uuid
+ (sbcl-package->ecl-package sbcl-uuid))
+
+(define-public sbcl-dissect
+ (let ((commit "cffd38479f0e64e805f167bbdb240b783ecc8d45"))
+ (package
+ (name "sbcl-dissect")
+ (version (git-version "1.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Shinmera/dissect.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0rmsjkgjl90gl6ssvgd60hb0d5diyhsiyypvw9hbc0ripvbmk5r5"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("cl-ppcre" ,sbcl-cl-ppcre)))
+ (home-page "https://shinmera.github.io/dissect/")
+ (synopsis
+ "Introspection library for the call stack and restarts")
+ (description
+ "Dissect is a small Common Lisp library for introspecting the call stack
+and active restarts.")
+ (license license:zlib))))
+
+(define-public cl-dissect
+ (sbcl-package->cl-source-package sbcl-dissect))
+
+(define-public ecl-dissect
+ (sbcl-package->ecl-package sbcl-dissect))
+
+;; TODO: Uses ASDF's package-inferred-system which is not supported by
+;; asdf-build-system/sbcl as of 2020-05-21. We should fix
+;; asdf-build-system/sbcl.
+(define-public sbcl-rove
+ (package
+ (name "sbcl-rove")
+ (version "0.9.6")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/rove.git")
+ (commit "f3695db08203bf26f3b861dc22ac0f4257d3ec21")))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "07ala4l2fncxf540fzxj3h5mhi9i4wqllhj0rqk8m2ljl5zbz89q"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("dissect" ,sbcl-dissect)
+ ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
+ (home-page "https://github.com/fukamachi/rove")
+ (synopsis
+ "Yet another common lisp testing library")
+ (description
+ "Rove is a unit testing framework for Common Lisp applications.
+This is intended to be a successor of Prove.")
+ (license license:bsd-3)))
+
+(define-public cl-rove
+ (sbcl-package->cl-source-package sbcl-rove))
+
+(define-public ecl-rove
+ (sbcl-package->ecl-package sbcl-rove))
+
+(define-public sbcl-exponential-backoff
+ (let ((commit "8d9e8444d8b3184a524c12ce3449f91613ab714f"))
+ (package
+ (name "sbcl-exponential-backoff")
+ (version (git-version "0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/death/exponential-backoff.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1389hm9hxv85s0125ja4js1bvh8ay4dsy9q1gaynjv27ynik6gmv"))))
+ (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.")
+ (license license:expat))))
+
+(define-public cl-exponential-backoff
+ (sbcl-package->cl-source-package sbcl-exponential-backoff))
+
+(define-public ecl-exponential-backoff
+ (sbcl-package->ecl-package sbcl-exponential-backoff))
+
+(define-public sbcl-sxql
+ (let ((commit "5aa8b739492c5829e8623432b5d46482263990e8"))
+ (package
+ (name "sbcl-sxql")
+ (version (git-version "0.1.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/sxql.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0k25p6w2ld9cn8q8s20lda6yjfyp4q89219sviayfgixnj27avnj"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:test-asd-file "sxql-test.asd"))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-syntax-annot" ,sbcl-cl-syntax-annot)
+ ("iterate" ,sbcl-iterate)
+ ("optima" ,sbcl-optima)
+ ("split-sequence" ,sbcl-split-sequence)
+ ("trivial-types" ,sbcl-trivial-types)))
+ (native-inputs
+ `(("prove" ,sbcl-prove)
+ ("prove-asdf" ,sbcl-prove-asdf)))
+ (home-page "https://github.com/fukamachi/sxql")
+ (synopsis "SQL generator for Common Lisp")
+ (description "SQL generator for Common Lisp.")
+ (license license:bsd-3))))
+
+(define-public cl-sxql
+ (sbcl-package->cl-source-package sbcl-sxql))
+
+(define-public ecl-sxql
+ (sbcl-package->ecl-package sbcl-sxql))
+
+(define-public sbcl-1am
+ (let ((commit "8b1da94eca4613fd8a20bdf63f0e609e379b0ba5"))
+ (package
+ (name "sbcl-1am")
+ (version (git-version "0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/lmj/1am.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "05ss4nz1jb9kb796295482b62w5cj29msfj8zis33sp2rw2vmv2g"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:asd-system-name "1am"))
+ (home-page "https://github.com/lmj/1am")
+ (synopsis "Minimal testing framework for Common Lisp")
+ (description "A minimal testing framework for Common Lisp.")
+ (license license:expat))))
+
+(define-public cl-1am
+ (sbcl-package->cl-source-package sbcl-1am))
+
+(define-public ecl-1am
+ (sbcl-package->ecl-package sbcl-1am))
+
+(define-public sbcl-cl-ascii-table
+ (let ((commit "d9f5e774a56fad1b416e4dadb8f8a5b0e84094e2")
+ (revision "1"))
+ (package
+ (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/telephil/cl-ascii-table.git")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "125fdif9sgl7k0ngjhxv0wjas2q27d075025hvj2rx1b1x948z4s"))))
+ (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))))
+
+(define-public cl-ascii-table
+ (sbcl-package->cl-source-package sbcl-cl-ascii-table))
+
+(define-public ecl-cl-ascii-table
+ (sbcl-package->ecl-package sbcl-cl-ascii-table))
+
+(define-public sbcl-cl-rdkafka
+ (package
+ (name "sbcl-cl-rdkafka")
+ (version "1.0.2")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/SahilKang/cl-rdkafka.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1qcgfd4h7syilzmrmd4z2vknbvawda3q3ykw7xm8n381syry4g82"))))
+ (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)))))
+ (add-before 'cleanup 'move-bundle
+ (lambda* (#:key outputs #:allow-other-keys)
+ (let* ((out (assoc-ref outputs "out"))
+ (actual (string-append out "/lib/sbcl/src/cl-rdkafka.fasl"))
+ (expected (string-append
+ out "/lib/sbcl/cl-rdkafka--system.fasl")))
+ (copy-file actual expected)
+ #t))))))
+ (inputs
+ `(("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("cffi" ,sbcl-cffi)
+ ("cffi-grovel" ,sbcl-cffi-grovel)
+ ("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-rdkafka
+ (sbcl-package->cl-source-package sbcl-cl-rdkafka))
+
+(define-public sbcl-acclimation
+ (let ((commit "4d51150902568fcd59335f4cc4cfa022df6116a5"))
+ (package
+ (name "sbcl-acclimation")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/robert-strandh/Acclimation")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1aw7rarjl8ai57h0jxnp9hr3dka7qrs55mmbl1p6rhd6xj8mp9wq"))))
+ (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))))
+
+(define-public cl-acclimation
+ (sbcl-package->cl-source-package sbcl-acclimation))
HCoop / jackhill / guix / guix.git / blobdiff