+
+(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")
+ (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")
+ (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")
+ (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")
+ (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")
+ (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")
+ (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")
+ (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")
+ (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")
+ (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")
+ (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))
+
+(define-public sbcl-clump-2-3-tree
+ (let ((commit "1ea4dbac1cb86713acff9ae58727dd187d21048a"))
+ (package
+ (name "sbcl-clump-2-3-tree")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/robert-strandh/Clump")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1639msyagsswj85gc0wd90jgh8588j3qg5q70by9s2brf2q6w4lh"))))
+ (arguments
+ '(#:asd-file "2-3-tree/clump-2-3-tree.asd"
+ #:asd-system-name "clump-2-3-tree"))
+ (inputs
+ `(("acclimation" ,sbcl-acclimation)))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/robert-strandh/Clump")
+ (synopsis "Implementation of 2-3 trees for Common Lisp")
+ (description "The purpose of this library is to provide a collection of
+implementations of trees.
+
+In contrast to existing libraries such as cl-containers, it does not impose a
+particular use for the trees. Instead, it aims for a stratified design,
+allowing client code to choose between different levels of abstraction.
+
+As a consequence of this policy, low-level interfaces are provided where
+the concrete representation is exposed, but also high level interfaces
+where the trees can be used as search trees or as trees that represent
+sequences of objects.")
+ (license license:bsd-2))))
+
+(define-public sbcl-clump-binary-tree
+ (package
+ (inherit sbcl-clump-2-3-tree)
+ (name "sbcl-clump-binary-tree")
+ (arguments
+ '(#:asd-file "Binary-tree/clump-binary-tree.asd"
+ #:asd-system-name "clump-binary-tree"))
+ (synopsis "Implementation of binary trees for Common Lisp")))
+
+(define-public sbcl-clump
+ (package
+ (inherit sbcl-clump-2-3-tree)
+ (name "sbcl-clump")
+ (arguments
+ '(#:asd-file "clump.asd"
+ #:asd-system-name "clump"))
+ (inputs
+ `(("clump-2-3-tree" ,sbcl-clump-2-3-tree)
+ ("clump-binary-tree" ,sbcl-clump-binary-tree)))
+ (synopsis "Collection of tree implementations for Common Lisp")))
+
+(define-public cl-clump
+ (sbcl-package->cl-source-package sbcl-clump))
+
+(define-public sbcl-cluffer-base
+ (let ((commit "4aad29c276a58a593064e79972ee4d77cae0af4a"))
+ (package
+ (name "sbcl-cluffer-base")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/robert-strandh/cluffer")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1bcg13g7qb3dr8z50aihdjqa6miz5ivlc9wsj2csgv1km1mak2kj"))))
+ (arguments
+ '(#:asd-file "Base/cluffer-base.asd"
+ #:asd-system-name "cluffer-base"))
+ (inputs
+ `(("acclimation" ,sbcl-acclimation)))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/robert-strandh/cluffer")
+ (synopsis "Common Lisp library providing a protocol for text-editor buffers")
+ (description "Cluffer is a library for representing the buffer of a text
+editor. As such, it defines a set of CLOS protocols for client code to
+interact with the buffer contents in various ways, and it supplies different
+implementations of those protocols for different purposes.")
+ (license license:bsd-2))))
+
+(define-public sbcl-cluffer-standard-line
+ (package
+ (inherit sbcl-cluffer-base)
+ (name "sbcl-cluffer-standard-line")
+ (arguments
+ '(#:asd-file "Standard-line/cluffer-standard-line.asd"
+ #:asd-system-name "cluffer-standard-line"))
+ (inputs
+ `(("cluffer-base" ,sbcl-cluffer-base)))))
+
+(define-public sbcl-cluffer-standard-buffer
+ (package
+ (inherit sbcl-cluffer-base)
+ (name "sbcl-cluffer-standard-buffer")
+ (arguments
+ '(#:asd-file "Standard-buffer/cluffer-standard-buffer.asd"
+ #:asd-system-name "cluffer-standard-buffer"))
+ (inputs
+ `(("cluffer-base" ,sbcl-cluffer-base)
+ ("clump" ,sbcl-clump)))))
+
+(define-public sbcl-cluffer-simple-line
+ (package
+ (inherit sbcl-cluffer-base)
+ (name "sbcl-cluffer-simple-line")
+ (arguments
+ '(#:asd-file "Simple-line/cluffer-simple-line.asd"
+ #:asd-system-name "cluffer-simple-line"))
+ (inputs
+ `(("cluffer-base" ,sbcl-cluffer-base)))))
+
+(define-public sbcl-cluffer-simple-buffer
+ (package
+ (inherit sbcl-cluffer-base)
+ (name "sbcl-cluffer-simple-buffer")
+ (arguments
+ '(#:asd-file "Simple-buffer/cluffer-simple-buffer.asd"
+ #:asd-system-name "cluffer-simple-buffer"))
+ (inputs
+ `(("cluffer-base" ,sbcl-cluffer-base)))))
+
+(define-public sbcl-cluffer
+ (package
+ (inherit sbcl-cluffer-base)
+ (name "sbcl-cluffer")
+ (arguments
+ '(#:asd-file "cluffer.asd"
+ #:asd-system-name "cluffer"))
+ (inputs
+ `(("cluffer-base" ,sbcl-cluffer-base)
+ ("cluffer-standard-line" ,sbcl-cluffer-standard-line)
+ ("cluffer-standard-buffer" ,sbcl-cluffer-standard-buffer)
+ ("cluffer-simple-line" ,sbcl-cluffer-simple-line)
+ ("cluffer-simple-buffer" ,sbcl-cluffer-simple-buffer)))))
+
+(define-public cl-cluffer
+ (sbcl-package->cl-source-package sbcl-cluffer))
+
+(define-public sbcl-cl-libsvm-format
+ (let ((commit "3300f84fd8d9f5beafc114f543f9d83417c742fb")
+ (revision "0"))
+ (package
+ (name "sbcl-cl-libsvm-format")
+ (version (git-version "0.1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/masatoi/cl-libsvm-format")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0284aj84xszhkhlivaigf9qj855fxad3mzmv3zfr0qzb5k0nzwrg"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("prove" ,sbcl-prove)
+ ("prove-asdf" ,sbcl-prove-asdf)))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)))
+ (synopsis "LibSVM data format reader for Common Lisp")
+ (description
+ "This Common Lisp library provides a fast reader for data in LibSVM
+format.")
+ (home-page "https://github.com/masatoi/cl-libsvm-format")
+ (license license:expat))))
+
+(define-public cl-libsvm-format
+ (sbcl-package->cl-source-package sbcl-cl-libsvm-format))
+
+(define-public ecl-cl-libsvm-format
+ (sbcl-package->ecl-package sbcl-cl-libsvm-format))
+
+(define-public sbcl-cl-online-learning
+ (let ((commit "fc7a34f4f161cd1c7dd747d2ed8f698947781423")
+ (revision "0"))
+ (package
+ (name "sbcl-cl-online-learning")
+ (version (git-version "0.5" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/masatoi/cl-online-learning")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "14x95rlg80ay5hv645ki57pqvy12v28hz4k1w0f6bsfi2rmpxchq"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("prove" ,sbcl-prove)
+ ("prove-asdf" ,sbcl-prove-asdf)))
+ (inputs
+ `(("cl-libsvm-format" ,sbcl-cl-libsvm-format)
+ ("cl-store" ,sbcl-cl-store)))
+ (arguments
+ `(;; FIXME: Tests pass but then the check phase crashes
+ #:tests? #f))
+ (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
+ (sbcl-package->cl-source-package sbcl-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")
+ (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)
+ ("prove-asdf" ,sbcl-prove-asdf)
+ ("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.")
+ (home-page "https://github.com/masatoi/cl-random-forest")
+ (license license:expat))))
+
+(define-public cl-random-forest
+ (sbcl-package->cl-source-package sbcl-cl-random-forest))
+
+(define-public ecl-cl-random-forest
+ (sbcl-package->ecl-package sbcl-cl-random-forest))
+
+(define-public sbcl-bordeaux-fft
+ (let ((commit "4a1f5600cae59bdabcb32de4ee2d7d73a9450d6e")
+ (revision "0"))
+ (package
+ (name "sbcl-bordeaux-fft")
+ (version (git-version "1.0.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/ahefner/bordeaux-fft")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0j584w6kq2k6r8lp2i14f9605rxhp3r15s33xs08iz1pndn6iwqf"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "http://vintage-digital.com/hefner/software/bordeaux-fft/")
+ (synopsis "Fast Fourier Transform for Common Lisp")
+ (description
+ "The Bordeaux-FFT library provides a reasonably efficient implementation
+of the Fast Fourier Transform and its inverse for complex-valued inputs, in
+portable Common Lisp.")
+ (license license:gpl2+))))
+
+(define-public cl-bordeaux-fft
+ (sbcl-package->cl-source-package sbcl-bordeaux-fft))
+
+(define-public ecl-bordeaux-fft
+ (sbcl-package->ecl-package sbcl-bordeaux-fft))
+
+(define-public sbcl-napa-fft3
+ (let ((commit "f2d9614c7167da327c9ceebefb04ff6eae2d2236")
+ (revision "0"))
+ (package
+ (name "sbcl-napa-fft3")
+ (version (git-version "0.0.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/pkhuong/Napa-FFT3")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1hxjf599xgwm28gbryy7q96j9ys6hfszmv0qxpr5698hxnhknscp"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/pkhuong/Napa-FFT3")
+ (synopsis "Fast Fourier Transform routines in Common Lisp")
+ (description
+ "Napa-FFT3 provides Discrete Fourier Transform (DFT) routines, but also
+buildings blocks to express common operations that involve DFTs: filtering,
+convolutions, etc.")
+ (license license:bsd-3))))
+
+(define-public cl-napa-fft3
+ (sbcl-package->cl-source-package sbcl-napa-fft3))
+
+(define-public sbcl-cl-tga
+ (let ((commit "4dc2f7b8a259b9360862306640a07a23d4afaacc")
+ (revision "0"))
+ (package
+ (name "sbcl-cl-tga")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fisxoj/cl-tga")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "03k3npmn0xd3fd2m7vwxph82av2xrfb150imqrinlzqmzvz1v1br"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/fisxoj/cl-tga")
+ (synopsis "TGA file loader for Common Lisp")
+ (description
+ "Cl-tga was written to facilitate loading @emph{.tga} files into OpenGL
+programs. It's a very simple library, and, at the moment, only supports
+non-RLE encoded forms of the files.")
+ (license license:expat))))
+
+(define-public cl-tga
+ (sbcl-package->cl-source-package sbcl-cl-tga))
+
+(define-public ecl-cl-tga
+ (sbcl-package->ecl-package sbcl-cl-tga))
+
+(define-public sbcl-com.gigamonkeys.binary-data
+ (let ((commit "22e908976d7f3e2318b7168909f911b4a00963ee")
+ (revision "0"))
+ (package
+ (name "sbcl-com.gigamonkeys.binary-data")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/gigamonkey/monkeylib-binary-data")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "072v417vmcnvmyh8ddq9vmwwrizm7zwz9dpzi14qy9nsw8q649zw"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)))
+ (home-page "https://github.com/gigamonkey/monkeylib-binary-data")
+ (synopsis "Common Lisp library for reading and writing binary data")
+ (description
+ "This a Common Lisp library for reading and writing binary data. It is
+based on code from chapter 24 of the book @emph{Practical Common Lisp}.")
+ (license license:bsd-3))))
+
+(define-public cl-com.gigamonkeys.binary-data
+ (sbcl-package->cl-source-package sbcl-com.gigamonkeys.binary-data))
+
+(define-public ecl-com.gigamonkeys.binary-data
+ (sbcl-package->ecl-package sbcl-com.gigamonkeys.binary-data))
+
+(define-public sbcl-deflate
+ (package
+ (name "sbcl-deflate")
+ (version "1.0.3")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/pmai/Deflate")
+ (commit (string-append "release-" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1jpdjnxh6cw2d8hk70r2sxn92is52s9b855irvwkdd777fdciids"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/pmai/Deflate")
+ (synopsis "Native deflate decompression for Common Lisp")
+ (description
+ "This library is an implementation of Deflate (RFC 1951) decompression,
+with optional support for ZLIB-style (RFC 1950) and gzip-style (RFC 1952)
+wrappers of deflate streams. It currently does not handle compression.")
+ (license license:expat)))
+
+(define-public cl-deflate
+ (sbcl-package->cl-source-package sbcl-deflate))
+
+(define-public ecl-deflate
+ (sbcl-package->ecl-package sbcl-deflate))
+
+(define-public sbcl-skippy
+ (let ((commit "e456210202ca702c792292c5060a264d45e47090")
+ (revision "0"))
+ (package
+ (name "sbcl-skippy")
+ (version (git-version "1.3.12" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/xach/skippy")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1sxbn5nh24qpx9w64x8mhp259cxcl1x8p126wk3b91ijjsj7l5vj"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://xach.com/lisp/skippy/")
+ (synopsis "Common Lisp library for GIF images")
+ (description
+ "Skippy is a Common Lisp library to read and write GIF image files.")
+ (license license:bsd-2))))
+
+(define-public cl-skippy
+ (sbcl-package->cl-source-package sbcl-skippy))
+
+(define-public ecl-skippy
+ (sbcl-package->ecl-package sbcl-skippy))
+
+(define-public sbcl-cl-freetype2
+ (let ((commit "96058da730b4812df916c1f4ee18c99b3b15a3de")
+ (revision "0"))
+ (package
+ (name "sbcl-cl-freetype2")
+ (version (git-version "1.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/rpav/cl-freetype2")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0f8darhairgxnb5bzqcny7nh7ss3471bdzix5rzcyiwdbr5kymjl"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cffi" ,sbcl-cffi)
+ ("cffi-grovel" ,sbcl-cffi-grovel)
+ ("freetype" ,freetype)
+ ("trivial-garbage" ,sbcl-trivial-garbage)))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/ffi/ft2-lib.lisp"
+ (("\"libfreetype\"")
+ (string-append "\"" (assoc-ref inputs "freetype")
+ "/lib/libfreetype\"")))
+ (substitute* "src/ffi/grovel/grovel-freetype2.lisp"
+ (("-I/usr/include/freetype")
+ (string-append "-I" (assoc-ref inputs "freetype")
+ "/include/freetype")))
+ #t)))))
+ (home-page "https://github.com/rpav/cl-freetype2")
+ (synopsis "Common Lisp bindings for Freetype 2")
+ (description
+ "This is a general Freetype 2 wrapper for Common Lisp using CFFI. It's
+geared toward both using Freetype directly by providing a simplified API, as
+well as providing access to the underlying C structures and functions for use
+with other libraries which may also use Freetype.")
+ (license license:bsd-3))))
+
+(define-public cl-freetype2
+ (sbcl-package->cl-source-package sbcl-cl-freetype2))
+
+(define-public ecl-cl-freetype2
+ (sbcl-package->ecl-package sbcl-cl-freetype2))
+
+(define-public sbcl-opticl-core
+ (let ((commit "b7cd13d26df6b824b216fbc360dc27bfadf04999")
+ (revision "0"))
+ (package
+ (name "sbcl-opticl-core")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/slyrus/opticl-core")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0458bllabcdjghfrqx6aki49c9qmvfmkk8jl75cfpi7q0i12kh95"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)))
+ (home-page "https://github.com/slyrus/opticl-core")
+ (synopsis "Core classes and pixel access macros for Opticl")
+ (description
+ "This Common Lisp library contains the core classes and pixel access
+macros for the Opticl image processing library.")
+ (license license:bsd-2))))
+
+(define-public cl-opticl-core
+ (sbcl-package->cl-source-package sbcl-opticl-core))
+
+(define-public ecl-opticl-core
+ (sbcl-package->ecl-package sbcl-opticl-core))
+
+(define-public sbcl-retrospectiff
+ (let ((commit "c2a69d77d5010f8cdd9045b3e36a08a73da5d321")
+ (revision "0"))
+ (package
+ (name "sbcl-retrospectiff")
+ (version (git-version "0.2" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/slyrus/retrospectiff")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0qsn9hpd8j2kp43dk05j8dczz9zppdff5rrclbp45n3ksk9inw8i"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (inputs
+ `(("cl-jpeg" ,sbcl-cl-jpeg)
+ ("com.gigamonkeys.binary-data" ,sbcl-com.gigamonkeys.binary-data)
+ ("deflate" ,sbcl-deflate)
+ ("flexi-streams" ,sbcl-flexi-streams)
+ ("ieee-floats" ,sbcl-ieee-floats)
+ ("opticl-core" ,sbcl-opticl-core)))
+ (home-page "https://github.com/slyrus/retrospectiff")
+ (synopsis "Common Lisp library for TIFF images")
+ (description
+ "Retrospectiff is a common lisp library for reading and writing images
+in the TIFF (Tagged Image File Format) format.")
+ (license license:bsd-2))))
+
+(define-public cl-retrospectif
+ (sbcl-package->cl-source-package sbcl-retrospectiff))
+
+(define-public ecl-retrospectiff
+ (sbcl-package->ecl-package sbcl-retrospectiff))
+
+(define-public sbcl-mmap
+ (let ((commit "ba2e98c67e25f0fb8ff838238561120a23903ce7")
+ (revision "0"))
+ (package
+ (name "sbcl-mmap")
+ (version (git-version "1.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Shinmera/mmap")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0qd0xp20i1pcfn12kkapv9pirb6hd4ns7kz4zf1mmjwykpsln96q"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cffi" ,sbcl-cffi)
+ ("parachute" ,sbcl-parachute)
+ ("trivial-features" ,sbcl-trivial-features)))
+ (inputs
+ `(("cffi" ,sbcl-cffi)
+ ("documentation-utils" ,sbcl-documentation-utils)))
+ (home-page "https://shinmera.github.io/mmap/")
+ (synopsis "File memory mapping for Common Lisp")
+ (description
+ "This is a utility library providing access to the @emph{mmap} family of
+functions in a portable way. It allows you to directly map a file into the
+address space of your process without having to manually read it into memory
+sequentially. Typically this is much more efficient for files that are larger
+than a few Kb.")
+ (license license:zlib))))
+
+(define-public cl-mmap
+ (sbcl-package->cl-source-package sbcl-mmap))
+
+(define-public ecl-mmap
+ (sbcl-package->ecl-package sbcl-mmap))
+
+(define-public sbcl-3bz
+ (let ((commit "d6119083b5e0b0a6dd3abc2877936c51f3f3deed")
+ (revision "0"))
+ (package
+ (name "sbcl-3bz")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/3b/3bz")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0fyxzyf2b6sc0w8d9g4nlva861565z6f3xszj0lw29x526dd9rhj"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("babel" ,sbcl-babel)
+ ("cffi" ,sbcl-cffi)
+ ("mmap" ,sbcl-mmap)
+ ("nibbles" ,sbcl-nibbles)
+ ("trivial-features" ,sbcl-trivial-features)))
+ (arguments
+ ;; FIXME: Without the following line, the build fails (see issue 41437).
+ `(#:asd-system-name "3bz"))
+ (home-page "https://github.com/3b/3bz")
+ (synopsis "Deflate decompression for Common Lisp")
+ (description
+ "3bz is an implementation of Deflate decompression (RFC 1951) optionally
+with zlib (RFC 1950) or gzip (RFC 1952) wrappers, with support for reading from
+foreign pointers (for use with mmap and similar, etc), and from CL octet
+vectors and streams.")
+ (license license:expat))))
+
+(define-public cl-3bz
+ (sbcl-package->cl-source-package sbcl-3bz))
+
+(define-public ecl-3bz
+ (sbcl-package->ecl-package sbcl-3bz))
+
+(define-public sbcl-zpb-exif
+ (package
+ (name "sbcl-zpb-exif")
+ (version "1.2.4")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/xach/zpb-exif")
+ (commit (string-append "release-" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "15s227jhby55cisz14xafb0p1ws2jmrg2rrbbd00lrb97im84hy6"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://xach.com/lisp/zpb-exif/")
+ (synopsis "EXIF information extractor for Common Lisp")
+ (description
+ "This is a Common Lisp library to extract EXIF information from image
+files.")
+ (license license:bsd-2)))
+
+(define-public cl-zpb-exif
+ (sbcl-package->cl-source-package sbcl-zpb-exif))
+
+(define-public ecl-zpb-exif
+ (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,
+both from files on disk, or streams in memory.")
+ (license license:expat)))
+
+(define-public cl-pngload
+ (sbcl-package->cl-source-package sbcl-pngload))
+
+(define-public ecl-pngload
+ (sbcl-package->ecl-package sbcl-pngload))
+
+(define-public sbcl-opticl
+ (let ((commit "e8684416eca2e78e82a7b436d436ef2ea24c019d")
+ (revision "0"))
+ (package
+ (name "sbcl-opticl")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/slyrus/opticl")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "03rirnnhhisjbimlmpi725h1d3x0cfv00r57988am873dyzawmm1"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-jpeg" ,sbcl-cl-jpeg)
+ ("cl-tga" ,sbcl-cl-tga)
+ ("png-read" ,sbcl-png-read)
+ ("pngload" ,sbcl-pngload)
+ ("retrospectiff" ,sbcl-retrospectiff)
+ ("skippy" ,sbcl-skippy)
+ ("zpng" ,sbcl-zpng)))
+ (home-page "https://github.com/slyrus/opticl")
+ (synopsis "Image processing library for Common Lisp")
+ (description
+ "Opticl is a Common Lisp library for representing, processing, loading,
+and saving 2-dimensional pixel-based images.")
+ (license license:bsd-2))))
+
+(define-public cl-opticl
+ (sbcl-package->cl-source-package sbcl-opticl))
+
+(define-public sbcl-clim-lisp
+ (let ((commit "27b4d7a667c9b3faa74cabcb57706b888314fff7")
+ (revision "0"))
+ (package
+ (name "sbcl-clim-lisp")
+ (version (git-version "0.9.7" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/mcclim/mcclim")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0jijfgkwas6xnpp5wiii6slcx9pgsalngacb8zm29x6pamx2193h"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("closer-mop" ,sbcl-closer-mop)
+ ("log4cl" ,sbcl-log4cl)
+ ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
+ (home-page "https://common-lisp.net/project/mcclim/")
+ (synopsis "Common Lisp GUI toolkit")
+ (description
+ "McCLIM is an implementation of the @emph{Common Lisp Interface Manager
+specification}, a toolkit for writing GUIs in Common Lisp.")
+ (license license:lgpl2.1+))))
+
+(define-public sbcl-clim-basic
+ (package
+ (inherit sbcl-clim-lisp)
+ (name "sbcl-clim-basic")
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("babel" ,sbcl-babel)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("clim-lisp" ,sbcl-clim-lisp)
+ ("flexichain" ,sbcl-flexichain)
+ ("spatial-trees" ,sbcl-spatial-trees)
+ ("trivial-features" ,sbcl-trivial-features)
+ ("trivial-garbage" ,sbcl-trivial-garbage)))
+ (arguments
+ '(#:asd-file "Core/clim-basic/clim-basic.asd"))))
+
+(define-public sbcl-clim-core
+ (package
+ (inherit sbcl-clim-lisp)
+ (name "sbcl-clim-core")
+ (inputs
+ `(("clim-basic" ,sbcl-clim-basic)))
+ (arguments
+ '(#:asd-file "Core/clim-core/clim-core.asd"))))
+
+(define-public sbcl-esa-mcclim
+ (package
+ (inherit sbcl-clim-lisp)
+ (name "sbcl-esa-mcclim")
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("clim-core" ,sbcl-clim-core)))
+ (arguments
+ '(#:asd-file "Libraries/ESA/esa-mcclim.asd"))))
+
+(define-public sbcl-mcclim-fonts
+ (package
+ (inherit sbcl-clim-lisp)
+ (name "sbcl-mcclim-fonts")
+ (inputs
+ `(("clim-basic" ,sbcl-clim-basic)))
+ (arguments
+ '(#:asd-file "Extensions/fonts/mcclim-fonts.asd"))))
+
+(define-public sbcl-automaton
+ (package
+ (inherit sbcl-clim-lisp)
+ (name "sbcl-automaton")
+ (inputs
+ `())
+ (arguments
+ '(#:asd-file "Libraries/Drei/cl-automaton/automaton.asd"))))
+
+(define-public sbcl-persistent
+ (package
+ (inherit sbcl-clim-lisp)
+ (name "sbcl-persistent")
+ (inputs
+ `())
+ (arguments
+ '(#:asd-file "Libraries/Drei/Persistent/persistent.asd"))))
+
+(define-public sbcl-drei-mcclim
+ (package
+ (inherit sbcl-clim-lisp)
+ (name "sbcl-drei-mcclim")
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (inputs
+ `(("automaton" ,sbcl-automaton)
+ ("clim-core" ,sbcl-clim-core)
+ ("esa-mcclim" ,sbcl-esa-mcclim)
+ ("flexichain" ,sbcl-flexichain)
+ ("mcclim-fonts" ,sbcl-mcclim-fonts)
+ ("persistent" ,sbcl-persistent)
+ ("swank" ,cl-slime-swank)))
+ (arguments
+ '(#:asd-file "Libraries/Drei/drei-mcclim.asd"))))
+
+(define-public sbcl-clim
+ (package
+ (inherit sbcl-clim-lisp)
+ (name "sbcl-clim")
+ (inputs
+ `(("clim-core" ,sbcl-clim-core)
+ ("drei-mcclim" ,sbcl-drei-mcclim)
+ ("swank" ,cl-slime-swank))) ; For drei-mcclim
+ (arguments
+ '(#:asd-file "Core/clim/clim.asd"))))
+
+(define-public sbcl-mcclim-backend-common
+ (package
+ (inherit sbcl-clim-lisp)
+ (name "sbcl-mcclim-backend-common")
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (inputs
+ `(("clim" ,sbcl-clim)
+ ("swank" ,cl-slime-swank))) ; For drei-mcclim
+ (arguments
+ '(#:asd-file "Backends/common/mcclim-backend-common.asd"))))
+
+(define-public sbcl-mcclim-clx
+ (package
+ (inherit sbcl-clim-lisp)
+ (name "sbcl-mcclim-clx")
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-unicode" ,sbcl-cl-unicode)
+ ("clx" ,sbcl-clx)
+ ("mcclim-backend-common" ,sbcl-mcclim-backend-common)
+ ("mcclim-fonts" ,sbcl-mcclim-fonts)
+ ("swank" ,cl-slime-swank))) ; For drei-mcclim
+ (arguments
+ '(#:asd-file "Backends/CLX/mcclim-clx.asd"))))
+
+(define-public sbcl-mcclim-fonts-truetype
+ (package
+ (inherit sbcl-clim-lisp)
+ (name "sbcl-mcclim-fonts-truetype")
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-aa" ,sbcl-cl-aa)
+ ("cl-paths-ttf" ,sbcl-cl-paths-ttf)
+ ("cl-vectors" ,sbcl-cl-vectors)
+ ("clim-basic" ,sbcl-clim-basic)
+ ("zpb-ttf" ,sbcl-zpb-ttf)))
+ (arguments
+ '(#:asd-file "./Extensions/fonts/mcclim-fonts.asd"
+ #:asd-system-name "mcclim-fonts/truetype"
+ ;; Tests want access to user's fonts, which are not available in
+ ;; build container.
+ #:tests? #f))))
+
+(define-public sbcl-mcclim-fonts-clx-truetype
+ (package
+ (inherit sbcl-clim-lisp)
+ (name "sbcl-mcclim-fonts-clx-truetype")
+ (inputs
+ `(("mcclim-clx" ,sbcl-mcclim-clx)
+ ("mcclim-fonts-truetype" ,sbcl-mcclim-fonts-truetype)
+ ("swank" ,cl-slime-swank))) ; For drei-mcclim
+ (arguments
+ '(#:asd-file "./Extensions/fonts/mcclim-fonts.asd"
+ #:asd-system-name "mcclim-fonts/clx-truetype"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-asd-system-names
+ (lambda _
+ (substitute* "Extensions/fonts/mcclim-fonts.asd"
+ ((":depends-on \\(#:mcclim-fonts/truetype")
+ ":depends-on (#:mcclim-fonts-truetype"))
+ #t)))))))
+
+(define-public sbcl-mcclim-clx-truetype
+ (package
+ (inherit sbcl-clim-lisp)
+ (name "sbcl-mcclim-clx-truetype")
+ (inputs
+ `(("mcclim-clx" ,sbcl-mcclim-clx)
+ ("mcclim-fonts-clx-truetype" ,sbcl-mcclim-fonts-clx-truetype)
+ ("swank" ,cl-slime-swank))) ; For drei-mcclim
+ (arguments
+ '(#:asd-file "Backends/CLX/mcclim-clx.asd"
+ #:asd-system-name "mcclim-clx/truetype"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-asd-system-names
+ (lambda _
+ (substitute* "Backends/CLX/mcclim-clx.asd"
+ (("mcclim-fonts/clx-truetype")
+ "mcclim-fonts-clx-truetype"))
+ #t)))))))
+
+(define-public sbcl-mcclim-fontconfig
+ (package
+ (inherit sbcl-clim-lisp)
+ (name "sbcl-mcclim-fontconfig")
+ (native-inputs
+ `(("pkg-config" ,pkg-config)))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cffi" ,sbcl-cffi)
+ ("cffi-grovel" ,sbcl-cffi-grovel)
+ ("fontconfig" ,fontconfig)))
+ (arguments
+ '(#:asd-file "Extensions/fontconfig/mcclim-fontconfig.asd"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "Extensions/fontconfig/src/functions.lisp"
+ (("libfontconfig\\.so")
+ (string-append (assoc-ref inputs "fontconfig")
+ "/lib/libfontconfig.so")))
+ #t))
+ (add-after 'unpack 'fix-build
+ (lambda _
+ ;; The cffi-grovel system does not get loaded automatically,
+ ;; so we load it explicitly.
+ (substitute* "Extensions/fontconfig/mcclim-fontconfig.asd"
+ (("\\(asdf:defsystem #:mcclim-fontconfig" all)
+ (string-append "(asdf:load-system :cffi-grovel)\n" all)))
+ #t)))))))
+
+(define-public sbcl-mcclim-harfbuzz
+ (package
+ (inherit sbcl-clim-lisp)
+ (name "sbcl-mcclim-harfbuzz")
+ (native-inputs
+ `(("pkg-config" ,pkg-config)))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cffi" ,sbcl-cffi)
+ ("cffi-grovel" ,sbcl-cffi-grovel)
+ ("freetype" ,freetype)
+ ("harfbuzz" ,harfbuzz)
+ ("trivial-garbage" ,sbcl-trivial-garbage)))
+ (arguments
+ '(#:asd-file "Extensions/harfbuzz/mcclim-harfbuzz.asd"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "Extensions/harfbuzz/src/functions.lisp"
+ (("libharfbuzz\\.so")
+ (string-append (assoc-ref inputs "harfbuzz")
+ "/lib/libharfbuzz.so")))
+ #t))
+ (add-after 'unpack 'fix-build
+ (lambda _
+ ;; The cffi-grovel system does not get loaded automatically,
+ ;; so we load it explicitly.
+ (substitute* "Extensions/harfbuzz/mcclim-harfbuzz.asd"
+ (("\\(asdf:defsystem #:mcclim-harfbuzz" all)
+ (string-append "(asdf:load-system :cffi-grovel)\n" all)))
+ #t)))))))
+
+(define-public sbcl-mcclim-fonts-clx-freetype
+ (package
+ (inherit sbcl-clim-lisp)
+ (name "sbcl-mcclim-fonts-clx-freetype")
+ (inputs
+ `(("cl-freetype2" ,sbcl-cl-freetype2)
+ ("mcclim-clx" ,sbcl-mcclim-clx)
+ ("mcclim-fontconfig" ,sbcl-mcclim-fontconfig)
+ ("mcclim-fonts" ,sbcl-mcclim-fonts)
+ ("mcclim-harfbuzz" ,sbcl-mcclim-harfbuzz)
+ ("swank" ,cl-slime-swank))) ; For drei-mcclim
+ (arguments
+ '(#:asd-file "Extensions/fonts/mcclim-fonts.asd"
+ #:asd-system-name "mcclim-fonts/clx-freetype"))))
+
+(define-public sbcl-mcclim-clx-freetype
+ (package
+ (inherit sbcl-clim-lisp)
+ (name "sbcl-mcclim-clx-freetype")
+ (inputs
+ `(("mcclim-clx" ,sbcl-mcclim-clx)
+ ("mcclim-fonts-clx-freetype" ,sbcl-mcclim-fonts-clx-freetype)
+ ("swank" ,cl-slime-swank))) ; For drei-mcclim
+ (arguments
+ '(#:asd-file "Backends/CLX/mcclim-clx.asd"
+ #:asd-system-name "mcclim-clx/freetype"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-asd-system-names
+ (lambda _
+ (substitute* "Backends/CLX/mcclim-clx.asd"
+ (("mcclim-fonts/clx-freetype")
+ "mcclim-fonts-clx-freetype"))
+ #t)))))))
+
+(define-public sbcl-mcclim-render
+ (package
+ (inherit sbcl-clim-lisp)
+ (name "sbcl-mcclim-render")
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-vectors" ,sbcl-cl-vectors)
+ ("clim-basic" ,sbcl-clim-basic)
+ ("mcclim-backend-common" ,sbcl-mcclim-backend-common)
+ ("mcclim-fonts-truetype" ,sbcl-mcclim-fonts-truetype)
+ ("swank" ,cl-slime-swank))) ; For drei-mcclim
+ (arguments
+ '(#:asd-file "Extensions/render/mcclim-render.asd"
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-asd-system-names
+ (lambda _
+ (substitute* "Extensions/render/mcclim-render.asd"
+ (("mcclim-fonts/truetype")
+ "mcclim-fonts-truetype"))
+ #t)))))))
+
+(define-public sbcl-mcclim-clx-fb
+ (package
+ (inherit sbcl-clim-lisp)
+ (name "sbcl-mcclim-clx-fb")
+ (inputs
+ `(("mcclim-backend-common" ,sbcl-mcclim-backend-common)
+ ("mcclim-clx" ,sbcl-mcclim-clx)
+ ("mcclim-render" ,sbcl-mcclim-render)
+ ("swank" ,cl-slime-swank))) ; For drei-mcclim
+ (arguments
+ '(#:asd-file "Backends/CLX-fb/mcclim-clx-fb.asd"))))
+
+(define-public sbcl-mcclim-null
+ (package
+ (inherit sbcl-clim-lisp)
+ (name "sbcl-mcclim-null")
+ (inputs
+ `(("clim" ,sbcl-clim)
+ ("swank" ,cl-slime-swank))) ; For drei-mcclim
+ (arguments
+ '(#:asd-file "Backends/Null/mcclim-null.asd"))))
HCoop / jackhill / guix / guix.git / blobdiff