;;; 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 Nils Gillmann <ng0@n0.is>
+;;; Copyright © 2016, 2017 ng0 <ng0@n0.is>
;;; Copyright © 2016, 2017 Andy Patterson <ajpatter@uwaterloo.ca>
-;;; Copyright © 2017 Ricardo Wurmus <rekado@elephly.net>
+;;; Copyright © 2017, 2019 Ricardo Wurmus <rekado@elephly.net>
;;; Copyright © 2017, 2018 Efraim Flashner <efraim@flashner.co.il>
-;;; Copyright © 2017 Tobias Geerinckx-Rice <me@tobias.gr>
+;;; Copyright © 2017, 2019 Tobias Geerinckx-Rice <me@tobias.gr>
;;; Copyright © 2018 Benjamin Slade <slade@jnanam.net>
;;; Copyright © 2018 Alex Vong <alexvong1995@gmail.com>
+;;; Copyright © 2018 Pierre Neidhardt <mail@ambrevar.xyz>
+;;; Copyright © 2018 Pierre Langlois <pierre.langlois@gmx.com>
;;;
;;; This file is part of GNU Guix.
;;;
#:use-module (gnu packages pkg-config)
#:use-module (gnu packages readline)
#:use-module (gnu packages sdl)
+ #:use-module (gnu packages sqlite)
#:use-module (gnu packages tex)
#:use-module (gnu packages texinfo)
#:use-module (gnu packages version-control)
#:use-module (gnu packages databases)
#:use-module (gnu packages gtk)
#:use-module (gnu packages webkit)
+ #:use-module (gnu packages xdisorg)
#:use-module (ice-9 match)
- #:use-module (srfi srfi-1)
#:use-module (srfi srfi-19))
(define (asdf-substitutions lisp)
,lisp))))
(define-public gcl
- (let ((commit "5956140b1083e2302a59d7ce2054b0b7c2cbb417")
- (revision "1")) ;Guix package revision
+ (let ((commit "d3335e2b3deb63f930eb0328e9b05377744c9512")
+ (revision "2")) ;Guix package revision
(package
(name "gcl")
(version (string-append "2.6.12-" revision "."
(commit commit)))
(file-name (string-append "gcl-" version "-checkout"))
(sha256
- (base32 "0mwclf2879mh3d9xqkqhghf58lwy7srsnsq9x0f1cc6j302sy4hb"))))
+ (base32 "05v86lhvsby05nzvcd3c4k0wljvgdgd0i6arzd2fx1yd67dl6fgj"))))
(build-system gnu-build-system)
(arguments
`(#:parallel-build? #f ; The build system seems not to be thread safe.
`(("gmp" ,gmp)
("readline" ,readline)))
(native-inputs
- `(("gcc" ,gcc-4.9)
- ("m4" ,m4)
- ("texinfo" ,texinfo)
- ("texlive" ,texlive)))
+ `(("m4" ,m4)
+ ("texinfo" ,texinfo)))
(home-page "https://www.gnu.org/software/gcl/")
(synopsis "A Common Lisp implementation")
(description "GCL is an implementation of the Common Lisp language. It
(define-public sbcl
(package
(name "sbcl")
- (version "1.4.4")
+ (version "1.4.16")
(source
(origin
(method url-fetch)
(uri (string-append "mirror://sourceforge/sbcl/sbcl/" version "/sbcl-"
version "-source.tar.bz2"))
(sha256
- (base32 "1k6v5b8qv7vyxvh8asx6phf2hbapx5pp5p5j47hgnq123fwnh4fa"))
+ (base32 "1myg4wkxnbfn5nz38xy62r1jhjy07x3h0b04vg858n41chdsv4wd"))
(modules '((guix build utils)))
(snippet
;; Add sbcl-bundle-systems to 'default-system-source-registry'.
#t))))
(build-system gnu-build-system)
(outputs '("out" "doc"))
- ;; Bootstrap with CLISP.
(native-inputs
- `(("clisp" ,clisp)
+ ;; From INSTALL:
+ ;; Supported build hosts are:
+ ;; SBCL
+ ;; CMUCL
+ ;; CCL (formerly known as OpenMCL)
+ ;; ABCL (recent versions only)
+ ;; CLISP (only some versions: 2.44.1 is OK, 2.47 is not)
+ ;; XCL
+ ;; CCL seems ideal then, but it unfortunately only builds reliably
+ ;; on some architectures.
+ `(,@(match (%current-system)
+ ((or "x86_64-linux" "i686-linux")
+ `(("ccl" ,ccl)))
+ (_
+ `(("clisp" ,clisp))))
("which" ,which)
("inetutils" ,inetutils) ;for hostname(1)
("ed" ,ed)
- ("texlive" ,texlive)
+ ("texlive" ,(texlive-union (list texlive-tex-texinfo)))
("texinfo" ,texinfo)))
(arguments
- '(#:modules ((guix build gnu-build-system)
+ `(#:modules ((guix build gnu-build-system)
(guix build utils)
(srfi srfi-1))
#:phases
(string-append "#+nil ;disabled by Guix\n" all))
(("\\(deftest grent\\.[12]" all)
(string-append "#+nil ;disabled by Guix\n" all))))))
+ ;; FIXME: the texlive-union insists on regenerating fonts. It stores
+ ;; them in HOME, so it needs to be writeable.
+ (add-before 'build 'set-HOME
+ (lambda _ (setenv "HOME" "/tmp") #t))
(replace 'build
(lambda* (#:key outputs #:allow-other-keys)
(setenv "CC" "gcc")
- (zero? (system* "sh" "make.sh" "clisp"
- (string-append "--prefix="
- (assoc-ref outputs "out"))))))
+ (invoke "sh" "make.sh" ,@(match (%current-system)
+ ((or "x86_64-linux" "i686-linux")
+ `("ccl"))
+ (_
+ `("clisp")))
+ (string-append "--prefix="
+ (assoc-ref outputs "out")))))
(replace 'install
(lambda _
- (zero? (system* "sh" "install.sh"))))
+ (invoke "sh" "install.sh")))
(add-after 'build 'build-doc
(lambda _
(with-directory-excursion "doc/manual"
- (and (zero? (system* "make" "info"))
- (zero? (system* "make" "dist"))))))
+ (and (invoke "make" "info")
+ (invoke "make" "dist")))))
(add-after 'install 'install-doc
(lambda* (#:key outputs #:allow-other-keys)
(let* ((out (assoc-ref outputs "out"))
(modify-phases %standard-phases
(replace 'unpack
(lambda* (#:key inputs #:allow-other-keys)
- (and (zero? (system* "tar" "xzvf" (assoc-ref inputs "ccl")))
- (begin (chdir "ccl") #t))))
+ (invoke "tar" "xzvf" (assoc-ref inputs "ccl"))
+ (chdir "ccl")
+ #t))
(delete 'configure)
(add-before 'build 'pre-build
;; Enter the source directory for the current platform's lisp
(substitute* '("Makefile")
(("/bin/rm") "rm"))
(setenv "CC" "gcc")
- (zero? (system* "make" "clean"))))
+ (invoke "make" "clean")))
;; XXX Do we need to recompile the heap image as well for Guix?
;; For now just use the one we already got in the tarball.
(replace 'install
(install-file heap libdir)
(let ((dirs '("lib" "library" "examples" "tools" "objc-bridge"
- ,(match (%current-system)
+ ,@(match (%current-system)
("x86_64-linux"
- "x86-headers64")
+ '("x86-headers64"))
("i686-linux"
- "x86-headers")))))
+ '("x86-headers"))
+ (_ '())))))
(for-each copy-recursively
dirs
(map (cut string-append libdir <>) dirs)))
(display
(string-append
"#!" bash "/bin/sh\n"
- "CCL_DEFAULT_DIRECTORY=" libdir "\n"
- "export CCL_DEFAULT_DIRECTORY\n"
- "exec " libdir kernel "\n"))))
+ "export CCL_DEFAULT_DIRECTORY=" libdir "\n"
+ "exec -a \"$0\" " libdir kernel " \"$@\"\n"))))
(chmod wrapper #o755))
#t)))))
(supported-systems '("i686-linux" "x86_64-linux" "armhf-linux"))
- (home-page "http://ccl.clozure.com/")
+ (home-page "https://ccl.clozure.com/")
(synopsis "Common Lisp implementation")
(description "Clozure CL (often called CCL for short) is a Common Lisp
implementation featuring fast compilation speed, native threads, a precise,
(license (list license:lgpl2.1
license:clarified-artistic)))) ;TRIVIAL-LDAP package
-(define-public clojure
- (let* ((lib (lambda (prefix version hash)
- (origin (method url-fetch)
- (uri (string-append "https://github.com/clojure/"
- prefix version ".tar.gz"))
- (sha256 (base32 hash)))))
- ;; The libraries below are needed to run the tests.
- (libraries
- `(("core-specs-alpha-src"
- ,(lib "core.specs.alpha/archive/core.specs.alpha-"
- "0.1.24"
- "0v2a0svf1ar2y42ajxwsjr7zmm5j7pp2zwrd2jh3k7xzd1p9x1fv"))
- ("data-generators-src"
- ,(lib "data.generators/archive/data.generators-"
- "0.1.2"
- "0kki093jp4ckwxzfnw8ylflrfqs8b1i1wi9iapmwcsy328dmgzp1"))
- ("spec-alpha-src"
- ,(lib "spec.alpha/archive/spec.alpha-"
- "0.1.143"
- "00alf0347licdn773w2jarpllyrbl52qz4d8mw61anjksacxylzz"))
- ("test-check-src"
- ,(lib "test.check/archive/test.check-"
- "0.9.0"
- "0p0mnyhr442bzkz0s4k5ra3i6l5lc7kp6ajaqkkyh4c2k5yck1md"))
- ("test-generative-src"
- ,(lib "test.generative/archive/test.generative-"
- "0.5.2"
- "1pjafy1i7yblc7ixmcpfq1lfbyf3jaljvkgrajn70sws9xs7a9f8"))
- ("tools-namespace-src"
- ,(lib "tools.namespace/archive/tools.namespace-"
- "0.2.11"
- "10baak8v0hnwz2hr33bavshm7y49mmn9zsyyms1dwjz45p5ymhy0"))))
- (library-names (match libraries
- (((library-name _) ...)
- library-name))))
- (package
- (name "clojure")
- (version "1.9.0")
- (source
- (origin
- (method url-fetch)
- (uri
- (string-append "https://github.com/clojure/clojure/archive/clojure-"
- version ".tar.gz"))
- (sha256
- (base32 "0xjbzcw45z32vsn9pifp7ndysjzqswp5ig0jkjpivigh2ckkdzha"))))
- (build-system ant-build-system)
- (arguments
- `(#:modules ((guix build ant-build-system)
- (guix build utils)
- (ice-9 ftw)
- (ice-9 regex)
- (srfi srfi-1)
- (srfi srfi-26))
- #:test-target "test"
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'unpack-library-sources
- (lambda* (#:key inputs #:allow-other-keys)
- (define (extract-library name)
- (mkdir-p name)
- (with-directory-excursion name
- (invoke "tar"
- "--extract"
- "--verbose"
- "--file" (assoc-ref inputs name)
- "--strip-components=1"))
- (copy-recursively (string-append name "/src/main/clojure/")
- "src/clj/"))
- (for-each extract-library ',library-names)
- #t))
- (add-after 'unpack-library-sources 'fix-manifest-classpath
- (lambda _
- (substitute* "build.xml"
- (("<attribute name=\"Class-Path\" value=\".\"/>") ""))
- #t))
- ;; The javadoc target is not built by default.
- (add-after 'build 'build-doc
- (lambda _
- (invoke "ant" "javadoc")))
- ;; Needed since no install target is provided.
- (replace 'install
- (lambda* (#:key outputs #:allow-other-keys)
- (let ((java-dir (string-append (assoc-ref outputs "out")
- "/share/java/")))
- ;; Install versioned to avoid collisions.
- (install-file (string-append "clojure-" ,version ".jar")
- java-dir)
- #t)))
- ;; Needed since no install-doc target is provided.
- (add-after 'install 'install-doc
- (lambda* (#:key outputs #:allow-other-keys)
- (let ((doc-dir (string-append (assoc-ref outputs "out")
- "/share/doc/clojure-"
- ,version "/")))
- (copy-recursively "doc/clojure" doc-dir)
- (copy-recursively "target/javadoc/"
- (string-append doc-dir "javadoc/"))
- (for-each (cut install-file <> doc-dir)
- (filter (cut string-match
- ".*\\.(html|markdown|md|txt)"
- <>)
- (scandir "./")))
- #t))))))
- (native-inputs libraries)
- (home-page "https://clojure.org/")
- (synopsis "Lisp dialect running on the JVM")
- (description "Clojure is a dynamic, general-purpose programming language,
-combining the approachability and interactive development of a scripting
-language with an efficient and robust infrastructure for multithreaded
-programming. Clojure is a compiled language, yet remains completely dynamic
-– every feature supported by Clojure is supported at runtime. Clojure
-provides easy access to the Java frameworks, with optional type hints and type
-inference, to ensure that calls to Java can avoid reflection.
-
-Clojure is a dialect of Lisp, and shares with Lisp the code-as-data philosophy
-and a powerful macro system. Clojure is predominantly a functional programming
-language, and features a rich set of immutable, persistent data structures.
-When mutable state is needed, Clojure offers a software transactional memory
-system and reactive Agent system that ensure clean, correct, multithreaded
-designs.")
- ;; Clojure is licensed under EPL1.0
- ;; ASM bytecode manipulation library is licensed under BSD-3
- ;; Guava Murmur3 hash implementation is licensed under APL2.0
- ;; src/clj/repl.clj is licensed under CPL1.0
-
- ;; See readme.html or readme.txt for details.
- (license (list license:epl1.0
- license:bsd-3
- license:asl2.0
- license:cpl1.0)))))
-
-(define-public femtolisp
- (let ((commit "68c5b1225572ecf2c52baf62f928063e5a30511b")
- (revision "1"))
- (package
- (name "femtolisp")
- (version (string-append "0.0.0-" revision "." (string-take commit 7)))
- (source (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/JeffBezanson/femtolisp.git")
- (commit commit)))
- (file-name (string-append name "-" version "-checkout"))
- (sha256
- (base32
- "04rnwllxnl86zw8c6pwxznn49bvkvh0f1lfliy085vjzvlq3rgja"))))
- ;; See "utils.h" for supported systems. Upstream bug:
- ;; https://github.com/JeffBezanson/femtolisp/issues/25
- (supported-systems
- (fold delete %supported-systems
- '("armhf-linux" "mips64el-linux" "aarch64-linux")))
- (build-system gnu-build-system)
- (arguments
- `(#:make-flags '("CC=gcc" "release")
- #:test-target "test"
- #:phases
- (modify-phases %standard-phases
- (delete 'configure) ; No configure script
- (replace 'install ; Makefile has no 'install phase
- (lambda* (#:key outputs #:allow-other-keys)
- (let* ((out (assoc-ref outputs "out"))
- (bin (string-append out "/bin")))
- (install-file "flisp" bin)
- #t)))
- ;; The flisp binary is now available, run bootstrap to
- ;; generate flisp.boot and afterwards runs make test.
- (add-after 'install 'bootstrap-gen-and-test
- (lambda* (#:key outputs #:allow-other-keys)
- (let* ((out (assoc-ref outputs "out"))
- (bin (string-append out "/bin")))
- (and
- (zero? (system* "./bootstrap.sh"))
- (install-file "flisp.boot" bin))))))))
- (synopsis "Scheme-like lisp implementation")
- (description
- "@code{femtolisp} is a scheme-like lisp implementation with a
-simple, elegant Scheme dialect. It is a lisp-1 with lexical scope.
-The core is 12 builtin special forms and 33 builtin functions.")
- (home-page "https://github.com/JeffBezanson/femtolisp")
- (license license:bsd-3))))
-
(define-public lush2
(package
(name "lush2")
(define-public ecl-trivial-gray-streams
(sbcl-package->ecl-package sbcl-trivial-gray-streams))
+(define-public sbcl-fiasco
+ (let ((commit "d62f7558b21addc89f87e306f65d7f760632655f")
+ (revision "1"))
+ (package
+ (name "sbcl-fiasco")
+ (version (git-version "0.0.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/joaotavora/fiasco.git")
+ (commit commit)))
+ (file-name (git-file-name "fiasco" version))
+ (sha256
+ (base32
+ "1zwxs3d6iswayavcmb49z2892xhym7n556d8dnmvalc32pm9bkjh"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
+ (synopsis "Simple and powerful test framework for Common Lisp")
+ (description "A Common Lisp test framework that treasures your failures,
+logical continuation of Stefil. It focuses on interactive debugging.")
+ (home-page "https://github.com/joaotavora/fiasco")
+ ;; LICENCE specifies this is public-domain unless the legislation
+ ;; doesn't allow or recognize it. In that case it falls back to a
+ ;; permissive licence.
+ (license (list license:public-domain
+ (license:x11-style "file://LICENCE"))))))
+
+(define-public cl-fiasco
+ (sbcl-package->cl-source-package sbcl-fiasco))
+
+(define-public ecl-fiasco
+ (sbcl-package->ecl-package sbcl-fiasco))
+
(define-public sbcl-flexi-streams
(package
(name "sbcl-flexi-streams")
`(("sbcl-cl-ppcre" ,sbcl-cl-ppcre)
("sbcl-cl-unicode" ,sbcl-cl-unicode)))))
-(define-public sbcl-stumpwm
+(define-public stumpwm
(package
- (name "sbcl-stumpwm")
- (version "18.05")
+ (name "stumpwm")
+ (version "18.11")
(source (origin
(method url-fetch)
(uri (string-append
"https://github.com/stumpwm/stumpwm/archive/"
version ".tar.gz"))
(sha256
- (base32 "1n2gaab3lwgf5r1hmwdcw13dkv9xdd7drn2shx28kfxvhdc9kbb9"))
- (file-name (string-append "stumpwm-" version ".tar.gz"))))
+ (base32 "177gxfk4c127i9crghx6fmkipznhgylvzgnjb2pna38g21gg6s39"))
+ (file-name (string-append "stumpwm-" version ".tar.gz"))
+ (patches
+ ;; This patch is included in the post-18.11 git master tree
+ ;; and can be removed when we move to the next release.
+ (search-patches "stumpwm-fix-broken-read-one-line.patch"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs `(("fiasco" ,sbcl-fiasco)
+ ("texinfo" ,texinfo)))
(inputs `(("cl-ppcre" ,sbcl-cl-ppcre)
("clx" ,sbcl-clx)
("alexandria" ,sbcl-alexandria)))
(outputs '("out" "lib"))
(arguments
- '(#:phases
+ '(#:asd-system-name "stumpwm"
+ #:phases
(modify-phases %standard-phases
(add-after 'create-symlinks 'build-program
(lambda* (#:key outputs #:allow-other-keys)
Icon=~@
Type=Application~%"
out)))
+ #t)))
+ (add-after 'install 'install-manual
+ (lambda* (#:key outputs #:allow-other-keys)
+ ;; The proper way to the manual is bootstrapping a full autotools
+ ;; build system and running ‘./configure && make stumpwm.info’ to
+ ;; do some macro substitution. We can get away with much less.
+ (let* ((out (assoc-ref outputs "out"))
+ (info (string-append out "/share/info")))
+ (invoke "makeinfo" "stumpwm.texi.in")
+ (install-file "stumpwm.info" info)
#t))))))
(synopsis "Window manager written in Common Lisp")
(description "Stumpwm is a window manager written entirely in Common Lisp.
productive, customizable lisp based systems.")
(home-page "https://github.com/stumpwm/stumpwm")
(license license:gpl2+)
- (properties `((ecl-variant . ,(delay ecl-stumpwm))))))
+ (properties `((cl-source-variant . ,(delay cl-stumpwm))))))
-(define-public cl-stumpwm
- (sbcl-package->cl-source-package sbcl-stumpwm))
+(define-public sbcl-stumpwm
+ (deprecated-package "sbcl-stumpwm" stumpwm))
-(define-public ecl-stumpwm
- (let ((base (sbcl-package->ecl-package sbcl-stumpwm)))
- (package
- (inherit base)
- (outputs '("out"))
- (arguments '()))))
+(define-public cl-stumpwm
+ (package
+ (inherit (sbcl-package->cl-source-package stumpwm))
+ (name "cl-stumpwm")))
;; The slynk that users expect to install includes all of slynk's contrib
;; modules. Therefore, we build the base module and all contribs first; then
paths)
#t)))))))
-(define-public sbcl-stumpwm+slynk
+(define-public stumpwm+slynk
(package
- (inherit sbcl-stumpwm)
- (name "sbcl-stumpwm-with-slynk")
+ (inherit stumpwm)
+ (name "stumpwm-with-slynk")
(outputs '("out"))
(inputs
- `(("stumpwm" ,sbcl-stumpwm "lib")
+ `(("stumpwm" ,stumpwm "lib")
("slynk" ,sbcl-slynk)))
(arguments
- (substitute-keyword-arguments (package-arguments sbcl-stumpwm)
+ (substitute-keyword-arguments (package-arguments stumpwm)
((#:phases phases)
`(modify-phases ,phases
(replace 'build-program
(delete 'cleanup)
(delete 'create-symlinks)))))))
+(define-public sbcl-stumpwm+slynk
+ (deprecated-package "sbcl-stumpwm-with-slynk" stumpwm+slynk))
+
(define-public sbcl-parse-js
(let ((commit "fbadc6029bec7039602abfc06c73bb52970998f6")
(revision "1"))
@item reduce variable names (usually to single letters)
@item join consecutive @code{var} statements
@item resolve simple binary expressions
-@item group most consecutive statements using the ``sequence'' operator (comma)
+@item group most consecutive statements using the @code{sequence} operator (comma)
@item remove unnecessary blocks
@item convert @code{IF} expressions in various ways that result in smaller code
@item remove some unreachable code
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/atlas-engineer/cl-webkit")
+ (url "https://github.com/jmercouris/cl-webkit")
(commit commit)))
(file-name (git-file-name "cl-webkit" version))
(sha256
(("libwebkit2gtk" all)
(string-append
(assoc-ref inputs "webkitgtk") "/lib/" all))))))))
- (home-page "https://github.com/atlas-engineer/cl-webkit")
+ (home-page "https://github.com/jmercouris/cl-webkit")
(synopsis "Binding to WebKitGTK+ for Common Lisp")
(description
"@command{cl-webkit} is a binding to WebKitGTK+ for Common Lisp,
(define-public ecl-lparallel
(sbcl-package->ecl-package sbcl-lparallel))
+
+(define-public sbcl-cl-markup
+ (let ((commit "e0eb7debf4bdff98d1f49d0f811321a6a637b390"))
+ (package
+ (name "sbcl-cl-markup")
+ (version (git-version "0.1" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/arielnetworks/cl-markup/")
+ (commit commit)))
+ (file-name (git-file-name "cl-markup" version))
+ (sha256
+ (base32
+ "10l6k45971dl13fkdmva7zc6i453lmq9j4xax2ci6pjzlc6xjhp7"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/arielnetworks/cl-markup/")
+ (synopsis "Markup generation library for Common Lisp")
+ (description
+ "A modern markup generation library for Common Lisp that features:
+
+@itemize
+@item Fast (even faster through compiling the code)
+@item Safety
+@item Support for multiple document types (markup, xml, html, html5, xhtml)
+@item Output with doctype
+@item Direct output to stream
+@end itemize\n")
+ (license license:lgpl3+))))
+
+(define-public cl-markup
+ (sbcl-package->cl-source-package sbcl-cl-markup))
+
+(define-public ecl-cl-markup
+ (sbcl-package->ecl-package sbcl-cl-markup))
+
+(define-public sbcl-cl-css
+ (let ((commit "8fe654c8f0cf95b300718101cce4feb517f78e2f"))
+ (package
+ (name "sbcl-cl-css")
+ (version (git-version "0.1" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/inaimathi/cl-css/")
+ (commit commit)))
+ (file-name (git-file-name "cl-css" version))
+ (sha256
+ (base32
+ "1lc42zi2sw11fl2589sc19nr5sd2p0wy7wgvgwaggxa5f3ajhsmd"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/inaimathi/cl-css/")
+ (synopsis "Non-validating, inline CSS generator for Common Lisp")
+ (description
+ "This is a dead-simple, non validating, inline CSS generator for Common
+Lisp. Its goals are axiomatic syntax, simple implementation to support
+portability, and boilerplate reduction in CSS.")
+ (license license:expat))))
+
+(define-public cl-css
+ (sbcl-package->cl-source-package sbcl-cl-css))
+
+(define-public ecl-cl-css
+ (sbcl-package->ecl-package sbcl-cl-css))
+
+(define-public sbcl-portable-threads
+ (let ((commit "c0e61a1faeb0583c80fd3f20b16cc4c555226920"))
+ (package
+ (name "sbcl-portable-threads")
+ (version (git-version "2.3" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/binghe/portable-threads/")
+ (commit commit)))
+ (file-name (git-file-name "portable-threads" version))
+ (sha256
+ (base32
+ "03fmxyarc0xf4kavwkfa0a2spkyfrz6hbgbi9y4q7ny5aykdyfaq"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(;; Tests seem broken.
+ #:tests? #f))
+ (home-page "https://github.com/binghe/portable-threads")
+ (synopsis "Portable threads (and scheduled and periodic functions) API for Common Lisp")
+ (description
+ "Portable Threads (and Scheduled and Periodic Functions) API for Common
+Lisp (from GBBopen project).")
+ (license license:asl2.0))))
+
+(define-public cl-portable-threads
+ (sbcl-package->cl-source-package sbcl-portable-threads))
+
+(define-public ecl-portable-threada
+ (sbcl-package->ecl-package sbcl-portable-threads))
+
+(define-public sbcl-usocket-boot0
+ ;; usocket's test rely on usocket-server which depends on usocket itself.
+ ;; We break this cyclic dependency with -boot0 that packages usocket.
+ (let ((commit "86e7efbfe50101931edf4b67cdcfa7e221ecfde9"))
+ (package
+ (name "sbcl-usocket-boot0")
+ (version (git-version "0.7.1" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/usocket/usocket/")
+ (commit commit)))
+ (file-name (git-file-name "usocket" version))
+ (sha256
+ (base32
+ "1lk6ipakrib7kdgzw44hrgmls9akp5pz4h35yynw0k5zwmmq6374"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("split-sequence" ,sbcl-split-sequence)))
+ (arguments
+ `(#:tests? #f
+ #:asd-system-name "usocket"))
+ (home-page "https://common-lisp.net/project/usocket/")
+ (synopsis "Universal socket library for Common Lisp (server side)")
+ (description
+ "This library strives to provide a portable TCP/IP and UDP/IP socket
+interface for as many Common Lisp implementations as possible, while keeping
+the abstraction and portability layer as thin as possible.")
+ (license license:expat))))
+
+(define-public sbcl-usocket-server
+ (package
+ (inherit sbcl-usocket-boot0)
+ (name "sbcl-usocket-server")
+ (inputs
+ `(("usocket" ,sbcl-usocket-boot0)
+ ("portable-threads" ,sbcl-portable-threads)))
+ (arguments
+ '(#:asd-system-name "usocket-server"))
+ (synopsis "Universal socket library for Common Lisp (server side)")))
+
+(define-public cl-usocket-server
+ (sbcl-package->cl-source-package sbcl-usocket-server))
+
+(define-public ecl-socket-server
+ (sbcl-package->ecl-package sbcl-usocket-server))
+
+(define-public sbcl-usocket
+ (package
+ (inherit sbcl-usocket-boot0)
+ (name "sbcl-usocket")
+ (arguments
+ ;; FIXME: Tests need network access?
+ `(#:tests? #f))
+ (native-inputs
+ ;; Testing only.
+ `(("usocket-server" ,sbcl-usocket-server)
+ ("rt" ,sbcl-rt)))))
+
+(define-public cl-usocket
+ (sbcl-package->cl-source-package sbcl-usocket))
+
+(define-public ecl-socket
+ (sbcl-package->ecl-package sbcl-usocket))
+
+(define-public sbcl-s-xml
+ (package
+ (name "sbcl-s-xml")
+ (version "3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri "https://common-lisp.net/project/s-xml/s-xml.tgz")
+ (sha256
+ (base32
+ "061qcr0dzshsa38s5ma4ay924cwak2nq9gy59dw6v9p0qb58nzjf"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://common-lisp.net/project/s-xml/")
+ (synopsis "Simple XML parser implemented in Common Lisp")
+ (description
+ "S-XML is a simple XML parser implemented in Common Lisp. This XML
+parser implementation has the following features:
+
+@itemize
+@item It works (handling many common XML usages).
+@item It is very small (the core is about 700 lines of code, including
+comments and whitespace).
+@item It has a core API that is simple, efficient and pure functional, much
+like that from SSAX (see also http://ssax.sourceforge.net).
+@item It supports different DOM models: an XSML-based one, an LXML-based one
+and a classic xml-element struct based one.
+@item It is reasonably time and space efficient (internally avoiding garbage
+generatation as much as possible).
+@item It does support CDATA.
+@item It should support the same character sets as your Common Lisp
+implementation.
+@item It does support XML name spaces.
+@end itemize
+
+This XML parser implementation has the following limitations:
+
+@itemize
+@item It does not support any special tags (like processing instructions).
+@item It is not validating, even skips DTD's all together.
+@end itemize\n")
+ (license license:lgpl3+)))
+
+(define-public cl-s-xml
+ (sbcl-package->cl-source-package sbcl-s-xml))
+
+(define-public ecl-s-xml
+ (sbcl-package->ecl-package sbcl-s-xml))
+
+(define-public sbcl-s-xml-rpc
+ (package
+ (name "sbcl-s-xml-rpc")
+ (version "7")
+ (source
+ (origin
+ (method url-fetch)
+ (uri "https://common-lisp.net/project/s-xml-rpc/s-xml-rpc.tgz")
+ (sha256
+ (base32
+ "02z7k163d51v0pzk8mn1xb6h5s6x64gjqkslhwm3a5x26k2gfs11"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("s-xml" ,sbcl-s-xml)))
+ (home-page "https://common-lisp.net/project/s-xml-rpc/")
+ (synopsis "Implementation of XML-RPC in Common Lisp for both client and server")
+ (description
+ "S-XML-RPC is an implementation of XML-RPC in Common Lisp for both
+client and server.")
+ (license license:lgpl3+)))
+
+(define-public cl-s-xml-rpc
+ (sbcl-package->cl-source-package sbcl-s-xml-rpc))
+
+(define-public ecl-s-xml-rpc
+ (sbcl-package->ecl-package sbcl-s-xml-rpc))
+
+(define-public sbcl-trivial-clipboard
+ (let ((commit "5af3415d1484e6d69a1b5c178f24680d9fd01796"))
+ (package
+ (name "sbcl-trivial-clipboard")
+ (version (git-version "0.0.0.0" "2" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/snmsts/trivial-clipboard")
+ (commit commit)))
+ (file-name (git-file-name "trivial-clipboard" version))
+ (sha256
+ (base32
+ "1gb515z5yq6h5548pb1fwhmb0hhq1ssyb78pvxh4alq799xipxs9"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("xclip" ,xclip)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (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\")"))))))))
+ (home-page "https://github.com/snmsts/trivial-clipboard")
+ (synopsis "Access system clipboard in Common Lisp")
+ (description
+ "@command{trivial-clipboard} gives access to the system clipboard.")
+ (license license:expat))))
+
+(define-public cl-trivial-clipboard
+ (sbcl-package->cl-source-package sbcl-trivial-clipboard))
+
+(define-public ecl-trivial-clipboard
+ (sbcl-package->ecl-package sbcl-trivial-clipboard))
HCoop / jackhill / guix / guix.git / blobdiff