diff options
34 files changed, 4938 insertions, 416 deletions
diff --git a/Makefile.am b/Makefile.am index 6f785e7083..1427203fb2 100644 --- a/Makefile.am +++ b/Makefile.am @@ -48,6 +48,7 @@ MODULES = \ guix/nar.scm \ guix/derivations.scm \ guix/gnu-maintenance.scm \ + guix/upstream.scm \ guix/licenses.scm \ guix/build-system.scm \ guix/build-system/cmake.scm \ diff --git a/doc/guix.texi b/doc/guix.texi index 3222a64085..99c10d8dc7 100644 --- a/doc/guix.texi +++ b/doc/guix.texi @@ -4211,8 +4211,12 @@ gnu/packages/glib.scm:77:12: glib would be upgraded from 2.34.3 to 2.37.0 @end example It does so by browsing each package's FTP directory and determining the -highest version number of the source tarballs -therein@footnote{Currently, this only works for GNU packages.}. +highest version number of the source tarballs therein. The command +knows how to update specific types of packages: GNU packages, ELPA +packages, etc.---see the documentation for @option{--type} below. The +are many packages, though, for which it lacks a method to determine +whether a new upstream release is available. However, the mechanism is +extensible, so feel free to get in touch with us to add a new method! When passed @code{--update}, it modifies distribution source files to update the version numbers and source tarball hashes of those packages' @@ -4257,6 +4261,29 @@ The @code{non-core} subset refers to the remaining packages. It is typically useful in cases where an update of the core packages would be inconvenient. +@item --type=@var{updater} +@itemx -t @var{updater} +Select only packages handled by @var{updater}. Currently, @var{updater} +may be one of: + +@table @code +@item gnu +the updater for GNU packages; +@item elpa +the updater for @uref{http://elpa.gnu.org/, ELPA} packages; +@item cran +the updater fro @uref{http://cran.r-project.org/, CRAN} packages. +@end table + +For instance, the following commands only checks for updates of Emacs +packages hosted at @code{elpa.gnu.org} and updates of CRAN packages: + +@example +$ guix refresh -t elpa -t cran +gnu/packages/statistics.scm:819:13: r-testthat would be upgraded from 0.10.0 to 0.11.0 +gnu/packages/emacs.scm:856:13: emacs-auctex would be upgraded from 11.88.6 to 11.88.9 +@end example + @end table In addition, @command{guix refresh} can be passed one or more package diff --git a/gnu-system.am b/gnu-system.am index 9bb537be33..655c00a679 100644 --- a/gnu-system.am +++ b/gnu-system.am @@ -439,6 +439,7 @@ dist_patch_DATA = \ gnu/packages/patches/elfutils-tests-ptrace.patch \ gnu/packages/patches/emacs-exec-path.patch \ gnu/packages/patches/eudev-rules-directory.patch \ + gnu/packages/patches/evilwm-lost-focus-bug.patch \ gnu/packages/patches/expat-CVE-2015-1283.patch \ gnu/packages/patches/fastcap-mulGlobal.patch \ gnu/packages/patches/fastcap-mulSetup.patch \ diff --git a/gnu/packages.scm b/gnu/packages.scm index 6e46a890bb..fb277389c7 100644 --- a/gnu/packages.scm +++ b/gnu/packages.scm @@ -24,6 +24,7 @@ #:use-module (guix utils) #:use-module ((guix ftp-client) #:select (ftp-open)) #:use-module (guix gnu-maintenance) + #:use-module (guix upstream) #:use-module (ice-9 ftw) #:use-module (ice-9 vlist) #:use-module (ice-9 match) @@ -377,14 +378,18 @@ it." (when (false-if-exception (gnu-package? package)) (let ((name (package-name package)) (full-name (package-full-name package))) + ;; XXX: This could work with non-GNU packages as well. However, + ;; GNU's FTP-based updater would be too slow if it weren't memoized, + ;; and the generic interface in (guix upstream) doesn't support + ;; that. (match (waiting (latest-release name #:ftp-open ftp-open* #:ftp-close (const #f)) (_ "looking for the latest release of GNU ~a...") name) - ((? gnu-release? release) + ((? upstream-source? source) (let ((latest-version - (string-append (gnu-release-package release) "-" - (gnu-release-version release)))) + (string-append (upstream-source-package source) "-" + (upstream-source-version source)))) (when (version>? latest-version full-name) (format (current-error-port) (_ "~a: note: using ~a \ diff --git a/gnu/packages/bioinformatics.scm b/gnu/packages/bioinformatics.scm index 51e3df6d81..48edd56854 100644 --- a/gnu/packages/bioinformatics.scm +++ b/gnu/packages/bioinformatics.scm @@ -2149,6 +2149,52 @@ viewer.") (string-append bin "/samtools"))))) (delete 'patch-tests))))))) +(define-public mosaik + (let ((commit "5c25216d")) + (package + (name "mosaik") + (version "2.2.30") + (source (origin + ;; There are no release tarballs nor tags. + (method git-fetch) + (uri (git-reference + (url "https://github.com/wanpinglee/MOSAIK.git") + (commit commit))) + (file-name (string-append name "-" version)) + (sha256 + (base32 + "17gj3s07cm77r41z92awh0bim7w7q7fbn0sf5nkqmcm1vw052qgw")))) + (build-system gnu-build-system) + (arguments + `(#:tests? #f ; no tests + #:make-flags (list "CC=gcc") + #:phases + (modify-phases %standard-phases + (replace 'configure + (lambda _ (chdir "src") #t)) + (replace 'install + (lambda* (#:key outputs #:allow-other-keys) + (let ((bin (string-append (assoc-ref outputs "out") + "/bin"))) + (mkdir-p bin) + (copy-recursively "../bin" bin) + #t)))))) + (inputs + `(("perl" ,perl) + ("zlib" ,zlib))) + (home-page "https://code.google.com/p/mosaik-aligner/") + (synopsis "Map nucleotide sequence reads to reference genomes") + (description + "MOSAIK is a program for mapping second and third-generation sequencing +reads to a reference genome. MOSAIK can align reads generated by all the +major sequencing technologies, including Illumina, Applied Biosystems SOLiD, +Roche 454, Ion Torrent and Pacific BioSciences SMRT.") + ;; MOSAIK is released under the GPLv2+ with the exception of third-party + ;; code released into the public domain: + ;; 1. fastlz by Ariya Hidayat - http://www.fastlz.org/ + ;; 2. MD5 implementation - RSA Data Security, RFC 1321 + (license (list license:gpl2+ license:public-domain))))) + (define-public ngs-sdk (package (name "ngs-sdk") diff --git a/gnu/packages/cdrom.scm b/gnu/packages/cdrom.scm index 62a6040280..884ba8bfa6 100644 --- a/gnu/packages/cdrom.scm +++ b/gnu/packages/cdrom.scm @@ -2,6 +2,7 @@ ;;; Copyright © 2013, 2014, 2015 Ludovic Courtès <ludo@gnu.org> ;;; Copyright © 2013, 2014 Andreas Enge <andreas@enge.fr> ;;; Copyright © 2015 Taylan Ulrich Bayırlı/Kammer <taylanbayirli@gmail.com> +;;; Copyright © 2015 Paul van der Walt <paul@denknerd.org> ;;; ;;; This file is part of GNU Guix. ;;; @@ -231,6 +232,25 @@ depend on the file system of the medium. The maximum error correction capacity is user-selectable.") (license gpl2+))) +(define-public libcue + (package + (name "libcue") + (version "1.4.0") + (source (origin + (method url-fetch) + (uri (string-append "mirror://sourceforge/libcue/libcue-" + version ".tar.bz2")) + (sha256 + (base32 + "17kjd7rjz1bvfn44n3n2bjb7a1ywd0yc0g4sqp5ihf9b5bn7cwlb")))) + (build-system gnu-build-system) + (home-page "http://libcue.sourceforge.net/") + (synopsis "C library to parse cue sheets") + (description "Libcue is a C library to parse so-called @dfn{cue sheets} +which contain meta-data for CD/DVD tracks. It provides an API to manipulate +the data.") + (license gpl2+))) + (define-public cd-discid (package (name "cd-discid") diff --git a/gnu/packages/compression.scm b/gnu/packages/compression.scm index 941844b870..a9e942efd5 100644 --- a/gnu/packages/compression.scm +++ b/gnu/packages/compression.scm @@ -7,6 +7,7 @@ ;;; Copyright © 2015 Ricardo Wurmus <rekado@elephly.net> ;;; Copyright © 2015 Leo Famulari <leo@famulari.name> ;;; Copyright © 2015 Jeff Mickey <j@codemac.net> +;;; Copyright © 2015 Efraim Flashner <efraim@flashner.co.il> ;;; ;;; This file is part of GNU Guix. ;;; @@ -25,6 +26,7 @@ (define-module (gnu packages compression) #:use-module ((guix licenses) #:prefix license:) + #:use-module (guix utils) #:use-module (guix packages) #:use-module (guix download) #:use-module (guix git-download) @@ -225,6 +227,36 @@ decompression.") "See LICENSE in the distribution.")) (home-page "http://www.bzip.org/")))) +(define-public pbzip2 + (package + (name "pbzip2") + (version "1.1.12") + (source (origin + (method url-fetch) + (uri (string-append "https://launchpad.net/pbzip2/" + (version-major+minor version) "/" version + "/+download/" name "-" version ".tar.gz")) + (sha256 + (base32 + "1vk6065dv3a47p86vmp8hv3n1ygd9hraz0gq89gvzlx7lmcb6fsp")))) + (build-system gnu-build-system) + (inputs + `(("bzip2", bzip2))) + (arguments + `(#:tests? #f ; no tests + #:phases (modify-phases %standard-phases + (delete 'configure)) + #:make-flags (list (string-append "PREFIX=" %output)))) + (home-page "http://compression.ca/pbzip2/") + (synopsis "Parallel bzip2 implementation") + (description + "Pbzip2 is a parallel implementation of the bzip2 block-sorting file +compressor that uses pthreads and achieves near-linear speedup on SMP machines. +The output of this version is fully compatible with bzip2 v1.0.2 (i.e. anything +compressed with pbzip2 can be decompressed with bzip2).") + (license (license:non-copyleft "file://COPYING" + "See COPYING in the distribution.")))) + (define-public xz (package (name "xz") diff --git a/gnu/packages/conkeror.scm b/gnu/packages/conkeror.scm index 51bb1a260a..d91fe9e78b 100644 --- a/gnu/packages/conkeror.scm +++ b/gnu/packages/conkeror.scm @@ -1,6 +1,6 @@ ;;; GNU Guix --- Functional package management for GNU ;;; Copyright © 2014 Cyrill Schenkel <cyrill.schenkel@gmail.com> -;;; Copyright © 2014 Eric Bavier <bavier@member.fsf.org> +;;; Copyright © 2014, 2015 Eric Bavier <bavier@member.fsf.org> ;;; ;;; This file is part of GNU Guix. ;;; @@ -28,46 +28,42 @@ (define-public conkeror (package (name "conkeror") - (version "1.0pre1") + (version "1.0pre1.20150730") (source (origin (method url-fetch) (uri (string-append "http://repo.or.cz/w/conkeror.git/snapshot/" - "8a26fff5896a3360549e2adfbf06b1d57e909266" - ".tar.gz")) ; tag: debian-1.0--pre-1+git140616-1 + "a1f7e879b129df5cf14ea4ce80a9c1407380ed58" + ".tar.gz")) ; tag: debian-1.0--pre-1+git150730-1 (sha256 (base32 - "1cgjzi7g3g22zcx6bpfnid4i12sb45w6icmxdzjn8d3c0m8qsyp1")))) + "1q45hc30733gz3ca2ixvw0rzzcbi7rlay7gx7kvzjv17a030nyk0")))) (build-system gnu-build-system) (inputs `(("icecat" ,icecat))) (arguments `(#:tests? #f ;no tests - #:make-flags '("CC=gcc") + #:make-flags `("CC=gcc" + ,(string-append "PREFIX=" (assoc-ref %outputs "out"))) #:phases - (alist-delete - 'configure - (alist-replace - 'install - (lambda _ - (begin - (use-modules (guix build utils)) - (let* ((datadir (string-append %output "/share/conkeror")) - (bindir (string-append %output "/bin")) - (launcher (string-append bindir "/conkeror")) - (spawn (string-append bindir "/conkeror-spawn-helper"))) - (copy-recursively "." datadir) - (mkdir-p bindir) - (copy-file "conkeror-spawn-helper" spawn) - (call-with-output-file launcher - (lambda (p) - (format p "#!~a/bin/bash + (modify-phases %standard-phases + (delete 'configure) + (add-after + 'install 'install-app-launcher + (lambda* (#:key inputs outputs #:allow-other-keys) + ;; This overwrites the installed launcher, which execs xulrunner, + ;; with one that execs 'icecat --app' + (let* ((out (assoc-ref outputs "out")) + (datadir (string-append out "/share/conkeror")) + (launcher (string-append out "/bin/conkeror"))) + (call-with-output-file launcher + (lambda (p) + (format p "#!~a/bin/bash exec ~a/bin/icecat --app ~a \"$@\"~%" - (assoc-ref %build-inputs "bash") ;implicit input - (assoc-ref %build-inputs "icecat") - (string-append datadir - "/application.ini")))) - (chmod launcher #o555)))) - %standard-phases)))) + (assoc-ref inputs "bash") ;implicit input + (assoc-ref inputs "icecat") + (string-append datadir + "/application.ini")))) + (chmod launcher #o555))))))) (synopsis "Keyboard focused web browser with Emacs look and feel") (description "Conkeror is a highly-programmable web browser based on Mozilla XULRunner which is the base of all Mozilla products including Firefox. diff --git a/gnu/packages/freeipmi.scm b/gnu/packages/freeipmi.scm index e25d113dd2..badecc60ba 100644 --- a/gnu/packages/freeipmi.scm +++ b/gnu/packages/freeipmi.scm @@ -27,14 +27,14 @@ (define-public freeipmi (package (name "freeipmi") - (version "1.4.9") + (version "1.4.10") (source (origin (method url-fetch) (uri (string-append "mirror://gnu/freeipmi/freeipmi-" version ".tar.gz")) (sha256 (base32 - "0v2xfwik2mv6z8066raiypc4xymjvr8pb0mv3mc3g4ym4km132qp")))) + "1l98l8g8lha85q1d288wr7dyx00x36smh9g5wza15n4wm35c9wqs")))) (build-system gnu-build-system) (inputs `(("readline" ,readline) ("libgcrypt" ,libgcrypt))) diff --git a/gnu/packages/games.scm b/gnu/packages/games.scm index 3023794218..546944ad25 100644 --- a/gnu/packages/games.scm +++ b/gnu/packages/games.scm @@ -6,12 +6,13 @@ ;;; Copyright © 2014 Sylvain Beucler <beuc@beuc.net> ;;; Copyright © 2014, 2015 Ludovic Courtès <ludo@gnu.org> ;;; Copyright © 2014, 2015 Sou Bunnbu <iyzsong@gmail.com> -;;; Copyright © 2014 Mark H Weaver <mhw@netris.org> +;;; Copyright © 2014, 2015 Mark H Weaver <mhw@netris.org> ;;; Copyright © 2015 Andreas Enge <andreas@enge.fr> ;;; Copyright © 2015 David Hashe <david.hashe@dhashe.com> ;;; Copyright © 2015 Christopher Allan Webber <cwebber@dustycloud.org> ;;; Copyright © 2015 Ricardo Wurmus <rekado@elephly.net> ;;; Copyright © 2015 Alex Kost <alezost@gmail.com> +;;; Copyright © 2015 Paul van der Walt <paul@denknerd.org> ;;; ;;; This file is part of GNU Guix. ;;; @@ -34,7 +35,9 @@ #:use-module (guix packages) #:use-module (guix download) #:use-module (guix git-download) + #:use-module (guix svn-download) #:use-module (gnu packages) + #:use-module (gnu packages autotools) #:use-module (gnu packages base) #:use-module (gnu packages admin) #:use-module (gnu packages audio) @@ -49,6 +52,7 @@ #:use-module (gnu packages guile) #:use-module (gnu packages libcanberra) #:use-module (gnu packages libunwind) + #:use-module (gnu packages haskell) #:use-module (gnu packages mp3) #:use-module (gnu packages image) #:use-module (gnu packages ncurses) @@ -78,6 +82,7 @@ #:use-module (gnu packages fribidi) #:use-module (guix build-system trivial) #:use-module (guix build-system gnu) + #:use-module (guix build-system haskell) #:use-module (guix build-system cmake) #:use-module (guix build-system trivial)) @@ -1048,6 +1053,48 @@ experience and advance levels, and are carried over from one scenario to the next campaign.") (license license:gpl2+))) +(define-public dosbox + (package + (name "dosbox") + (version "0.74.svn3947") + (source (origin + (method svn-fetch) + (uri (svn-reference + (url "http://svn.code.sf.net/p/dosbox/code-0/dosbox/trunk/") + (revision 3947))) + (file-name (string-append name "-" version "-checkout")) + ;; Use SVN head, since the last release (2010) is incompatible + ;; with GCC 4.8+ (see + ;; <https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=624976>). + (sha256 + (base32 + "1p918j6090d1nkvgq7ifvmn506zrdmyi32y7p3ms40d5ssqjg8fj")))) + (build-system gnu-build-system) + (arguments + `(#:phases (modify-phases %standard-phases + (add-after + 'unpack 'autogen.sh + (lambda _ + (zero? (system* "sh" "autogen.sh"))))))) + (native-inputs + `(("autoconf" ,autoconf) + ("automake" ,automake))) + (inputs + `(("sdl" ,sdl) + ("libpng" ,libpng) + ("zlib" ,zlib) + ("alsa-lib" ,alsa-lib) + ("glu" ,glu) + ("mesa" ,mesa))) + (home-page "http://www.dosbox.com") + (synopsis "x86 emulator with CGA/EGA/VGA/etc. graphics and sound") + (description "DOSBox is a DOS-emulator that uses the SDL library. DOSBox +also emulates CPU:286/386 realmode/protected mode, Directory +FileSystem/XMS/EMS, Tandy/Hercules/CGA/EGA/VGA/VESA graphics, a +SoundBlaster/Gravis Ultra Sound card for excellent sound compatibility with +older games.") + (license license:gpl2+))) + (define-public gamine (package (name "gamine") @@ -1094,6 +1141,39 @@ on the screen and keyboard to display letters.") ;; Most files under gpl2+ or gpl3+, but eat.wav under gpl3 (license license:gpl3))) +(define-public raincat + (package + (name "raincat") + (version "1.1.1.3") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/Raincat/Raincat-" + version + ".tar.gz")) + (sha256 + (base32 + "1aalh68h6799mv4vyg30zpskl5jkn6x2j1jza7p4lrflyifxzar8")))) + (build-system haskell-build-system) + (inputs + `(("ghc-extensible-exceptions" ,ghc-extensible-exceptions) + ("ghc-mtl" ,ghc-mtl) + ("ghc-random" ,ghc-random) + ("ghc-glut" ,ghc-glut) + ("ghc-opengl" ,ghc-opengl) + ("ghc-sdl" ,ghc-sdl) + ("ghc-sdl-image" ,ghc-sdl-image) + ("ghc-sdl-mixer" ,ghc-sdl-mixer))) + (home-page "http://raincat.bysusanlin.com/") + (synopsis "Puzzle game with a cat in lead role") + (description "Project Raincat is a game developed by Carnegie Mellon +students through GCS during the Fall 2008 semester. Raincat features game +play inspired from classics Lemmings and The Incredible Machine. The project +proved to be an excellent learning experience for the programmers. Everything +is programmed in Haskell.") + (license license:bsd-3))) + (define-public manaplus (package (name "manaplus") diff --git a/gnu/packages/gnu-pw-mgr.scm b/gnu/packages/gnu-pw-mgr.scm index e7b93f024e..76329e8084 100644 --- a/gnu/packages/gnu-pw-mgr.scm +++ b/gnu/packages/gnu-pw-mgr.scm @@ -29,7 +29,7 @@ (define-public gnu-pw-mgr (package (name "gnu-pw-mgr") - (version "1.5") + (version "1.6") (source (origin (method url-fetch) @@ -37,7 +37,7 @@ version ".tar.xz")) (sha256 (base32 - "1winmckl4h8lypg57hd3nd7jscpdr7f1v8zi432k5h648izkf2dg")))) + "141wfm4w420ygrl7qvrc84drzv34jym0d2bxqcgi7n1vimql0slp")))) (build-system gnu-build-system) (native-inputs `(("which" ,which) diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm index 34cad87b4b..83ec3f9ca3 100644 --- a/gnu/packages/haskell.scm +++ b/gnu/packages/haskell.scm @@ -1,6 +1,7 @@ ;;; GNU Guix --- Functional package management for GNU ;;; Copyright © 2015 Federico Beffa <beffa@fbengineering.ch> ;;; Copyright © 2015 Siniša Biđin <sinisa@bidin.eu> +;;; Copyright © 2015 Paul van der Walt <paul@denknerd.org> ;;; ;;; This file is part of GNU Guix. ;;; @@ -19,7 +20,7 @@ (define-module (gnu packages haskell) #:use-module (ice-9 regex) - #:use-module ((guix licenses) #:select (bsd-3 lgpl2.1)) + #:use-module ((guix licenses) #:select (bsd-3 lgpl2.1 lgpl2.1+ gpl3+ expat)) #:use-module (guix packages) #:use-module (guix download) #:use-module (guix utils) @@ -29,13 +30,18 @@ #:use-module (gnu packages perl) #:use-module (gnu packages compression) #:use-module (gnu packages elf) + #:use-module (gnu packages gl) + #:use-module (gnu packages sdl) #:use-module (gnu packages bootstrap) + #:use-module (gnu packages zip) + #:use-module (gnu packages gcc) #:use-module (gnu packages ghostscript) #:use-module (gnu packages libffi) #:use-module (gnu packages libedit) #:use-module (gnu packages multiprecision) #:use-module (gnu packages ncurses) #:use-module (gnu packages python) + #:use-module (gnu packages pcre) #:use-module (gnu packages xorg)) (define ghc-bootstrap-x86_64-7.8.4 @@ -73,7 +79,7 @@ (define-public ghc (package (name "ghc") - (version "7.8.4") + (version "7.10.2") (source (origin (method url-fetch) @@ -81,7 +87,7 @@ version "/" name "-" version "-src.tar.xz")) (sha256 (base32 - "1i4254akbb4ym437rf469gc0m40bxm31blp6s1z1g15jmnacs6f3")))) + "1x8m4rp2v7ydnrz6z9g8x7z3x3d3pxhv2pixy7i7hkbqbdsp7kal")))) (build-system gnu-build-system) (supported-systems '("i686-linux" "x86_64-linux")) (outputs '("out" "doc")) @@ -98,7 +104,7 @@ version "/" name "-" version "-testsuite.tar.xz")) (sha256 (base32 - "0q95whf87y4mxjzwzy899g7z7l9pazq4si6iciyhxkcdhqq2ycyh")))))) + "0qp9da9ar87zbyn6wjgacd2ic1vgzbi3cklxnhsmjqyafv9qaj4b")))))) (native-inputs `(("perl" ,perl) ("python" ,python-2) ; for tests (fails with python-3) @@ -203,7 +209,7 @@ (string-append ghc-bootstrap-prefix "/lib/ghc-7.8.4/terminfo-0.4.0.0"))) (with-directory-excursion - (string-append ghc-bootstrap-path "/" ,name "-" ,version) + (string-append ghc-bootstrap-path "/ghc-7.8.4") (setenv "CONFIG_SHELL" (which "bash")) (setenv "LD_LIBRARY_PATH" gmp-lib) ;; The binaries have "/lib64/ld-linux-x86-64.so.2" hardcoded. @@ -231,7 +237,7 @@ 'configure 'install-bin (lambda* (#:key inputs outputs #:allow-other-keys) (with-directory-excursion - (string-append ghc-bootstrap-path "/" ,name "-" ,version) + (string-append ghc-bootstrap-path "/ghc-7.8.4") (zero? (system* "make" "install")))) %standard-phases))))))) (home-page "https://www.haskell.org/ghc") @@ -241,6 +247,28 @@ interactive environment for the functional language Haskell.") (license bsd-3))) +(define-public ghc-prelude-extras + (package + (name "ghc-prelude-extras") + (version "0.4.0.2") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/prelude-extras/prelude-extras-" + version + ".tar.gz")) + (sha256 + (base32 + "1q7mj9hysy747vimnlyrwsk1wb2axymxixa76fwcbcnmz3fi4llp")))) + (build-system haskell-build-system) + (home-page "http://github.com/ekmett/prelude-extras") + (synopsis "Higher order versions of Prelude classes") + (description "This library provides higher order versions of +@code{Prelude} classes to ease programming with polymorphic recursion and +reduce @code{UndecidableInstances}.") + (license bsd-3))) + (define-public ghc-data-default (package (name "ghc-data-default") @@ -361,6 +389,848 @@ package.") package.") (license bsd-3))) +(define-public ghc-haddock-library + (package + (name "ghc-haddock-library") + (version "1.2.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/haddock-library/haddock-library-" + version + ".tar.gz")) + (sha256 + (base32 + "0mhh2ppfhrvvi9485ipwbkv2fbgj35jvz3la02y3jlvg5ffs1c8g")))) + (build-system haskell-build-system) + (inputs + `(("ghc-base-compat" ,ghc-base-compat) + ("ghc-hspec" ,ghc-hspec) + ("ghc-quickcheck" ,ghc-quickcheck))) + (home-page "http://www.haskell.org/haddock/") + (synopsis + "Library exposing some functionality of Haddock") + (description + "Haddock is a documentation-generation tool for Haskell libraries. These +modules expose some functionality of it without pulling in the GHC dependency. +Please note that the API is likely to change so specify upper bounds in your +project if you can't release often. For interacting with Haddock itself, see +the ‘haddock’ package.") + (license bsd-3))) + +(define-public ghc-haddock-api + (package + (name "ghc-haddock-api") + (version "2.16.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/haddock-api/haddock-api-" + version + ".tar.gz")) + (sha256 + (base32 + "1spd5axg1pdjv4dkdb5gcwjsc8gg37qi4mr2k2db6ayywdkis1p2")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-paths" ,ghc-paths) + ("ghc-haddock-library" ,ghc-haddock-library))) + (home-page "http://www.haskell.org/haddock/") + (synopsis "API for documentation-generation tool Haddock") + (description "This package provides an API to Haddock, the +documentation-generation tool for Haskell libraries.") + (license bsd-3))) + +(define-public ghc-haddock + (package + (name "ghc-haddock") + (version "2.16.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/haddock/haddock-" + version + ".tar.gz")) + (sha256 + (base32 + "1mnnvc5jqp6n6rj7xw8wdm0z2xp9fndkz11c8p3vbljsrcqd3v26")))) + (build-system haskell-build-system) + (arguments `(#:tests? #f)) ; FIXME: Tests break with GHC 7.10.2, fixed + ; upstream. See + ; <https://github.com/haskell/haddock/issues/427> + (inputs `(("ghc-haddock-api" ,ghc-haddock-api))) + (home-page "http://www.haskell.org/haddock/") + (synopsis + "Documentation-generation tool for Haskell libraries") + (description + "Haddock is a documentation-generation tool for Haskell libraries.") + (license bsd-3))) + +(define-public ghc-simple-reflect + (package + (name "ghc-simple-reflect") + (version "0.3.2") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/simple-reflect/simple-reflect-" + version + ".tar.gz")) + (sha256 + (base32 + "1dpcf6w3cf1sfl9bnlsx04x7aghw029glj5d05qzrsnms2rlw8iq")))) + (build-system haskell-build-system) + (home-page + "http://twanvl.nl/blog/haskell/simple-reflection-of-expressions") + (synopsis + "Simple reflection of expressions containing variables") + (description + "This package allows simple reflection of expressions containing +variables. Reflection here means that a Haskell expression is turned into a +string. The primary aim of this package is teaching and understanding; there +are no options for manipulating the reflected expressions beyond showing +them.") + (license bsd-3))) + +(define-public ghc-multipart + (package + (name "ghc-multipart") + (version "0.1.2") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/multipart/multipart-" + version + ".tar.gz")) + (sha256 + (base32 + "0g04jhyw1ib1s7c9bcldyyn4n90qd9x7dmvic4vgq57bgcqgnhz5")))) + (build-system haskell-build-system) + (inputs `(("ghc-parsec" ,ghc-parsec))) + (home-page + "http://www.github.com/silkapp/multipart") + (synopsis + "HTTP multipart library") + (description + "HTTP multipart split out of the cgi package, for Haskell.") + (license bsd-3))) + +(define-public ghc-html + (package + (name "ghc-html") + (version "1.0.1.2") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/html/html-" + version + ".tar.gz")) + (sha256 + (base32 + "0q9hmfii62kc82ijlg238fxrzxhsivn42x5wd6ffcr9xldg4jd8c")))) + (build-system haskell-build-system) + (home-page + "http://hackage.haskell.org/package/html") + (synopsis "HTML combinator library") + (description + "This package contains a combinator library for constructing HTML +documents.") + (license bsd-3))) + +(define-public ghc-xhtml + (package + (name "ghc-xhtml") + (version "3000.2.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/xhtml/xhtml-" + version + ".tar.gz")) + (sha256 + (base32 + "1n6wgzxbj8xf0wf1il827qidphnffb5vzhwzqlxhh70c2y10f0ik")))) + (build-system haskell-build-system) + (home-page "https://github.com/haskell/xhtml") + (synopsis "XHTML combinator library") + (description + "This package provides combinators for producing XHTML 1.0, including the +Strict, Transitional and Frameset variants.") + (license bsd-3))) + +(define-public ghc-haskell-src + (package + (name "ghc-haskell-src") + (version "1.0.2.0") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/haskell-src/haskell-src-" + version + ".tar.gz")) + (sha256 + (base32 + "19lilhpwnjb7cks9fq1ipnc8f7dwxy0ri3dgjkdxs3i355byw99a")))) + (build-system haskell-build-system) + (inputs + `(("ghc-happy" ,ghc-happy) + ("ghc-syb" ,ghc-syb))) + (home-page + "http://hackage.haskell.org/package/haskell-src") + (synopsis + "Support for manipulating Haskell source code") + (description + "The 'haskell-src' package provides support for manipulating Haskell +source code. The package provides a lexer, parser and pretty-printer, and a +definition of a Haskell abstract syntax tree (AST). Common uses of this +package are to parse or generate Haskell 98 code.") + (license bsd-3))) + +(define-public ghc-alex + (package + (name "ghc-alex") + (version "3.1.4") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/alex/alex-" + version + ".tar.gz")) + (sha256 + (base32 + "17x13nbbr79xgdlzywjqw19vcl6iygjnssjnxnajgijkv764wknn")))) + (build-system haskell-build-system) + (arguments `(#:tests? #f)) ; FIXME: Tests broken for GHC 7.10. Fixed + ; upstream, see + ; <https://github.com/simonmar/alex/issues/62> + (inputs `(("ghc-quickcheck" ,ghc-quickcheck))) + (home-page "http://www.haskell.org/alex/") + (synopsis + "Tool for generating lexical analysers in Haskell") + (description + "Alex is a tool for generating lexical analysers in Haskell. It takes a +description of tokens based on regular expressions and generates a Haskell +module containing code for scanning text efficiently. It is similar to the +tool lex or flex for C/C++.") + (license bsd-3))) + +(define-public ghc-cgi + (package + (name "ghc-cgi") + (version "3001.2.2.2") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/cgi/cgi-" + version + ".tar.gz")) + (sha256 + (base32 + "0q1pxpa8gi42c0hsidcdkhk5xr5anfrvhqsn3iksr9c0rllhz193")))) + (build-system haskell-build-system) + (inputs + `(("ghc-parsec" ,ghc-parsec) + ("ghc-old-locale" ,ghc-old-locale) + ("ghc-old-time" ,ghc-old-time) + ("ghc-exceptions" ,ghc-exceptions) + ("ghc-multipart" ,ghc-multipart) + ("ghc-network-uri" ,ghc-network-uri) + ("ghc-network" ,ghc-network) + ("ghc-mtl" ,ghc-mtl))) + (home-page + "https://github.com/cheecheeo/haskell-cgi") + (synopsis "Library for writing CGI programs") + (description + "This is a Haskell library for writing CGI programs.") + (license bsd-3))) + +(define-public ghc-cmdargs + (package + (name "ghc-cmdargs") + (version "0.10.13") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/cmdargs/cmdargs-" + version + ".tar.gz")) + (sha256 + (base32 + "0vmz7f0ssrqlp6wzmc0mjqj4qczfgk58g0lr0yz7jamamlgpq4b6")))) + (build-system haskell-build-system) + (home-page + "http://community.haskell.org/~ndm/cmdargs/") + (synopsis "Command line argument processing") + (description + "This library provides an easy way to define command line parsers.") + (license bsd-3))) + +(define-public ghc-happy + (package + (name "ghc-happy") + (version "1.19.5") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/happy/happy-" + version + ".tar.gz")) + (sha256 + (base32 + "1nj353q4z1g186fpjzf0dnsg71qhxqpamx8jy89rjjvv3p0kmw32")))) + (build-system haskell-build-system) + (arguments `(#:tests? #f)) ;; cannot satisfy -package mtl. Possible Cabal + ;; issue. + (propagated-inputs + `(("ghc-mtl" ,ghc-mtl))) + (home-page "https://hackage.haskell.org/package/happy") + (synopsis "Parser generator for Haskell") + (description "Happy is a parser generator for Haskell. Given a grammar +specification in BNF, Happy generates Haskell code to parse the grammar. +Happy works in a similar way to the yacc tool for C.") + (license bsd-3))) + +(define-public ghc-haskell-src-exts + (package + (name "ghc-haskell-src-exts") + (version "1.16.0.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/haskell-src-exts/haskell-src-exts-" + version + ".tar.gz")) + (sha256 + (base32 + "1h8gjw5g92rvvzadqzpscg73x7ajvs1wlphrh27afim3scdd8frz")))) + (build-system haskell-build-system) + (inputs + `(("cpphs" ,cpphs) + ("ghc-mtl" ,ghc-mtl) + ("ghc-smallcheck" ,ghc-smallcheck) + ("ghc-tasty" ,ghc-tasty) + ("ghc-happy" ,ghc-happy) + ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck) + ("ghc-tasty-golden" ,ghc-tasty-golden) + ("ghc-syb" ,ghc-syb))) + (home-page "https://github.com/haskell-suite/haskell-src-exts") + (synopsis "Library for manipulating Haskell source") + (description "Haskell-Source with Extensions (HSE, haskell-src-exts) is an +extension of the standard @code{haskell-src} package, and handles most +registered syntactic extensions to Haskell. All extensions implemented in GHC +are supported. Apart from these standard extensions, it also handles regular +patterns as per the HaRP extension as well as HSX-style embedded XML syntax.") + (license bsd-3))) + +(define-public hlint + (package + (name "hlint") + (version "1.9.21") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/" name + "/" name "-" version ".tar.gz")) + (sha256 + (base32 + "14v3rdjjlml9nimdk7d5dvir2bw78ai49yylvms9lnzmw29s3546")))) + (build-system haskell-build-system) + (inputs + `(("cpphs" ,cpphs) + ("ghc-cmdargs" ,ghc-cmdargs) + ("ghc-haskell-src-exts" ,ghc-haskell-src-exts) + ("ghc-uniplate" ,ghc-uniplate) + ("ghc-ansi-terminal" ,ghc-ansi-terminal) + ("ghc-extra" ,ghc-extra) + ("hscolour" ,hscolour))) + (home-page "http://community.haskell.org/~ndm/hlint/") + (synopsis "Suggest improvements for Haskell source code") + (description "HLint reads Haskell programs and suggests changes that +hopefully make them easier to read. HLint also makes it easy to disable +unwanted suggestions, and to add your own custom suggestions.") + (license bsd-3))) + +(define-public ghc-resourcet + (package + (name "ghc-resourcet") + (version "1.1.6") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/resourcet/resourcet-" + version + ".tar.gz")) + (sha256 + (base32 + "0zhsaaa4n8ry76vjih519a8npm2hrzk10d5asrgllcwpzmifl41y")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-transformers-base" ,ghc-transformers-base) + ("ghc-monad-control" ,ghc-monad-control) + ("ghc-transformers-compat" ,ghc-transformers-compat) + ("ghc-mtl" ,ghc-mtl) + ("ghc-mmorph" ,ghc-mmorph) + ("ghc-exceptions" ,ghc-exceptions))) + (inputs + `(("ghc-lifted-base" ,ghc-lifted-base) + ("ghc-hspec" ,ghc-hspec))) + (home-page "http://github.com/snoyberg/conduit") + (synopsis "Deterministic allocation and freeing of scarce resources") + (description "ResourceT is a monad transformer which creates a region of +code where you can safely allocate resources.") + (license bsd-3))) + +(define-public ghc-xss-sanitize + (package + (name "ghc-xss-sanitize") + (version "0.3.5.6") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/xss-sanitize/xss-sanitize-" + version + ".tar.gz")) + (sha256 + (base32 + "1j2qrn2dbfx01m7zyk9ilgnp9zjwq9mk62b0rdal4zkg4vh212h0")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-tagsoup" ,ghc-tagsoup) + ("ghc-utf8-string" ,ghc-utf8-string) + ("ghc-css-text" ,ghc-css-text) + ("ghc-network-uri" ,ghc-network-uri))) + (inputs + `(("ghc-text" ,ghc-text) + ("ghc-attoparsec" ,ghc-attoparsec) + ("ghc-hspec" ,ghc-hspec) + ("ghc-hunit" ,ghc-hunit))) + (home-page "http://github.com/yesodweb/haskell-xss-sanitize") + (synopsis "Sanitize untrusted HTML to prevent XSS attacks") + (description "This library provides @code{sanitizeXSS}. Run untrusted +HTML through @code{Text.HTML.SanitizeXSS.sanitizeXSS} to prevent XSS +attacks.") + (license bsd-3))) + +(define-public ghc-objectname + (package + (name "ghc-objectname") + (version "1.1.0.0") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/ObjectName/ObjectName-" + version + ".tar.gz")) + (sha256 + (base32 + "0kh5fb9ykag6rfsm3f0bx3w323s18w2cyry34w5xgli5ncqimadg")))) + (build-system haskell-build-system) + (home-page "https://hackage.haskell.org/package/ObjectName") + (synopsis "Helper library for Haskell OpenGL") + (description "This tiny package contains the class ObjectName, which +corresponds to the general notion of explicitly handled identifiers for API +objects, e.g. a texture object name in OpenGL or a buffer object name in +OpenAL.") + (license bsd-3))) + +(define-public ghc-sdl + (package + (name "ghc-sdl") + (version "0.6.5.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/SDL/SDL-" + version + ".tar.gz")) + (sha256 + (base32 + "1sa3zx3vrs1gbinxx33zwq0x2bsf3i964bff7419p7vzidn36k46")))) + (build-system haskell-build-system) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-after + 'unpack 'fix-/bin/sh + (lambda _ + ;; Use `sh', not `/bin/sh'. + (setenv "CONFIG_SHELL" "sh")))))) + (inputs + `(("sdl" ,sdl))) + (home-page "https://hackage.haskell.org/package/SDL") + (synopsis "LibSDL for Haskell") + (description "Simple DirectMedia Layer (libSDL) is a cross-platform +multimedia library designed to provide low level access to audio, keyboard, +mouse, joystick, 3D hardware via OpenGL, and 2D video framebuffer. It is used +by MPEG playback software, emulators, and many popular games, including the +award winning Linux port of \"Civilization: Call To Power.\"") + (license bsd-3))) + +(define-public ghc-sdl-mixer + (package + (name "ghc-sdl-mixer") + (version "0.6.1.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/SDL-mixer/SDL-mixer-" + version + ".tar.gz")) + (sha256 + (base32 + "0md3238hx79mxb9a7l43kg3b3d28x4mqvj0hjsbsh15ajnvy9x2z")))) + (build-system haskell-build-system) + (arguments + `(#:configure-flags + (let* ((sdl-mixer (assoc-ref %build-inputs "sdl-mixer")) + (sdl-mixer-include (string-append sdl-mixer "/include/SDL"))) + (list (string-append "--extra-include-dirs=" sdl-mixer-include))) + #:phases + (modify-phases %standard-phases + (add-after + 'unpack 'fix-/bin/sh + (lambda _ + ;; Use `sh', not `/bin/sh'. + (setenv "CONFIG_SHELL" "sh")))))) + (propagated-inputs + `(("ghc-sdl" ,ghc-sdl))) + (inputs + `(("sdl-mixer" ,sdl-mixer))) + (home-page "http://hackage.haskell.org/package/SDL-mixer") + (synopsis "Haskell bindings to libSDL_mixer") + (description "SDL_mixer is a sample multi-channel audio mixer library. It +supports any number of simultaneously playing channels of 16 bit stereo audio, +plus a single channel of music, mixed by the popular MikMod MOD, Timidity +MIDI, Ogg Vorbis, and SMPEG MP3 libraries.") + (license bsd-3))) + +(define-public ghc-sdl-image + (package + (name "ghc-sdl-image") + (version "0.6.1.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/SDL-image/SDL-image-" + version + ".tar.gz")) + (sha256 + (base32 + "1m02q2426qp8m8pzz2jkk4srk2vb3j3ickiaga5jx9rkkhz732zq")))) + (build-system haskell-build-system) + (arguments + `(#:configure-flags + (let* ((sdl-image (assoc-ref %build-inputs "sdl-image")) + (sdl-image-include (string-append sdl-image "/include/SDL"))) + (list (string-append "--extra-include-dirs=" sdl-image-include))) + #:phases + (modify-phases %standard-phases + (add-after + 'unpack 'fix-/bin/sh + (lambda _ + ;; Use `sh', not `/bin/sh'. + (setenv "CONFIG_SHELL" "sh")))))) + (propagated-inputs + `(("ghc-sdl" ,ghc-sdl))) + (inputs + `(("sdl-image" ,sdl-image))) + (home-page "http://hackage.haskell.org/package/SDL-image") + (synopsis "Haskell bindings to libSDL_image") + (description "SDL_image is an image file loading library. It loads images +as SDL surfaces, and supports the following formats: BMP, GIF, JPEG, LBM, PCX, +PNG, PNM, TGA, TIFF, XCF, XPM, XV.") + (license bsd-3))) + +(define-public ghc-half + (package + (name "ghc-half") + (version "0.2.2.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/half/half-" + version + ".tar.gz")) + (sha256 + (base32 + "0zhwc6ps5w4ccnxl8sy623z4rjsafmnry69jpkw4hrbq11l402f1")))) + (build-system haskell-build-system) + (home-page "http://github.com/ekmett/half") + (synopsis "Half-precision floating-point computations") + (description "This library provides a half-precision floating-point +computation library for Haskell.") + (license bsd-3))) + +(define-public ghc-openglraw + (package + (name "ghc-openglraw") + (version "2.5.1.0") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/OpenGLRaw/OpenGLRaw-" + version + ".tar.gz")) + (sha256 + (base32 + "1kfq24mxg922ml3kkmym2qfpc56jbmrfbiix4rc2cxlwv05i191k")))) + (build-system haskell-build-system) + (inputs + `(("ghc-half" ,ghc-half) + ("glu" ,glu) + ("ghc-text" ,ghc-text))) + (home-page "http://www.haskell.org/haskellwiki/Opengl") + (synopsis "Raw Haskell bindings for the OpenGL graphics system") + (description "OpenGLRaw is a raw Haskell binding for the OpenGL 4.5 +graphics system and lots of OpenGL extensions. It is basically a 1:1 mapping +of OpenGL's C API, intended as a basis for a nicer interface. OpenGLRaw +offers access to all necessary functions, tokens and types plus a general +facility for loading extension entries. The module hierarchy closely mirrors +the naming structure of the OpenGL extensions, making it easy to find the +right module to import. All API entries are loaded dynamically, so no special +C header files are needed for building this package. If an API entry is not +found at runtime, a userError is thrown.") + (license bsd-3))) + +(define-public ghc-glut + (package + (name "ghc-glut") + (version "2.7.0.3") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/GLUT/GLUT-" + version + ".tar.gz")) + (sha256 + (base32 + "1qfilpc10jm47anan44c20y8mh76f2dv09m5d22gk0f7am7hg4k2")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-statevar" ,ghc-statevar) + ("ghc-openglraw" ,ghc-openglraw))) + (inputs + `(("ghc-opengl" ,ghc-opengl) + ("freeglut" ,freeglut))) + (home-page "http://www.haskell.org/haskellwiki/Opengl") + (synopsis "Haskell bindings for the OpenGL Utility Toolkit") + (description "This library provides Haskell bindings for the OpenGL +Utility Toolkit, a window system-independent toolkit for writing OpenGL +programs.") + (license bsd-3))) + +(define-public ghc-gluraw + (package + (name "ghc-gluraw") + (version "1.5.0.2") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/GLURaw/GLURaw-" + version + ".tar.gz")) + (sha256 + (base32 + "0gscd9lhp9mb10q8s716nx26m8qng9xbb4h6b3f48zzgkc1sy96x")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-openglraw" ,ghc-openglraw))) + (home-page "http://www.haskell.org/haskellwiki/Opengl") + (synopsis "Raw Haskell bindings GLU") + (description "GLURaw is a raw Haskell binding for the GLU 1.3 OpenGL +utility library. It is basically a 1:1 mapping of GLU's C API, intended as a +basis for a nicer interface.") + (license bsd-3))) + +(define-public ghc-opengl + (package + (name "ghc-opengl") + (version "2.12.0.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/OpenGL/OpenGL-" + version + ".tar.gz")) + (sha256 + (base32 + "1mcfb167jl75qc2hgylh83vf2jqizvyvkvhhb72adi2crc3zqz4b")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-text" ,ghc-text) + ("ghc-objectname" ,ghc-objectname) + ("ghc-gluraw" ,ghc-gluraw) + ("ghc-statevar" ,ghc-statevar) + ("ghc-openglraw" ,ghc-openglraw))) + (home-page "http://www.haskell.org/haskellwiki/Opengl") + (synopsis "Haskell bindings for the OpenGL graphics system") + (description "This package provides Haskell bindings for the OpenGL +graphics system (GL, version 4.5) and its accompanying utility library (GLU, +version 1.3).") + (license bsd-3))) + +(define-public ghc-streaming-commons + (package + (name "ghc-streaming-commons") + (version "0.1.14.2") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/streaming-commons/streaming-commons-" + version + ".tar.gz")) + (sha256 + (base32 + "12nw9bwvy6zrabkgvbp371klca3ds6qjlfncg1b8pbwx1y7m8c8h")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-random" ,ghc-random))) + (inputs + `(("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-async" ,ghc-async) + ("ghc-blaze-builder" ,ghc-blaze-builder) + ("ghc-hspec" ,ghc-hspec) + ("ghc-stm" ,ghc-stm) + ("ghc-text" ,ghc-text) + ("ghc-network" ,ghc-network) + ("ghc-zlib" ,ghc-zlib))) + (home-page "https://hackage.haskell.org/package/streaming-commons") + (synopsis "Conduit and pipes needed by some streaming data libraries") + (description "Provides low-dependency functionality commonly needed by +various Haskell streaming data libraries, such as @code{conduit} and +@code{pipe}s.") + (license bsd-3))) + +(define-public cpphs + (package + (name "cpphs") + (version "1.19.3") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/" name "/" + name "-" version ".tar.gz")) + (sha256 + (base32 + "1njpmxgpah5pcqppcl1cxb5xicf6xlqrd162qm12khp9hainlm72")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-polyparse" ,ghc-polyparse) + ("ghc-old-locale" ,ghc-old-locale) + ("ghc-old-time" ,ghc-old-time))) + (home-page "http://projects.haskell.org/cpphs/") + (synopsis "Liberalised re-implementation of cpp, the C pre-processor") + (description "Cpphs is a re-implementation of the C pre-processor that is +both more compatible with Haskell, and itself written in Haskell so that it +can be distributed with compilers. This version of the C pre-processor is +pretty-much feature-complete and compatible with traditional (K&R) +pre-processors. Additional features include: a plain-text mode; an option to +unlit literate code files; and an option to turn off macro-expansion.") + (license (list lgpl2.1+ gpl3+)))) + +(define-public ghc-reflection + (package + (name "ghc-reflection") + (version "2.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/reflection/reflection-" + version + ".tar.gz")) + (sha256 + (base32 + "10w3m6v3g6am203wbrikdbp57x9vw6b4jsh7bxdzsss4nmpm81zg")))) + (build-system haskell-build-system) + (inputs `(("ghc-tagged" ,ghc-tagged))) + (home-page "http://github.com/ekmett/reflection") + (synopsis "Reify arbitrary terms into types that can be reflected back +into terms") + (description "This package addresses the 'configuration problem' which is +propogating configurations that are available at run-time, allowing multiple +configurations to coexist without resorting to mutable global variables or +@code{System.IO.Unsafe.unsafePerformIO}.") + (license bsd-3))) + +(define-public ghc-old-locale + (package + (name "ghc-old-locale") + (version "1.0.0.7") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/old-locale/old-locale-" + version + ".tar.gz")) + (sha256 + (base32 "0l3viphiszvz5wqzg7a45zp40grwlab941q5ay29iyw8p3v8pbyv")))) + (build-system haskell-build-system) + (home-page "http://hackage.haskell.org/package/old-locale") + (synopsis "Adapt to locale conventions") + (description + "This package provides the ability to adapt to locale conventions such as +date and time formats.") + (license bsd-3))) + +(define-public ghc-old-time + (package + (name "ghc-old-time") + (version "1.1.0.3") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/old-time/old-time-" + version + ".tar.gz")) + (sha256 + (base32 + "1h9b26s3kfh2k0ih4383w90ibji6n0iwamxp6rfp2lbq1y5ibjqw")))) + (build-system haskell-build-system) + (arguments + `(#:phases + (modify-phases %standard-phases + (add-after 'unpack 'fix-/bin/sh + (lambda _ + (setenv "CONFIG_SHELL" "sh")))))) + (propagated-inputs + `(("ghc-old-locale" ,ghc-old-locale))) + (home-page "http://hackage.haskell.org/package/old-time") + (synopsis "Time compatibility library for Haskell") + (description "Old-time is a package for backwards compatibility with the +old @code{time} library. For new projects, the newer +@uref{http://hackage.haskell.org/package/time, time library} is recommended.") + (license bsd-3))) + (define-public ghc-data-default-instances-old-locale (package (name "ghc-data-default-instances-old-locale") @@ -376,7 +1246,8 @@ package.") (base32 "00h81i5phib741yj517p8mbnc48myvfj8axzsw44k34m48lv1lv0")))) (build-system haskell-build-system) (propagated-inputs - `(("ghc-data-default-class" ,ghc-data-default-class))) + `(("ghc-data-default-class" ,ghc-data-default-class) + ("ghc-old-locale" ,ghc-old-locale))) (home-page "http://hackage.haskell.org/package/data-default-instances-old-locale") (synopsis "Default instances for types in old-locale") @@ -387,7 +1258,7 @@ package.") (define-public ghc-dlist (package (name "ghc-dlist") - (version "0.7.1.1") + (version "0.7.1.2") (source (origin (method url-fetch) @@ -396,9 +1267,10 @@ package.") version ".tar.gz")) (sha256 - (base32 "1zayvxvkan2s2ixajdr3f5rn1gzhprzv6cww4cbpwjhzw0l7zc08")))) - (arguments `(#:tests? #f)) + (base32 "10rp96rryij7d8gz5kv8ygc6chm1624ck5mbnqs2a3fkdzqj2b9k")))) (build-system haskell-build-system) + (inputs + `(("ghc-quickcheck" ,ghc-quickcheck))) (home-page "https://github.com/spl/dlist") (synopsis "Difference lists") (description @@ -430,7 +1302,7 @@ versions of GHC (i.e., < 6.10).") (define-public cabal-install (package (name "cabal-install") - (version "1.18.1.0") + (version "1.22.6.0") (source (origin (method url-fetch) @@ -439,7 +1311,7 @@ versions of GHC (i.e., < 6.10).") version ".tar.gz")) (sha256 - (base32 "1r1shhvnpgxf91rmbv3wa1rkd24plbgr6bpz3aj80ir0z3zbdayn")))) + (base32 "1d5h7h2wjwc2s3dvsvzjgmmfrfl2312ym2h6kyjgm9wnaqw9w8wx")))) (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing. (build-system haskell-build-system) (propagated-inputs @@ -461,7 +1333,7 @@ installation of Haskell libraries and programs.") (define-public ghc-mtl (package (name "ghc-mtl") - (version "2.1.3.1") + (version "2.2.1") (outputs '("out" "doc")) (source (origin @@ -472,18 +1344,17 @@ installation of Haskell libraries and programs.") ".tar.gz")) (sha256 (base32 - "1xpn2wjmqbh2cg1yssc6749xpgcqlrrg4iilwqgkcjgvaxlpdbvp")))) + "1icdbj2rshzn0m1zz5wa7v3xvkf6qw811p4s7jgqwvx1ydwrvrfa")))) (build-system haskell-build-system) (home-page "http://github.com/ekmett/mtl") (synopsis "Monad classes, using functional dependencies") - (description - "Monad classes using functional dependencies, with instances -for various monad transformers, inspired by the paper -'Functional Programming with Overloading and Higher-Order Polymorphism', -by Mark P Jones, in 'Advanced School of Functional Programming', 1995 -http://web.cecs.pdx.edu/~mpj/pubs/springschool.html.") - (license bsd-3))) + (description "Monad classes using functional dependencies, with instances +for various monad transformers, inspired by the paper 'Functional Programming +with Overloading and Higher-Order Polymorphism', by Mark P Jones, in 'Advanced +School of Functional Programming', 1995. See +@uref{http://web.cecs.pdx.edu/~mpj/pubs/springschool.html, the paper}.") + (license bsd-3))) (define-public ghc-paths (package @@ -511,7 +1382,7 @@ http://web.cecs.pdx.edu/~mpj/pubs/springschool.html.") (define-public ghc-utf8-string (package (name "ghc-utf8-string") - (version "0.3.8") + (version "1.0.1.1") (source (origin (method url-fetch) @@ -520,16 +1391,37 @@ http://web.cecs.pdx.edu/~mpj/pubs/springschool.html.") version ".tar.gz")) (sha256 - (base32 "1h29dn0scsfkhmkg14ywq9178lw40ah1r36w249zfzqr02y7qxc0")))) + (base32 "0h7imvxkahiy8pzr8cpsimifdfvv18lizrb33k6mnq70rcx9w2zv")))) (build-system haskell-build-system) (home-page "http://github.com/glguy/utf8-string/") (synopsis "Support for reading and writing UTF8 Strings") (description - "A UTF8 layer for Strings. The utf8-string package provides operations + "A UTF8 layer for Strings. The utf8-string package provides operations for encoding UTF8 strings to Word8 lists and back, and for reading and writing UTF8 without truncation.") (license bsd-3))) +(define-public ghc-setenv + (package + (name "ghc-setenv") + (version "0.1.1.3") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/setenv/setenv-" + version + ".tar.gz")) + (sha256 + (base32 + "0cnbgrvb9byyahb37zlqrj05rj25v190crgcw8wmlgf0mwwxyn73")))) + (build-system haskell-build-system) + (home-page "http://hackage.haskell.org/package/setenv") + (synopsis "Library for setting environment variables") + (description "This package provides a Haskell library for setting +environment variables.") + (license expat))) + (define-public ghc-x11 (package (name "ghc-x11") @@ -590,6 +1482,29 @@ bindings are a direct translation of the C bindings.") parts.") (license lgpl2.1))) +(define-public ghc-stringbuilder + (package + (name "ghc-stringbuilder") + (version "0.5.0") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/stringbuilder/stringbuilder-" + version + ".tar.gz")) + (sha256 + (base32 + "1ap95xphqnrhv64c2a137wqslkdmb2jjd9ldb17gs1pw48k8hrl9")))) + (build-system haskell-build-system) + (arguments `(#:tests? #f)) ; FIXME: circular dependencies with tests + ; enabled + (home-page "http://hackage.haskell.org/package/stringbuilder") + (synopsis "Writer monad for multi-line string literals") + (description "This package provides a writer monad for multi-line string +literals.") + (license expat))) + (define-public ghc-zlib (package (name "ghc-zlib") @@ -666,7 +1581,7 @@ access to the full zlib feature set.") (define-public ghc-text (package (name "ghc-text") - (version "1.2.0.4") + (version "1.2.1.3") (outputs '("out" "doc")) (source (origin @@ -677,7 +1592,7 @@ access to the full zlib feature set.") ".tar.gz")) (sha256 (base32 - "004p1c74crs8wmjafwsmw3mmycspq1j8fpm1lvfpq6acha7bnpc6")))) + "0gzqx5cpkdhshbz9xss51mpyq23pnf8dwjz4h3irbv2ryaa4qdlq")))) (build-system haskell-build-system) (arguments `(#:tests? #f)) ; FIXME: currently missing libraries used for tests. @@ -696,7 +1611,7 @@ in terms of large data quantities and high speed.") (define-public ghc-hashable (package (name "ghc-hashable") - (version "1.2.3.2") + (version "1.2.3.3") (outputs '("out" "doc")) (source (origin @@ -707,7 +1622,7 @@ in terms of large data quantities and high speed.") ".tar.gz")) (sha256 (base32 - "0h9295pv2sgbaqlwpwbx2bap6nngm0jcdhkqham1wpjwyxqgqrlc")))) + "0kp4aj0x1iicz9qirpqxxqd8x5g1njbapxk1d90n406w3xykz4pw")))) (build-system haskell-build-system) (arguments `(#:tests? #f)) ; FIXME: currently missing libraries used for tests. @@ -771,7 +1686,7 @@ library, including the ability to split random number generators.") (define-public ghc-primitive (package (name "ghc-primitive") - (version "0.5.4.0") + (version "0.6.1.0") (outputs '("out" "doc")) (source (origin @@ -782,7 +1697,7 @@ library, including the ability to split random number generators.") ".tar.gz")) (sha256 (base32 - "05gdgj383xdrdkhxh26imlvs8ji0z28ny38ms9snpvv5i8l2lg10")))) + "1j1q7l21rdm8kfs93vibr3xwkkhqis181w2k6klfhx5g5skiywwk")))) (build-system haskell-build-system) (home-page "https://github.com/haskell/primitive") @@ -819,10 +1734,1048 @@ the paper \"Splittable Pseudorandom Number Generators Using Cryptographic Hashing\" by Claessen, Pałka for details and the rationale of the design.") (license bsd-3))) +(define-public ghc-transformers-base + (package + (name "ghc-transformers-base") + (version "0.4.4") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/transformers-base/transformers-base-" + version + ".tar.gz")) + (sha256 + (base32 + "11r3slgpgpra6zi2kjg3g60gvv17b1fh6qxipcpk8n86qx7lk8va")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-stm" ,ghc-stm))) + (inputs + `(("ghc-transformers-compat" ,ghc-transformers-compat))) + (home-page + "http://hackage.haskell.org/package/transformers-compat") + (synopsis + "Backported transformer library") + (description + "Backported versions of types that were added to transformers in +transformers 0.3 and 0.4 for users who need strict transformers 0.2 or 0.3 +compatibility to run on old versions of the platform.") + (license bsd-3))) + +(define-public ghc-transformers-compat + (package + (name "ghc-transformers-compat") + (version "0.4.0.4") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/transformers-compat" + "/transformers-compat-" version ".tar.gz")) + (sha256 + (base32 + "0lmg8ry6bgigb0v2lg0n74lxi8z5m85qq0qi4h1k9llyjb4in8ym")))) + (build-system haskell-build-system) + (home-page "http://github.com/ekmett/transformers-compat/") + (synopsis "Small compatibility shim between transformers 0.3 and 0.4") + (description "This package includes backported versions of types that were +added to transformers in transformers 0.3 and 0.4 for users who need strict +transformers 0.2 or 0.3 compatibility to run on old versions of the platform, +but also need those types.") + (license bsd-3))) + +(define-public ghc-unix-time + (package + (name "ghc-unix-time") + (version "0.3.6") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/unix-time/unix-time-" + version + ".tar.gz")) + (sha256 + (base32 + "0dyvyxwaffb94bgri1wc4b9wqaasy32pyjn0lww3dqblxv8fn5ax")))) + (build-system haskell-build-system) + (arguments + `(#:tests? #f ; FIXME: Test fails with "System.Time not found". This is + ; weird, that should be provided by GHC 7.10.2. + #:phases + (modify-phases %standard-phases + (add-after 'unpack 'fix-/bin/sh + (lambda _ + (setenv "CONFIG_SHELL" "sh")))))) + (propagated-inputs + `(("ghc-old-time" ,ghc-old-time) + ("ghc-old-locale" ,ghc-old-locale))) + (home-page "http://hackage.haskell.org/package/unix-time") + (synopsis "Unix time parser/formatter and utilities") + (description "This library provides fast parsing and formatting utilities +for Unix time in Haskell.") + (license bsd-3))) + +(define-public ghc-unix-compat + (package + (name "ghc-unix-compat") + (version "0.4.1.4") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/unix-compat/unix-compat-" + version + ".tar.gz")) + (sha256 + (base32 + "0jxk7j5pz2kgfpqr4hznndjg31pqj5xg2qfc5308fcn9xyg1myps")))) + (build-system haskell-build-system) + (home-page + "http://github.com/jystic/unix-compat") + (synopsis "Portable POSIX-compatibility layer") + (description + "This package provides portable implementations of parts of the unix +package. This package re-exports the unix package when available. When it +isn't available, portable implementations are used.") + (license bsd-3))) + +(define-public ghc-http-types + (package + (name "ghc-http-types") + (version "0.9") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/http-types/http-types-" + version + ".tar.gz")) + (sha256 + (base32 + "0ny15jgm5skhs2yx6snr13lrnw19hwjgfygrpsmhib8wqa8cz8cc")))) + (build-system haskell-build-system) + (arguments `(#:tests? #f)) ; FIXME: Tests cannot find + ; Blaze.Bytestring.Builder, which should be + ; provided by ghc-blaze-builder. + (propagated-inputs + `(("ghc-case-insensitive" ,ghc-case-insensitive) + ("ghc-blaze-builder" ,ghc-blaze-builder))) + (inputs + `(("ghc-text" ,ghc-text))) + (home-page "https://github.com/aristidb/http-types") + (synopsis "Generic HTTP types for Haskell") + (description "This package provides generic HTTP types for Haskell (for +both client and server code).") + (license bsd-3))) + +(define-public ghc-iproute + (package + (name "ghc-iproute") + (version "1.7.0") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/iproute/iproute-" + version + ".tar.gz")) + (sha256 + (base32 + "1ply0i110c2sppjbfyysgw48jfjnsbam5zwil8xws0hp20rh1pb5")))) + (build-system haskell-build-system) + (arguments `(#:tests? #f)) ; FIXME: Tests cannot find System.ByteOrder, + ; exported by ghc-byteorder. Doctest issue. + (propagated-inputs + `(("ghc-appar" ,ghc-appar) + ("ghc-byteorder" ,ghc-byteorder))) + (inputs + `(("ghc-network" ,ghc-network) + ("ghc-safe" ,ghc-safe))) + (home-page "http://www.mew.org/~kazu/proj/iproute/") + (synopsis "IP routing table") + (description "IP Routing Table is a tree of IP ranges to search one of +them on the longest match base. It is a kind of TRIE with one way branching +removed. Both IPv4 and IPv6 are supported.") + (license bsd-3))) + +(define-public ghc-regex-base + (package + (name "ghc-regex-base") + (version "0.93.2") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/regex-base/regex-base-" + version + ".tar.gz")) + (sha256 + (base32 + "0y1j4h2pg12c853nzmczs263di7xkkmlnsq5dlp5wgbgl49mgp10")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-mtl" ,ghc-mtl))) + (home-page + "http://sourceforge.net/projects/lazy-regex") + (synopsis "Replaces/Enhances Text.Regex") + (description "@code{Text.Regex.Base} provides the interface API for +regex-posix, regex-pcre, regex-parsec, regex-tdfa, regex-dfa.") + (license bsd-3))) + +(define-public ghc-regex-posix + (package + (name "ghc-regex-posix") + (version "0.95.2") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/regex-posix/regex-posix-" + version + ".tar.gz")) + (sha256 + (base32 + "0gkhzhj8nvfn1ija31c7xnl6p0gadwii9ihyp219ck2arlhrj0an")))) + (build-system haskell-build-system) + (inputs `(("ghc-regex-base" ,ghc-regex-base))) + (home-page "http://sourceforge.net/projects/lazy-regex") + (synopsis "POSIX regular expressions for Haskell") + (description "This library provides the POSIX regex backend used by the +Haskell library @code{regex-base}.") + (license bsd-3))) + +(define-public ghc-regex-compat + (package + (name "ghc-regex-compat") + (version "0.95.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/regex-compat/regex-compat-" + version + ".tar.gz")) + (sha256 + (base32 + "0fwmima3f04p9y4h3c23493n1xj629ia2dxaisqm6rynljjv2z6m")))) + (build-system haskell-build-system) + (inputs + `(("ghc-regex-base" ,ghc-regex-base) + ("ghc-regex-posix" ,ghc-regex-posix))) + (home-page "http://sourceforge.net/projects/lazy-regex") + (synopsis "Replaces/Enhances Text.Regex") + (description "This library provides one module layer over +@code{regex-posix} to replace @code{Text.Regex}.") + (license bsd-3))) + +(define-public ghc-regex-tdfa-rc + (package + (name "ghc-regex-tdfa-rc") + (version "1.1.8.3") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/regex-tdfa-rc/regex-tdfa-rc-" + version + ".tar.gz")) + (sha256 + (base32 + "1vi11i23gkkjg6193ak90g55akj69bhahy542frkwb68haky4pp3")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-regex-base" ,ghc-regex-base) + ("ghc-parsec" ,ghc-parsec))) + (inputs + `(("ghc-mtl" ,ghc-mtl))) + (home-page + "http://hackage.haskell.org/package/regex-tdfa") + (synopsis "Tagged DFA regex engine for Haskell") + (description "A new all-Haskell \"tagged\" DFA regex engine, inspired by +@code{libtre} (fork by Roman Cheplyaka).") + (license bsd-3))) + +(define-public ghc-parsers + (package + (name "ghc-parsers") + (version "0.12.3") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/parsers/parsers-" + version + ".tar.gz")) + (sha256 + (base32 + "18wzmp8y3py4qa8hdsxqm0jfzmwy744dw7xa48r5s8ynhpimi462")))) + (build-system haskell-build-system) + (arguments `(#:tests? #f)) ; FIXME: Test fails with "cannot satisfy + ; -package attoparsec-0.13.0.1" + (propagated-inputs + `(("ghc-base-orphans" ,ghc-base-orphans) + ("ghc-attoparsec" ,ghc-attoparsec) + ("ghc-parsec" ,ghc-parsec) + ("ghc-scientific" ,ghc-scientific) + ("ghc-charset" ,ghc-charset))) + (inputs + `(("ghc-text" ,ghc-text) + ("ghc-unordered-containers" ,ghc-unordered-containers))) + (home-page "http://github.com/ekmett/parsers/") + (synopsis "Parsing combinators") + (description "This library provides convenient combinators for working +with and building parsing combinator libraries. Given a few simple instances, +you get access to a large number of canned definitions. Instances exist for +the parsers provided by @code{parsec}, @code{attoparsec} and @code{base}'s +@code{Text.Read}.") + (license bsd-3))) + +(define-public ghc-trifecta + (package + (name "ghc-trifecta") + (version "1.5.2") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/trifecta/trifecta-" + version + ".tar.gz")) + (sha256 + (base32 + "0fjhnsbafl3yw34pyhcsvrqy6a2mnhyqys6gna3rrlygs8ck7hpb")))) + (build-system haskell-build-system) + (arguments `(#:tests? #f)) ; FIXME: Test fails with "cannot satisfy + ; -package ansi-terminal-0.6.2.3" + (propagated-inputs + `(("ghc-charset" ,ghc-charset) + ("ghc-comonad" ,ghc-comonad) + ("ghc-lens" ,ghc-lens) + ("ghc-profunctors" ,ghc-profunctors) + ("ghc-reducers" ,ghc-reducers) + ("ghc-semigroups" ,ghc-semigroups))) + (inputs + `(("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint) + ("ghc-ansi-terminal" ,ghc-ansi-terminal) + ("ghc-blaze-builder" ,ghc-blaze-builder) + ("ghc-blaze-html" ,ghc-blaze-html) + ("ghc-blaze-markup" ,ghc-blaze-markup) + ("ghc-fingertree" ,ghc-fingertree) + ("ghc-hashable" ,ghc-hashable) + ("ghc-mtl" ,ghc-mtl) + ("ghc-parsers" ,ghc-parsers) + ("ghc-unordered-containers" ,ghc-unordered-containers) + ("ghc-utf8-string" ,ghc-utf8-string))) + (home-page "http://github.com/ekmett/trifecta/") + (synopsis "Parser combinator library with convenient diagnostics") + (description "Trifecta is a modern parser combinator library for Haskell, +with slicing and Clang-style colored diagnostics.") + (license bsd-3))) + +(define-public ghc-attoparsec + (package + (name "ghc-attoparsec") + (version "0.13.0.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/attoparsec/attoparsec-" + version + ".tar.gz")) + (sha256 + (base32 + "0cprkr7bl4lrr80pz8mryb4rbfwdgpsrl7g0fbcaybhl8p5hm26f")))) + (build-system haskell-build-system) + (arguments `(#:tests? #f)) ; FIXME: ghc-test-framework unavailable + (propagated-inputs + `(("ghc-scientific" ,ghc-scientific))) + (inputs + `(("ghc-text" ,ghc-text) + ("ghc-vector" ,ghc-vector))) + (home-page "https://github.com/bos/attoparsec") + (synopsis "Fast combinator parsing for bytestrings and text") + (description "This library provides a fast parser combinator library, +aimed particularly at dealing efficiently with network protocols and +complicated text/binary file formats.") + (license bsd-3))) + +(define-public ghc-css-text + (package + (name "ghc-css-text") + (version "0.1.2.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/css-text/css-text-" + version + ".tar.gz")) + (sha256 + (base32 + "1xi1n2f0g8y43p95lynhcg50wxbq7hqfzbfzm7fy8mn7gvd920nw")))) + (build-system haskell-build-system) + (inputs + `(("ghc-text" ,ghc-text) + ("ghc-attoparsec" ,ghc-attoparsec) + ("ghc-hspec" ,ghc-hspec) + ("ghc-quickcheck" ,ghc-quickcheck))) + (home-page "http://www.yesodweb.com/") + (synopsis "CSS parser and renderer") + (description "This package provides a CSS parser and renderer for +Haskell.") + (license bsd-3))) + +(define-public ghc-zip-archive + (package + (name "ghc-zip-archive") + (version "0.2.3.7") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/zip-archive/zip-archive-" + version + ".tar.gz")) + (sha256 + (base32 + "169nkxr5zlbymiz1ydlhlqr66vqiycmg85xh559phpkr64w3nqj1")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-old-time" ,ghc-old-time) + ("ghc-digest" ,ghc-digest))) + (inputs + `(("ghc-hunit" ,ghc-hunit) + ("ghc-mtl" ,ghc-mtl) + ("zip" ,zip) + ("ghc-text" ,ghc-text) + ("ghc-zlib" ,ghc-zlib))) + (home-page "https://hackage.haskell.org/package/zip-archive") + (synopsis "Zip archive library for Haskell") + (description "The zip-archive library provides functions for creating, +modifying, and extracting files from zip archives in Haskell.") + (license bsd-3))) + +(define-public ghc-distributive + (package + (name "ghc-distributive") + (version "0.4.4") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/distributive/distributive-" + version + ".tar.gz")) + (sha256 + (base32 + "0s2ln9jv7bh4ri2y31178pvjl8x6nik5d0klx7j2b77yjlsgblc2")))) + (build-system haskell-build-system) + (arguments `(#:tests? #f)) ; FIXME: fails with "cannot satisfy -package + ; tagged-0.8.1". Suspected Cabal issue. + (propagated-inputs + `(("ghc-tagged" ,ghc-tagged) + ("ghc-transformers-compat" ,ghc-transformers-compat))) + (home-page "http://github.com/ekmett/distributive/") + (synopsis "Distributive functors for Haskell") + (description "This package provides distributive functors for Haskell. +Dual to @code{Traversable}.") + (license bsd-3))) + +(define-public ghc-cereal + (package + (name "ghc-cereal") + (version "0.4.1.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/cereal/cereal-" + version + ".tar.gz")) + (sha256 + (base32 + "15rhfn9hrjm01ksh9xpz9syxsp9vkvpp6b736iqq38wv2wb7416z")))) + (build-system haskell-build-system) + (home-page "http://hackage.haskell.org/package/cereal") + (synopsis "Binary serialization library") + (description "This package provides a binary serialization library, +similar to @code{binary}, that introduces an @code{isolate} primitive for +parser isolation, and labeled blocks for better error messages.") + (license bsd-3))) + +(define-public ghc-comonad + (package + (name "ghc-comonad") + (version "4.2.7.2") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/comonad/comonad-" + version + ".tar.gz")) + (sha256 + (base32 + "0arvbaxgkawzdp38hh53akkahjg2aa3kj2b4ns0ni8a5ylg2cqmp")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-distributive" ,ghc-distributive) + ("ghc-transformers-compat" ,ghc-transformers-compat) + ("ghc-contravariant" ,ghc-contravariant))) + (arguments `(#:tests? #f)) ; FIXME: Test fails with "cannot satisfy + ; -package contravariant-1.3.3" + (inputs + `(("ghc-semigroups" ,ghc-semigroups) + ("ghc-tagged" ,ghc-tagged) + ("ghc-contravariant" ,ghc-contravariant))) + (home-page "http://github.com/ekmett/comonad/") + (synopsis "Comonads for Haskell") + (description "This library provides @code{Comonad}s for Haskell.") + (license bsd-3))) + +(define-public hscolour + (package + (name "hscolour") + (version "1.23") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/hscolour/hscolour-" + version + ".tar.gz")) + (sha256 + (base32 + "1c4i2zpami8g3w9949nm3f92g7xwh5c94vkx658zz7ihrjp7w5lp")))) + (build-system haskell-build-system) + (home-page "https://hackage.haskell.org/package/hscolour") + (synopsis "Script to colourise Haskell code") + (description "HSColour is a small Haskell script to colourise Haskell +code. It currently has six output formats: ANSI terminal codes (optionally +XTerm-256colour codes), HTML 3.2 with font tags, HTML 4.01 with CSS, HTML 4.01 +with CSS and mouseover annotations, XHTML 1.0 with inline CSS styling, LaTeX, +and mIRC chat codes.") + (license bsd-3))) + +(define-public ghc-polyparse + (package + (name "ghc-polyparse") + (version "1.11") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/polyparse/polyparse-" + version + ".tar.gz")) + (sha256 + (base32 + "1z417f80b0jm4dgv25fk408p3d9mmcd1dlbya3ry0zdx4md09vrh")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-text" ,ghc-text))) + (home-page + "http://code.haskell.org/~malcolm/polyparse/") + (synopsis + "Alternative parser combinator libraries") + (description + "This package provides a variety of alternative parser combinator +libraries, including the original HuttonMeijer set. The Poly sets have +features like good error reporting, arbitrary token type, running state, lazy +parsing, and so on. Finally, Text.Parse is a proposed replacement for the +standard Read class, for better deserialisation of Haskell values from +Strings.") + (license lgpl2.1))) + +(define-public ghc-extra + (package + (name "ghc-extra") + (version "1.4.2") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/extra/extra-" + version + ".tar.gz")) + (sha256 + (base32 + "1h9hxkrqrqscx420yz1lmivbrhi6jc3a5ap61vkxd2mhdgark9hf")))) + (build-system haskell-build-system) + (inputs `(("ghc-quickcheck" ,ghc-quickcheck))) + (home-page "https://github.com/ndmitchell/extra") + (synopsis "Extra Haskell functions") + (description "This library provides extra functions for the standard +Haskell libraries. Most functions are simple additions, filling out missing +functionality. A few functions are available in later versions of GHC, but +this package makes them available back to GHC 7.2.") + (license bsd-3))) + +(define-public ghc-profunctors + (package + (name "ghc-profunctors") + (version "5.1.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/profunctors/profunctors-" + version + ".tar.gz")) + (sha256 + (base32 + "0lw2ipacpnp9yqmi8zsp01pzpn5hwj8af3y0f3079mddrmw48gw7")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-distributive" ,ghc-distributive))) + (inputs + `(("ghc-comonad" ,ghc-comonad) + ("ghc-tagged" ,ghc-tagged))) + (home-page "http://github.com/ekmett/profunctors/") + (synopsis "Profunctors for Haskell") + (description "This library provides profunctors for Haskell.") + (license bsd-3))) + +(define-public ghc-reducers + (package + (name "ghc-reducers") + (version "3.12.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/reducers/reducers-" + version + ".tar.gz")) + (sha256 + (base32 + "0pkddg0s3cn759miq0nfrq7lnp3imk5sx784ihsilsbjh9kvffz4")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-semigroupoids" ,ghc-semigroupoids))) + (inputs + `(("ghc-fingertree" ,ghc-fingertree) + ("ghc-hashable" ,ghc-hashable) + ("ghc-text" ,ghc-text) + ("ghc-unordered-containers" ,ghc-unordered-containers) + ("ghc-semigroups" ,ghc-semigroups))) + (home-page "http://github.com/ekmett/reducers/") + (synopsis "Semigroups, specialized containers and a general map/reduce framework") + (description "This library provides various semigroups, specialized +containers and a general map/reduce framework for Haskell.") + (license bsd-3))) + +(define-public ghc-appar + (package + (name "ghc-appar") + (version "0.1.4") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/appar/appar-" + version + ".tar.gz")) + (sha256 + (base32 + "09jb9ij78fdkz2qk66rw99q19qnm504dpv0yq0pjsl6xwjmndsjq")))) + (build-system haskell-build-system) + (home-page + "http://hackage.haskell.org/package/appar") + (synopsis "Simple applicative parser") + (description "This package provides a simple applicative parser in Parsec +style.") + (license bsd-3))) + +(define-public ghc-safe + (package + (name "ghc-safe") + (version "0.3.9") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/safe/safe-" + version + ".tar.gz")) + (sha256 + (base32 + "1jdnp5zhvalf1xy8i872n29nljfjz6lnl9ghj80ffisrnnkrwcfh")))) + (build-system haskell-build-system) + (home-page "https://github.com/ndmitchell/safe#readme") + (synopsis "Library of safe (exception free) functions") + (description "This library provides wrappers around @code{Prelude} and +@code{Data.List} functions, such as @code{head} and @code{!!}, that can throw +exceptions.") + (license bsd-3))) + +(define-public ghc-generic-deriving + (package + (name "ghc-generic-deriving") + (version "1.8.0") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/generic-deriving/generic-deriving-" + version + ".tar.gz")) + (sha256 + (base32 + "1kc6lhdanls6kgpk8xv5xi14lz1sngcd8xn930hkf7ilq4kxkcr6")))) + (build-system haskell-build-system) + (home-page "https://hackage.haskell.org/package/generic-deriving") + (synopsis "Generalise the deriving mechanism to arbitrary classes") + (description "This package provides functionality for generalising the +deriving mechanism in Haskell to arbitrary classes.") + (license bsd-3))) + +(define-public ghc-pcre-light + (package + (name "ghc-pcre-light") + (version "0.4.0.3") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/pcre-light/pcre-light-" + version + ".tar.gz")) + (sha256 + (base32 + "0l1df2sk5qwf424bvb8mbdkr2xjg43fi92n5r22yd7vm1zz0jqvf")))) + (build-system haskell-build-system) + (inputs + `(("pcre" ,pcre))) + (home-page "https://github.com/Daniel-Diaz/pcre-light") + (synopsis "Haskell library for Perl 5 compatible regular expressions") + (description "This package provides a small, efficient, and portable regex +library for Perl 5 compatible regular expressions. The PCRE library is a set +of functions that implement regular expression pattern matching using the same +syntax and semantics as Perl 5.") + (license bsd-3))) + +(define-public ghc-logict + (package + (name "ghc-logict") + (version "0.6.0.2") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/logict/logict-" + version + ".tar.gz")) + (sha256 + (base32 + "07hnirv6snnym2r7iijlfz00b60jpy2856zvqxh989q0in7bd0hi")))) + (build-system haskell-build-system) + (inputs `(("ghc-mtl" ,ghc-mtl))) + (home-page "http://code.haskell.org/~dolio/") + (synopsis "Backtracking logic-programming monad") + (description "This library provides a continuation-based, backtracking, +logic programming monad. An adaptation of the two-continuation implementation +found in the paper \"Backtracking, Interleaving, and Terminating Monad +Transformers\" available @uref{http://okmij.org/ftp/papers/LogicT.pdf, +online}.") + (license bsd-3))) + +(define-public ghc-xml + (package + (name "ghc-xml") + (version "1.3.14") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/xml/xml-" + version + ".tar.gz")) + (sha256 + (base32 + "0g814lj7vaxvib2g3r734221k80k7ap9czv9hinifn8syals3l9j")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-text" ,ghc-text))) + (home-page "http://code.galois.com") + (synopsis "Simple XML library for Haskell") + (description "This package provides a simple XML library for Haskell.") + (license bsd-3))) + +(define-public ghc-exceptions + (package + (name "ghc-exceptions") + (version "0.8.0.2") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/exceptions/exceptions-" + version + ".tar.gz")) + (sha256 + (base32 + "1x1bk1jf42k1gigiqqmkkh38z2ffhx8rsqiszdq3f94m2h6kw2h7")))) + (build-system haskell-build-system) + (arguments `(#:tests? #f)) ; FIXME: Missing test-framework package. + (propagated-inputs + `(("ghc-stm" ,ghc-stm) + ("ghc-mtl" ,ghc-mtl) + ("ghc-transformers-compat" ,ghc-transformers-compat))) + (home-page "http://github.com/ekmett/exceptions/") + (synopsis "Extensible optionally-pure exceptions") + (description "This library provides extensible optionally-pure exceptions +for Haskell.") + (license bsd-3))) + +(define-public ghc-temporary + (package + (name "ghc-temporary") + (version "1.2.0.3") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/temporary/temporary-" + version + ".tar.gz")) + (sha256 + (base32 + "0is67bmsjmbbw6wymhis8wyq9gax3sszm573p5719fx2c9z9r24a")))) + (build-system haskell-build-system) + (propagated-inputs `(("ghc-exceptions" ,ghc-exceptions))) + (home-page "http://www.github.com/batterseapower/temporary") + (synopsis "Temporary file and directory support") + (description "The functions for creating temporary files and directories +in the Haskelll base library are quite limited. This library just repackages +the Cabal implementations of its own temporary file and folder functions so +that you can use them without linking against Cabal or depending on it being +installed.") + (license bsd-3))) + +(define-public ghc-temporary-rc + (package + (name "ghc-temporary-rc") + (version "1.2.0.3") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/temporary-rc/temporary-rc-" + version + ".tar.gz")) + (sha256 + (base32 + "1nqih0qks439k3pr5kmbbc8rjdw730slrxlflqb27fbxbzb8skqs")))) + (build-system haskell-build-system) + (propagated-inputs `(("ghc-exceptions" ,ghc-exceptions))) + (home-page + "http://www.github.com/feuerbach/temporary") + (synopsis + "Portable temporary file and directory support") + (description + "The functions for creating temporary files and directories in the base +library are quite limited. The unixutils package contains some good ones, but +they aren't portable to Windows. This library just repackages the Cabal +implementations of its own temporary file and folder functions so that you can +use them without linking against Cabal or depending on it being installed. +This is a better maintained fork of the \"temporary\" package.") + (license bsd-3))) + +(define-public ghc-smallcheck + (package + (name "ghc-smallcheck") + (version "1.1.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/smallcheck/smallcheck-" + version + ".tar.gz")) + (sha256 + (base32 + "1ygrabxh40bym3grnzqyfqn96lirnxspb8cmwkkr213239y605sd")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-logict" ,ghc-logict))) + (inputs + `(("ghc-mtl" ,ghc-mtl))) + (home-page + "https://github.com/feuerbach/smallcheck") + (synopsis "Property-based testing library") + (description "SmallCheck is a testing library that allows to verify +properties for all test cases up to some depth. The test cases are generated +automatically by SmallCheck.") + (license bsd-3))) + +(define-public ghc-tasty-ant-xml + (package + (name "ghc-tasty-ant-xml") + (version "1.0.2") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/tasty-ant-xml/tasty-ant-xml-" + version + ".tar.gz")) + (sha256 + (base32 + "0pgz2lclg2hp72ykljcbxd88pjanfdfk8m5vb2qzcyjr85kwrhxv")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-generic-deriving" ,ghc-generic-deriving) + ("ghc-xml" ,ghc-xml))) + (inputs + `(("ghc-mtl" ,ghc-mtl) + ("ghc-stm" ,ghc-stm) + ("ghc-tagged" ,ghc-tagged) + ("ghc-tasty" ,ghc-tasty))) + (home-page + "http://github.com/ocharles/tasty-ant-xml") + (synopsis + "Render tasty output to XML for Jenkins") + (description + "A tasty ingredient to output test results in XML, using the Ant +schema. This XML can be consumed by the Jenkins continuous integration +framework.") + (license bsd-3))) + +(define-public ghc-tasty-smallcheck + (package + (name "ghc-tasty-smallcheck") + (version "0.8.0.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/tasty-smallcheck/tasty-smallcheck-" + version + ".tar.gz")) + (sha256 + (base32 + "0yckfbz8na8ccyw2911i3a4hd3fdncclk3ng5343hs5cylw6y4sm")))) + (build-system haskell-build-system) + (inputs + `(("ghc-tasty" ,ghc-tasty) + ("ghc-smallcheck" ,ghc-smallcheck) + ("ghc-async" ,ghc-async) + ("ghc-tagged" ,ghc-tagged))) + (home-page "http://documentup.com/feuerbach/tasty") + (synopsis "SmallCheck support for the Tasty test framework") + (description "This package provides SmallCheck support for the Tasty +Haskell test framework.") + (license bsd-3))) + +(define-public ghc-silently + (package + (name "ghc-silently") + (version "1.2.5") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/silently/silently-" + version + ".tar.gz")) + (sha256 + (base32 + "0f9qm3f7y0hpxn6mddhhg51mm1r134qkvd2kr8r6192ka1ijbxnf")))) + (build-system haskell-build-system) + (arguments `(#:tests? #f)) ;; circular dependency with nanospec + ;; (inputs + ;; `(("ghc-temporary" ,ghc-temporary))) + (home-page "https://github.com/hspec/silently") + (synopsis "Prevent writing to stdout") + (description "This package provides functions to prevent or capture +writing to stdout and other handles.") + (license bsd-3))) + +(define-public ghc-quickcheck-instances + (package + (name "ghc-quickcheck-instances") + (version "0.3.11") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/" + "quickcheck-instances/quickcheck-instances-" + version ".tar.gz")) + (sha256 + (base32 + "041s6963czs1pz0fc9cx17lgd6p83czqy2nxji7bhxqxwl2j15h2")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-old-time" ,ghc-old-time) + ("ghc-unordered-containers" ,ghc-unordered-containers))) + (inputs + `(("ghc-hashable" ,ghc-hashable) + ("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-text" ,ghc-text))) + (home-page + "https://github.com/aslatter/qc-instances") + (synopsis "Common quickcheck instances") + (description "This package provides QuickCheck instances for types +provided by the Haskell Platform.") + (license bsd-3))) + +(define-public ghc-quickcheck-unicode + (package + (name "ghc-quickcheck-unicode") + (version "1.0.0.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/quickcheck-unicode/quickcheck-unicode-" + version + ".tar.gz")) + (sha256 + (base32 + "1a8nl6x7l9b22yx61wm0bh2n1xzb1hd5i5zgg1w4fpaivjnrrhi4")))) + (build-system haskell-build-system) + (inputs `(("ghc-quickcheck" ,ghc-quickcheck))) + (home-page + "https://github.com/bos/quickcheck-unicode") + (synopsis "Generator functions Unicode-related tests") + (description "This package provides generator and shrink functions for +testing Unicode-related software.") + (license bsd-3))) + +(define-public ghc-quickcheck-io + (package + (name "ghc-quickcheck-io") + (version "0.1.2") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/quickcheck-io/quickcheck-io-" + version + ".tar.gz")) + (sha256 + (base32 + "1kf1kfw9fsmly0rvzvdf6jvdw10qhkmikyj0wcwciw6wad95w9sh")))) + (build-system haskell-build-system) + (inputs + `(("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-hunit" ,ghc-hunit))) + (home-page + "https://github.com/hspec/quickcheck-io#readme") + (synopsis "Use HUnit assertions as QuickCheck properties") + (description "This package provides an orphan instance that allows you to +use HUnit assertions as QuickCheck properties.") + (license expat))) + (define-public ghc-quickcheck (package (name "ghc-quickcheck") - (version "2.8") + (version "2.8.1") (outputs '("out" "doc")) (source (origin @@ -833,7 +2786,7 @@ Hashing\" by Claessen, Pałka for details and the rationale of the design.") ".tar.gz")) (sha256 (base32 - "04xs6mq22bcnkpi616qrbm7jlivh9csnhmvjgp1ifq52an1wr4rx")))) + "0fvnfl30fxmj5q920l13641ar896d53z0z6z66m7c1366lvalwvh")))) (build-system haskell-build-system) (arguments `(#:tests? #f ; FIXME: currently missing libraries used for tests. @@ -886,7 +2839,7 @@ to cases.") (define-public ghc-syb (package (name "ghc-syb") - (version "0.4.4") + (version "0.6") (outputs '("out" "doc")) (source (origin @@ -897,7 +2850,7 @@ to cases.") ".tar.gz")) (sha256 (base32 - "11sc9kmfvcn9bfxf227fgmny502z2h9xs3z0m9ak66lk0dw6f406")))) + "1p3cnqjm13677r4a966zffzhi9b3a321aln8zs8ckqj0d9z1z3d3")))) (build-system haskell-build-system) (inputs `(("ghc-hunit" ,ghc-hunit) @@ -905,43 +2858,12 @@ to cases.") (home-page "http://www.cs.uu.nl/wiki/GenericProgramming/SYB") (synopsis "Scrap Your Boilerplate") - (description - "This package contains the generics system described in the + (description "This package contains the generics system described in the /Scrap Your Boilerplate/ papers (see -<http://www.cs.uu.nl/wiki/GenericProgramming/SYB>). -It defines the 'Data' class of types permitting folding and unfolding -of constructor applications, instances of this class for primitive -types, and a variety of traversals.") - (license bsd-3))) - -(define-public ghc-containers - (package - (name "ghc-containers") - (version "0.5.6.3") - (outputs '("out" "doc")) - (source - (origin - (method url-fetch) - (uri (string-append - "http://hackage.haskell.org/package/containers/containers-" - version - ".tar.gz")) - (sha256 - (base32 - "1kcd55nl0vzi99i8sr8fmc5j25fv7m0a9hd3nihnq1pd64pfciqn")))) - (build-system haskell-build-system) - (inputs - `(("ghc-hunit" ,ghc-hunit) - ("ghc-quickcheck" ,ghc-quickcheck))) - (arguments - `(#:tests? #f)) ; FIXME: currently missing libraries used for tests. - (home-page "http://hackage.haskell.org/package/containers") - (synopsis "Assorted concrete container types") - (description - "This package contains efficient general-purpose implementations of -various basic immutable container types. The declared cost of each operation -is either worst-case or amortized, but remains valid even if structures are -shared.") +@uref{http://www.cs.uu.nl/wiki/GenericProgramming/SYB, the website}). It +defines the 'Data' class of types permitting folding and unfolding of +constructor applications, instances of this class for primitive types, and a +variety of traversals.") (license bsd-3))) (define-public ghc-fgl @@ -979,9 +2901,8 @@ encourages inductive, recursive definitions of graph algorithms.") (origin (method url-fetch) (uri (string-append - "http://hackage.haskell.org/package/unordered-containers/unordered-containers-" - version - ".tar.gz")) + "http://hackage.haskell.org/package/unordered-containers" + "/unordered-containers-" version ".tar.gz")) (sha256 (base32 "06l1xv7vhpxly75saxdrbc6p2zlgz1az278arfkz4rgawfnphn3f")))) @@ -1003,6 +2924,103 @@ optimized for performance critical use, both in terms of large data quantities and high speed.") (license bsd-3))) +(define-public ghc-uniplate + (package + (name "ghc-uniplate") + (version "1.6.12") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/uniplate/uniplate-" + version + ".tar.gz")) + (sha256 + (base32 + "1dx8f9aw27fz8kw0ad1nm6355w5rdl7bjvb427v2bsgnng30pipw")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-syb" ,ghc-syb) + ("ghc-hashable" ,ghc-hashable) + ("ghc-unordered-containers" ,ghc-unordered-containers))) + (home-page "http://community.haskell.org/~ndm/uniplate/") + (synopsis "Simple, concise and fast generic operations") + (description "Uniplate is a library for writing simple and concise generic +operations. Uniplate has similar goals to the original Scrap Your Boilerplate +work, but is substantially simpler and faster.") + (license bsd-3))) + +(define-public ghc-base64-bytestring + (package + (name "ghc-base64-bytestring") + (version "1.0.0.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/base64-bytestring/base64-bytestring-" + version + ".tar.gz")) + (sha256 + (base32 + "0l1v4ddjdsgi9nqzyzcxxj76rwar3lzx8gmwf2r54bqan3san9db")))) + (build-system haskell-build-system) + (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing. + (home-page "https://github.com/bos/base64-bytestring") + (synopsis "Base64 encoding and decoding for ByteStrings") + (description "This library provides fast base64 encoding and decoding for +Haskell @code{ByteString}s.") + (license bsd-3))) + +(define-public ghc-annotated-wl-pprint + (package + (name "ghc-annotated-wl-pprint") + (version "0.7.0") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/annotated-wl-pprint" + "/annotated-wl-pprint-" version + ".tar.gz")) + (sha256 + (base32 + "061xfz6qany3wf95csl8dcik2pz22cn8iv1qchhm16isw5zjs9hc")))) + (build-system haskell-build-system) + (home-page + "https://github.com/david-christiansen/annotated-wl-pprint") + (synopsis + "The Wadler/Leijen Pretty Printer, with annotation support") + (description "This is a modified version of wl-pprint, which was based on +Wadler's paper \"A Prettier Printer\". This version allows the library user +to annotate the text with semantic information, which can later be rendered in +a variety of ways.") + (license bsd-3))) + +(define-public ghc-ansi-wl-pprint + (package + (name "ghc-ansi-wl-pprint") + (version "0.6.7.3") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/ansi-wl-pprint/ansi-wl-pprint-" + version + ".tar.gz")) + (sha256 + (base32 + "025pyphsjf0dnbrmj5nscbi6gzyigwgp3ifxb3psn7kji6mfr29p")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-ansi-terminal" ,ghc-ansi-terminal))) + (home-page "http://github.com/ekmett/ansi-wl-pprint") + (synopsis "Wadler/Leijen Pretty Printer for colored ANSI terminal output") + (description "This is a pretty printing library based on Wadler's paper +\"A Prettier Printer\". It has been enhanced with support for ANSI terminal +colored output using the ansi-terminal package.") + (license bsd-3))) + (define-public ghc-split (package (name "ghc-split") @@ -1017,15 +3035,22 @@ and high speed.") ".tar.gz")) (sha256 (base32 - "0xa3j0gwr6k5vizxybnzk5fgb3pppgspi6mysnp2gwjp2dbrxkzr")))) + "0xa3j0gwr6k5vizxybnzk5fgb3pppgspi6mysnp2gwjp2dbrxkzr")) + (modules '((guix build utils))) + (snippet + ;; The Cabal file on Hackage is updated, but the tar.gz does not + ;; include it. See + ;; <https://hackage.haskell.org/package/split-0.2.2/revisions/>. + '(substitute* "split.cabal" + (("base <4.8") "base <4.9"))))) (build-system haskell-build-system) (inputs `(("ghc-quickcheck" ,ghc-quickcheck))) (home-page "http://hackage.haskell.org/package/split") - (synopsis - "Combinator library for splitting lists") - (description "A collection of various methods for splitting lists into -parts, akin to the 'split' function found in several mainstream languages.") + (synopsis "Combinator library for splitting lists") + (description "This package provides a collection of Haskell functions for +splitting lists into parts, akin to the @code{split} function found in several +mainstream languages.") (license bsd-3))) (define-public ghc-parsec @@ -1063,7 +3088,7 @@ is also parametric in the input stream type.") (define-public ghc-vector (package (name "ghc-vector") - (version "0.10.12.2") + (version "0.11.0.0") (outputs '("out" "doc")) (source (origin @@ -1074,7 +3099,7 @@ is also parametric in the input stream type.") ".tar.gz")) (sha256 (base32 - "01hc71k1z9m0g0dv4zsvq5d2dvbgyc5p01hryw5c53792yi2fm25")))) + "1r1jlksy7b0kb0fy00g64isk6nyd9wzzdq31gx5v1wn38knj0lqa")))) (build-system haskell-build-system) (inputs `(("ghc-quickcheck" ,ghc-quickcheck))) @@ -1082,17 +3107,46 @@ is also parametric in the input stream type.") (propagated-inputs `(("ghc-primitive" ,ghc-primitive))) (arguments - `(#:tests? #f)) ; FIXME: currently missing libraries used for tests. + `(#:tests? #f)) ; FIXME: currently missing libraries used for tests. (home-page "https://github.com/haskell/vector") (synopsis "Efficient Arrays") - (description "An efficient implementation of Int-indexed arrays (both -mutable and immutable), with a powerful loop optimisation framework.") - (license bsd-3))) + (description "This library provides an efficient implementation of +Int-indexed arrays (both mutable and immutable), with a powerful loop +optimisation framework.") + (license bsd-3))) + +(define-public ghc-vector-binary-instances + (package + (name "ghc-vector-binary-instances") + (version "0.2.1.0") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/" + "vector-binary-instances/vector-binary-instances-" + version ".tar.gz")) + (sha256 + (base32 + "028rsf2w193rhs1gic5yvvrwidw9sblczcn10aw64npfc6502l4l")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-cereal" ,ghc-cereal))) + (inputs + `(("ghc-vector" ,ghc-vector))) + (home-page "https://github.com/bos/vector-binary-instances") + (synopsis "Instances of Data.Binary and Data.Serialize for vector") + (description "This library provides instances of @code{Binary} for the +types defined in the @code{vector} package, making it easy to serialize +vectors to and from disk. We use the generic interface to vectors, so all +vector types are supported. Specific instances are provided for unboxed, +boxed and storable vectors.") + (license bsd-3))) (define-public ghc-network (package (name "ghc-network") - (version "2.6.0.2") + (version "2.6.2.1") (outputs '("out" "doc")) (source (origin @@ -1103,7 +3157,7 @@ mutable and immutable), with a powerful loop optimisation framework.") ".tar.gz")) (sha256 (base32 - "12b7saam5ga6l4cplgkad49xa4vkynz2ri9jxidx1cxiqjcl0vc4")))) + "1yhvpd4wigz165jvyvw9zslx7lgqdj63jh3zv5s74b5ykdfa3zd3")))) (build-system haskell-build-system) (inputs `(("ghc-hunit" ,ghc-hunit))) @@ -1122,7 +3176,7 @@ mutable and immutable), with a powerful loop optimisation framework.") (define-public ghc-network-uri (package (name "ghc-network-uri") - (version "2.6.0.1") + (version "2.6.0.3") (outputs '("out" "doc")) (source (origin @@ -1133,7 +3187,7 @@ mutable and immutable), with a powerful loop optimisation framework.") ".tar.gz")) (sha256 (base32 - "09ymamb128jgqghpda4nixncr73all8qc6q53976aricm6a27p37")))) + "1pwbqb2rk4rnvllvdch42p5368xcvpkanp7bxckdhxya8zzwvhhg")))) (build-system haskell-build-system) (inputs `(("ghc-hunit" ,ghc-hunit) @@ -1150,10 +3204,32 @@ mutable and immutable), with a powerful loop optimisation framework.") package into this package.") (license bsd-3))) +(define-public ghc-ansi-terminal + (package + (name "ghc-ansi-terminal") + (version "0.6.2.3") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/ansi-terminal/ansi-terminal-" + version + ".tar.gz")) + (sha256 + (base32 + "0hpfw0k025y681m9ml1c712skrb1p4vh7z5x1f0ci9ww7ssjrh2d")))) + (build-system haskell-build-system) + (home-page "https://github.com/feuerbach/ansi-terminal") + (synopsis "ANSI terminal support for Haskell") + (description "This package provides ANSI terminal support for Haskell. It +allows cursor movement, screen clearing, color output showing or hiding the +cursor, and changing the title.") + (license bsd-3))) + (define-public ghc-http (package (name "ghc-http") - (version "4000.2.19") + (version "4000.2.20") (outputs '("out" "doc")) (source (origin @@ -1164,12 +3240,13 @@ package into this package.") ".tar.gz")) (sha256 (base32 - "1yzm8gimh8g0wwbixcbxg60v4l3vgi63w9v55ms0x9qnm6vrgysz")))) + "0nyqdxr5ls2dxkf4a1f3x15xzwdm46ppn99nkcbhswlr6s3cq1s4")))) (build-system haskell-build-system) (inputs `(("ghc-hunit" ,ghc-hunit))) (propagated-inputs - `(("ghc-parsec" ,ghc-parsec) + `(("ghc-old-time" ,ghc-old-time) + ("ghc-parsec" ,ghc-parsec) ("ghc-mtl" ,ghc-mtl) ("ghc-network" ,ghc-network) ("ghc-network-uri" ,ghc-network-uri))) @@ -1183,4 +3260,1601 @@ lets you set up HTTP connections, transmitting requests and processing the responses coming back.") (license bsd-3))) +(define-public ghc-hspec + (package + (name "ghc-hspec") + (version "2.2.0") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/hspec/hspec-" + version + ".tar.gz")) + (sha256 + (base32 + "0zqisxznlbszivsgy3irvf566zhcr6ipqqj3x9i7pj5hy913jwqf")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-hspec-core" ,ghc-hspec-core) + ("hspec-discover" ,hspec-discover) + ("ghc-hspec-expectations" ,ghc-hspec-expectations) + ("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-hunit" ,ghc-hunit))) + (inputs + `(("ghc-stringbuilder" ,ghc-stringbuilder) + ("ghc-hspec-meta" ,ghc-hspec-meta))) + (home-page "http://hspec.github.io/") + (synopsis "Testing Framework for Haskell") + (description "This library provides the Hspec testing framework for +Haskell, inspired by the Ruby library RSpec.") + (license expat))) + +(define-public ghc-hspec-expectations + (package + (name "ghc-hspec-expectations") + (version "0.7.2") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/hspec-expectations/hspec-expectations-" + version + ".tar.gz")) + (sha256 + (base32 + "1w56jiqfyl237sr207gh3b0l8sr9layy0mdsgd5wknzb49mif6ip")))) + (build-system haskell-build-system) + (inputs `(("ghc-hunit" ,ghc-hunit))) + (home-page "https://github.com/sol/hspec-expectations") + (synopsis "Catchy combinators for HUnit") + (description "This library provides catchy combinators for HUnit, see +@uref{https://github.com/sol/hspec-expectations#readme, the README}.") + (license expat))) + +(define-public hspec-discover + (package + (name "hspec-discover") + (version "2.2.0") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/hspec-discover/hspec-discover-" + version + ".tar.gz")) + (sha256 + (base32 + "0w3awzbljf4hqhxrjrxqa1lfcclg92bhmq641gz2q80vycspapzx")))) + (build-system haskell-build-system) + (arguments `(#:haddock? #f)) ; Haddock phase fails because there are no + ; documentation files. + (inputs `(("ghc-hspec-meta" ,ghc-hspec-meta))) + (home-page "http://hspec.github.io/") + (synopsis "Automatically discover and run Hspec tests") + (description "hspec-discover is a tool which automatically discovers and +runs Hspec tests.") + (license expat))) + +(define-public ghc-hspec-core + (package + (name "ghc-hspec-core") + (version "2.2.0") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/hspec-core/hspec-core-" + version + ".tar.gz")) + (sha256 + (base32 + "1wgd55k652jaf81nkvciyqi67ycj7zamr4nd9z1cqf8nr9fc3sa4")))) + (build-system haskell-build-system) + (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing. + (propagated-inputs + `(("ghc-setenv" ,ghc-setenv) + ("ghc-ansi-terminal" ,ghc-ansi-terminal) + ("ghc-async" ,ghc-async) + ("ghc-quickcheck-io" ,ghc-quickcheck-io))) + (inputs + `(("ghc-hunit" ,ghc-hunit) + ("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-hspec-expectations" ,ghc-hspec-expectations) + ("ghc-silently" ,ghc-silently))) + (home-page "http://hspec.github.io/") + (synopsis "Testing framework for Haskell") + (description "This library exposes internal types and functions that can +be used to extend Hspec's functionality.") + (license expat))) + +(define-public ghc-hspec-meta + (package + (name "ghc-hspec-meta") + (version "2.2.0") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/hspec-meta/hspec-meta-" + version + ".tar.gz")) + (sha256 + (base32 + "1fmqmgrzp135cxhmxxbaswkk4bqbpgfml00cmcz0d39n11vzpa5z")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-hunit" ,ghc-hunit) + ("ghc-ansi-terminal" ,ghc-ansi-terminal) + ("ghc-async" ,ghc-async) + ("ghc-hspec-expectations" ,ghc-hspec-expectations) + ("ghc-setenv" ,ghc-setenv) + ("ghc-random" ,ghc-random) + ("ghc-quickcheck-io" ,ghc-quickcheck-io))) + (home-page "http://hspec.github.io/") + (synopsis "Version of Hspec to test Hspec itself") + (description "This library provides a stable version of Hspec which is +used to test the in-development version of Hspec.") + (license expat))) + +(define-public ghc-vault + (package + (name "ghc-vault") + (version "0.3.0.4") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/vault/vault-" + version + ".tar.gz")) + (sha256 + (base32 + "0ah6qrg71krc87f4vjy4b4shdd0mgyil8fikb3j6fl4kfwlg67jn")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-unordered-containers" ,ghc-unordered-containers) + ("ghc-hashable" ,ghc-hashable))) + (home-page + "https://github.com/HeinrichApfelmus/vault") + (synopsis "Persistent store for arbitrary values") + (description "This package provides vaults for Haskell. A vault is a +persistent store for values of arbitrary types. It's like having first-class +access to the storage space behind @code{IORefs}. The data structure is +analogous to a bank vault, where you can access different bank boxes with +different keys; hence the name. Also provided is a @code{locker} type, +representing a store for a single element.") + (license bsd-3))) + +(define-public ghc-mmorph + (package + (name "ghc-mmorph") + (version "1.0.4") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/mmorph/mmorph-" + version + ".tar.gz")) + (sha256 + (base32 + "0k5zlzmnixfwcjrqvhgi3i6xg532b0gsjvc39v5jigw69idndqr2")))) + (build-system haskell-build-system) + (home-page + "http://hackage.haskell.org/package/mmorph") + (synopsis "Monad morphisms") + (description + "This library provides monad morphism utilities, most commonly used for +manipulating monad transformer stacks.") + (license bsd-3))) + +(define-public ghc-monad-control + (package + (name "ghc-monad-control") + (version "1.0.0.4") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/monad-control" + "/monad-control-" version ".tar.gz")) + (sha256 + (base32 + "07pn1p4m80wdd7gw62s4yny8rbvm60ka1q8qx5y1plznd8sbg179")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-stm" ,ghc-stm) + ("ghc-transformers-base" ,ghc-transformers-base) + ("ghc-transformers-compat" ,ghc-transformers-compat))) + (home-page "https://github.com/basvandijk/monad-control") + (synopsis "Monad transformers to lift control operations like exception +catching") + (description "This package defines the type class @code{MonadBaseControl}, +a subset of @code{MonadBase} into which generic control operations such as +@code{catch} can be lifted from @code{IO} or any other base monad.") + (license bsd-3))) + +(define-public ghc-byteorder + (package + (name "ghc-byteorder") + (version "1.0.4") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/byteorder/byteorder-" + version + ".tar.gz")) + (sha256 + (base32 + "06995paxbxk8lldvarqpb3ygcjbg4v8dk4scib1rjzwlhssvn85x")))) + (build-system haskell-build-system) + (home-page + "http://community.haskell.org/~aslatter/code/byteorder") + (synopsis + "Exposes the native endianness of the system") + (description + "This package is for working with the native byte-ordering of the +system.") + (license bsd-3))) + +(define-public ghc-base-compat + (package + (name "ghc-base-compat") + (version "0.8.2") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/base-compat/base-compat-" + version + ".tar.gz")) + (sha256 + (base32 + "02m93hzgxg4bcnp7xcc2fdh2hrsc2h6fwl8hix5nx9k864kwf41q")))) + (build-system haskell-build-system) + (inputs + `(("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-hspec" ,ghc-hspec))) + (home-page "https://hackage.haskell.org/package/base-compat") + (synopsis "Haskell compiler compatibility library") + (description "This library provides functions available in later versions +of base to a wider range of compilers, without requiring the use of CPP +pragmas in your code.") + (license bsd-3))) + +(define-public ghc-blaze-builder + (package + (name "ghc-blaze-builder") + (version "0.4.0.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/blaze-builder/blaze-builder-" + version + ".tar.gz")) + (sha256 + (base32 + "1id3w33x9f7q5m3xpggmvzw03bkp94bpfyz81625bldqgf3yqdn1")))) + (build-system haskell-build-system) + (arguments `(#:tests? #f)) ; FIXME: Missing test libraries. + (propagated-inputs + `(("ghc-text" ,ghc-text) + ("ghc-utf8-string" ,ghc-utf8-string))) + (home-page "http://github.com/lpsmith/blaze-builder") + (synopsis "Efficient buffered output") + (description "This library provides an implementation of the older +@code{blaze-builder} interface in terms of the new builder that shipped with +@code{bytestring-0.10.4.0}. This implementation is mostly intended as a +bridge to the new builder, so that code that uses the old interface can +interoperate with code that uses the new implementation.") + (license bsd-3))) + +(define-public ghc-blaze-markup + (package + (name "ghc-blaze-markup") + (version "0.7.0.3") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/blaze-markup/blaze-markup-" + version + ".tar.gz")) + (sha256 + (base32 + "080vlhd8dwjxrma4bb524lh8gxs5lm3xh122icy6lnnyipla0s9y")))) + (build-system haskell-build-system) + (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing. + (propagated-inputs + `(("ghc-blaze-builder" ,ghc-blaze-builder) + ("ghc-text" ,ghc-text))) + (home-page "http://jaspervdj.be/blaze") + (synopsis "Fast markup combinator library for Haskell") + (description "This library provides core modules of a markup combinator +library for Haskell.") + (license bsd-3))) + +(define-public ghc-blaze-html + (package + (name "ghc-blaze-html") + (version "0.8.1.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/blaze-html/blaze-html-" + version + ".tar.gz")) + (sha256 + (base32 + "1dnw50kh0s405cg9i2y4a8awanhj3bqzk21jwgfza65kcjby7lpq")))) + (build-system haskell-build-system) + (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing. + (propagated-inputs + `(("ghc-blaze-builder" ,ghc-blaze-builder) + ("ghc-text" ,ghc-text) + ("ghc-blaze-markup" ,ghc-blaze-markup))) + (home-page "http://jaspervdj.be/blaze") + (synopsis "Fast HTML combinator library") + (description "This library provides HTML combinators for Haskell.") + (license bsd-3))) + +(define-public ghc-easy-file + (package + (name "ghc-easy-file") + (version "0.2.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/easy-file/easy-file-" + version + ".tar.gz")) + (sha256 + (base32 + "0v75081bx4qzlqy29hh639nzlr7dncwza3qxbzm9njc4jarf31pz")))) + (build-system haskell-build-system) + (home-page + "http://github.com/kazu-yamamoto/easy-file") + (synopsis "File handling library for Haskell") + (description "This library provides file handling utilities for Haskell.") + (license bsd-3))) + +(define-public ghc-async + (package + (name "ghc-async") + (version "2.0.2") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/async/async-" + version + ".tar.gz")) + (sha256 + (base32 + "0azx4qk65a9a2gvqsfmz3w89m6shzr2iz0i5lly2zvly4n2d6m6v")))) + (build-system haskell-build-system) + (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing. + (propagated-inputs + `(("ghc-stm" ,ghc-stm))) + (home-page "https://github.com/simonmar/async") + (synopsis "Library to run IO operations asynchronously") + (description "Async provides a library to run IO operations +asynchronously, and wait for their results. It is a higher-level interface +over threads in Haskell, in which @code{Async a} is a concurrent thread that +will eventually deliver a value of type @code{a}.") + (license bsd-3))) + +(define-public ghc-fingertree + (package + (name "ghc-fingertree") + (version "0.1.1.0") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/fingertree/fingertree-" + version + ".tar.gz")) + (sha256 + (base32 + "1w6x3kp3by5yjmam6wlrf9vap5l5rrqaip0djbrdp0fpf2imn30n")))) + (build-system haskell-build-system) + (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing. + (home-page "http://hackage.haskell.org/package/fingertree") + (synopsis "Generic finger-tree structure") + (description "This library provides finger trees, a general sequence +representation with arbitrary annotations, for use as a base for +implementations of various collection types. It includes examples, as +described in section 4 of Ralf Hinze and Ross Paterson, \"Finger trees: a +simple general-purpose data structure\".") + (license bsd-3))) + +(define-public ghc-optparse-applicative + (package + (name "ghc-optparse-applicative") + (version "0.11.0.2") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/optparse-applicative" + "/optparse-applicative-" version ".tar.gz")) + (sha256 + (base32 + "0ni52ii9555jngljvzxn1ngicr6i2w647ww3rzhdrmng04y95iii")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-transformers-compat" ,ghc-transformers-compat) + ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint))) + (home-page "https://github.com/pcapriotti/optparse-applicative") + (synopsis "Utilities and combinators for parsing command line options") + (description "This package provides utilities and combinators for parsing +command line options in Haskell.") + (license bsd-3))) + +(define-public ghc-base-orphans + (package + (name "ghc-base-orphans") + (version "0.4.4") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/base-orphans/base-orphans-" + version + ".tar.gz")) + (sha256 + (base32 + "0hhgpwjvx7jhvlhsygmmf0q5hv2ymijzz4bjilicw99bmv13qcpl")))) + (build-system haskell-build-system) + (inputs + `(("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-hspec" ,ghc-hspec))) + (home-page "https://hackage.haskell.org/package/base-orphans") + (synopsis "Orphan instances for backwards compatibility") + (description "This package defines orphan instances that mimic instances +available in later versions of base to a wider (older) range of compilers.") + (license bsd-3))) + +(define-public ghc-auto-update + (package + (name "ghc-auto-update") + (version "0.1.2.2") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/auto-update/auto-update-" + version + ".tar.gz")) + (sha256 + (base32 + "1ns4c5mqhnm7hsiqxf1ivjs5fflyq92b16ldzrcl0p85631h0c3v")))) + (build-system haskell-build-system) + (home-page "https://github.com/yesodweb/wai") + (synopsis "Efficiently run periodic, on-demand actions") + (description "This library provides mechanisms to efficiently run +periodic, on-demand actions in Haskell.") + (license expat))) + +(define-public ghc-tagged + (package + (name "ghc-tagged") + (version "0.8.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/tagged/tagged-" + version + ".tar.gz")) + (sha256 + (base32 + "1hc2qzhhz5p1xd8k03sklrdnhcflkwhgpl82k6fam8yckww9ipav")))) + (build-system haskell-build-system) + (home-page "https://hackage.haskell.org/package/tagged") + (synopsis "Haskell phantom types to avoid passing dummy arguments") + (description "This library provides phantom types for Haskell 98, to avoid +having to unsafely pass dummy arguments.") + (license bsd-3))) + +(define-public ghc-unbounded-delays + (package + (name "ghc-unbounded-delays") + (version "0.1.0.9") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/unbounded-delays/unbounded-delays-" + version + ".tar.gz")) + (sha256 + (base32 + "1f4h87503m3smhip432q027wj3zih18pmz2rnafh60589ifcl420")))) + (build-system haskell-build-system) + (home-page "https://github.com/basvandijk/unbounded-delays") + (synopsis "Unbounded thread delays and timeouts") + (description "The @code{threadDelay} and @code{timeout} functions from the +Haskell base library use the bounded @code{Int} type for specifying the delay +or timeout period. This package provides alternative functions which use the +unbounded @code{Integer} type.") + (license bsd-3))) + +;; This package builds `clock` without tests, since the tests rely on tasty +;; and tasty-quickcheck, which in turn require clock to build. When tasty and +;; tasty-quickcheck are added, we will add ghc-clock with tests enabled. +(define ghc-clock-bootstrap + (package + (name "ghc-clock-bootstrap") + (version "0.5.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/" + "clock/" + "clock-" version ".tar.gz")) + (sha256 + (base32 "1ncph7vi2q6ywwc8ysxl1ibw6i5dwfvln88ssfazk8jgpj4iyykw")))) + (build-system haskell-build-system) + (arguments `(#:tests? #f)) ;; Testing suite depends on tasty and + ;; tasty-quickcheck, which need clock to build. + (home-page "https://hackage.haskell.org/package/clock") + (synopsis "High-resolution clock for Haskell") + (description "A package for convenient access to high-resolution clock and +timer functions of different operating systems via a unified API.") + (license bsd-3))) + +(define-public ghc-clock + (package + (name "ghc-clock") + (version "0.5.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/" + "clock/" + "clock-" version ".tar.gz")) + (sha256 + (base32 "1ncph7vi2q6ywwc8ysxl1ibw6i5dwfvln88ssfazk8jgpj4iyykw")))) + (build-system haskell-build-system) + (inputs + `(("ghc-tasty" ,ghc-tasty) + ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck))) + (home-page "https://hackage.haskell.org/package/clock") + (synopsis "High-resolution clock for Haskell") + (description "A package for convenient access to high-resolution clock and +timer functions of different operating systems via a unified API.") + (license bsd-3))) + +(define-public ghc-charset + (package + (name "ghc-charset") + (version "0.3.7.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/charset/charset-" + version + ".tar.gz")) + (sha256 + (base32 + "1gn0m96qpjww8hpp2g1as5yy0wcwy4iq73h3kz6g0yxxhcl5sh9x")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-semigroups" ,ghc-semigroups))) + (inputs + `(("ghc-unordered-containers" ,ghc-unordered-containers))) + (home-page "http://github.com/ekmett/charset") + (synopsis "Fast unicode character sets for Haskell") + (description "This package provides fast unicode character sets for +Haskell, based on complemented PATRICIA tries.") + (license bsd-3))) + +(define-public ghc-bytestring-builder + (package + (name "ghc-bytestring-builder") + (version "0.10.6.0.0") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/bytestring-builder" + "/bytestring-builder-" version ".tar.gz")) + (sha256 + (base32 + "1mkg24zl0rapb3gqzkyj5ibp07wx3yzd72hmfczssl0is63rjhww")))) + (build-system haskell-build-system) + (arguments `(#:haddock? #f)) ; Package contains no documentation. + (home-page "http://hackage.haskell.org/package/bytestring-builder") + (synopsis "The new bytestring builder, packaged outside of GHC") + (description "This package provides the bytestring builder that is +debuting in bytestring-0.10.4.0, which should be shipping with GHC 7.8. +Compatibility package for older packages.") + (license bsd-3))) + +(define-public ghc-nats + (package + (name "ghc-nats") + (version "1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/nats/nats-" + version + ".tar.gz")) + (sha256 + (base32 + "0r6s8l4s0yq3x2crrkv0b8zac13magfasr9v8hnq6rn1icsfhic0")))) + (build-system haskell-build-system) + (arguments `(#:haddock? #f)) + (inputs + `(("ghc-hashable" ,ghc-hashable))) + (home-page "https://hackage.haskell.org/package/nats") + (synopsis "Natural numbers") + (description "This library provides the natural numbers for Haskell.") + (license bsd-3))) + +(define-public ghc-void + (package + (name "ghc-void") + (version "0.7.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/void/void-" + version + ".tar.gz")) + (sha256 + (base32 + "1x15x2axz84ndw2bf60vjqljhrb0w95lddaljsxrl0hcd29zvw69")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-semigroups" ,ghc-semigroups))) + (inputs + `(("ghc-hashable" ,ghc-hashable))) + (home-page "http://github.com/ekmett/void") + (synopsis + "Logically uninhabited data type") + (description + "A Haskell 98 logically uninhabited data type, used to indicate that a +given term should not exist.") + (license bsd-3))) + +(define-public ghc-kan-extensions + (package + (name "ghc-kan-extensions") + (version "4.2.3") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/kan-extensions/kan-extensions-" + version + ".tar.gz")) + (sha256 + (base32 + "0iywbadpy8s3isfzlx9dlz3apaywhqq4gdbxkwygksq8pzdhwkrk")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-adjunctions" ,ghc-adjunctions))) + (inputs + `(("ghc-comonad" ,ghc-comonad) + ("ghc-contravariant" ,ghc-contravariant) + ("ghc-distributive" ,ghc-distributive) + ("ghc-free" ,ghc-free) + ("ghc-mtl" ,ghc-mtl) + ("ghc-semigroupoids" ,ghc-semigroupoids) + ("ghc-tagged" ,ghc-tagged))) + (home-page "http://github.com/ekmett/kan-extensions/") + (synopsis "Kan extensions library") + (description "This library provides Kan extensions, Kan lifts, various +forms of the Yoneda lemma, and (co)density (co)monads for Haskell.") + (license bsd-3))) + +(define-public ghc-statevar + (package + (name "ghc-statevar") + (version "1.1.0.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/StateVar/StateVar-" + version + ".tar.gz")) + (sha256 + (base32 + "1ap51cvwq61xckx5hw44l82ihbxvsq3263xr5hqg42c5qp67kbhf")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-stm" ,ghc-stm))) + (home-page "http://hackage.haskell.org/package/StateVar") + (synopsis "State variables for Haskell") + (description "This package provides state variables, which are references +in the @code{IO} monad, like @code{IORef}s or parts of the OpenGL state.") + (license bsd-3))) + +(define-public ghc-lens + (package + (name "ghc-lens") + (version "4.13") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/lens/lens-" + version + ".tar.gz")) + (sha256 + (base32 + "0g4g0xksrb2m8wgsmraaq8qnk1sssb42kr65fc7clgyid6zyfmim")))) + (build-system haskell-build-system) + (arguments `(#:tests? #f)) ; FIXME: doctest packagedb propagation problem. + (propagated-inputs + `(("ghc-base-orphans" ,ghc-base-orphans) + ("ghc-bifunctors" ,ghc-bifunctors) + ("ghc-distributive" ,ghc-distributive) + ("ghc-exceptions" ,ghc-exceptions) + ("ghc-free" ,ghc-free) + ("ghc-kan-extensions" ,ghc-kan-extensions) + ("ghc-parallel" ,ghc-parallel) + ("ghc-reflection" ,ghc-reflection) + ("ghc-semigroupoids" ,ghc-semigroupoids) + ("ghc-vector" ,ghc-vector))) + (inputs + `(("ghc-comonad" ,ghc-comonad) + ("ghc-contravariant" ,ghc-contravariant) + ("ghc-hashable" ,ghc-hashable) + ("ghc-mtl" ,ghc-mtl) + ("ghc-profunctors" ,ghc-profunctors) + ("ghc-semigroups" ,ghc-semigroups) + ("ghc-tagged" ,ghc-tagged) + ("ghc-text" ,ghc-text) + ("ghc-transformers-compat" ,ghc-transformers-compat) + ("ghc-unordered-containers" ,ghc-unordered-containers) + ("ghc-void" ,ghc-void) + ("ghc-generic-deriving" ,ghc-generic-deriving) + ("ghc-nats" ,ghc-nats) + ("ghc-simple-reflect" ,ghc-simple-reflect) + ("hlint" ,hlint))) + (home-page "http://github.com/ekmett/lens/") + (synopsis "Lenses, Folds and Traversals") + (description "This library provides @code{Control.Lens}. The combinators +in @code{Control.Lens} provide a highly generic toolbox for composing families +of getters, folds, isomorphisms, traversals, setters and lenses and their +indexed variants.") + (license bsd-3))) + +(define-public ghc-tagsoup + (package + (name "ghc-tagsoup") + (version "0.13.3") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/tagsoup/tagsoup-" + version + ".tar.gz")) + (sha256 + (base32 + "13b6zy6346r3cxhaivys84fnxarg8wbv7r2znazfjdkqil8n5a1j")))) + (build-system haskell-build-system) + (inputs `(("ghc-text" ,ghc-text))) + (home-page + "http://community.haskell.org/~ndm/tagsoup/") + (synopsis + "Parsing and extracting information from (possibly malformed) HTML/XML +documents") + (description + "TagSoup is a library for parsing HTML/XML. It supports the HTML 5 +specification, and can be used to parse either well-formed XML, or +unstructured and malformed HTML from the web. The library also provides +useful functions to extract information from an HTML document, making it ideal +for screen-scraping.") + (license bsd-3))) + +(define-public ghc-digest + (package + (name "ghc-digest") + (version "0.0.1.2") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/digest/digest-" + version + ".tar.gz")) + (sha256 + (base32 + "04gy2zp8yzvv7j9bdfvmfzcz3sqyqa6rwslqcn4vyair2vmif5v4")))) + (build-system haskell-build-system) + (inputs + `(("zlib" ,zlib))) + (home-page + "http://hackage.haskell.org/package/digest") + (synopsis + "Various cryptographic hashes for bytestrings") + (description + "This package provides efficient cryptographic hash implementations for +strict and lazy bytestrings. For now, CRC32 and Adler32 are supported; they +are implemented as FFI bindings to efficient code from zlib.") + (license bsd-3))) + +(define-public ghc-cheapskate + (package + (name "ghc-cheapskate") + (version "0.1.0.4") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/cheapskate/cheapskate-" + version + ".tar.gz")) + (sha256 + (base32 + "0drx1hlqvdcrij4097q6bxhbfcqm73jsqv1wwhd3hsnjdmr46ch2")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-xss-sanitize" ,ghc-xss-sanitize) + ("ghc-data-default" ,ghc-data-default))) + (inputs + `(("ghc-mtl" ,ghc-mtl) + ("ghc-text" ,ghc-text) + ("ghc-blaze-html" ,ghc-blaze-html) + ("ghc-syb" ,ghc-syb) + ("ghc-uniplate" ,ghc-uniplate) + ("ghc-aeson" ,ghc-aeson) + ("ghc-wai-extra" ,ghc-wai-extra) + ("ghc-wai" ,ghc-wai) + ("ghc-http-types" ,ghc-http-types))) + (home-page "http://github.com/jgm/cheapskate") + (synopsis "Experimental markdown processor") + (description "Cheapskate is an experimental Markdown processor in pure +Haskell. It aims to process Markdown efficiently and in the most forgiving +possible way. It is designed to deal with any input, including garbage, with +linear performance. Output is sanitized by default for protection against XSS +attacks.") + (license bsd-3))) + +(define-public ghc-bifunctors + (package + (name "ghc-bifunctors") + (version "5") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/bifunctors/bifunctors-" + version + ".tar.gz")) + (sha256 + (base32 + "13990xdgx0n23qgi18ghhmsywj5zkr0a5bim0g8a4nzi0cx95ps1")))) + (build-system haskell-build-system) + (inputs + `(("ghc-tagged" ,ghc-tagged) + ("ghc-semigroups" ,ghc-semigroups))) + (home-page "http://github.com/ekmett/bifunctors/") + (synopsis "Bifunctors for Haskell") + (description "This package provides bifunctors for Haskell.") + (license bsd-3))) + +(define-public ghc-semigroupoids + (package + (name "ghc-semigroupoids") + (version "5.0.0.4") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/semigroupoids/semigroupoids-" + version + ".tar.gz")) + (sha256 + (base32 + "1jf7jnfhdvl6p18wdr21yi2fim1xb8alcn6szhrdswj0dkilgq6d")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-base-orphans" ,ghc-base-orphans) + ("ghc-transformers-compat" ,ghc-transformers-compat) + ("ghc-bifunctors" ,ghc-bifunctors) + ("ghc-comonad" ,ghc-comonad) + ("ghc-contravariant" ,ghc-contravariant) + ("ghc-distributive" ,ghc-distributive))) + (arguments `(#:tests? #f)) ; FIXME: doctest packagedb propagation problem. + (inputs + `(("ghc-semigroups" ,ghc-semigroups) + ("ghc-tagged" ,ghc-tagged))) + (home-page "http://github.com/ekmett/semigroupoids") + (synopsis "Semigroupoids operations for Haskell") + (description "This library provides a wide array of (semi)groupoids and +operations for working with them. A @code{Semigroupoid} is a @code{Category} +without the requirement of identity arrows for every object in the category. +A @code{Category} is any @code{Semigroupoid} for which the Yoneda lemma holds. +Finally, to work with these weaker structures it is beneficial to have +containers that can provide stronger guarantees about their contents, so +versions of @code{Traversable} and @code{Foldable} that can be folded with +just a @code{Semigroup} are added.") + (license bsd-3))) + +(define-public ghc-contravariant + (package + (name "ghc-contravariant") + (version "1.3.3") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/contravariant/contravariant-" + version + ".tar.gz")) + (sha256 + (base32 + "184hcmhsznqrkmqlc1kza9pb5p591anva574ry8wrh81vqmhwfb5")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-void" ,ghc-void) + ("ghc-transformers-compat" ,ghc-transformers-compat) + ("ghc-statevar" ,ghc-statevar))) + (inputs + `(("ghc-semigroups" ,ghc-semigroups))) + (home-page + "http://github.com/ekmett/contravariant/") + (synopsis "Contravariant functors") + (description "Contravariant functors for Haskell.") + (license bsd-3))) + +(define-public ghc-semigroups + (package + (name "ghc-semigroups") + (version "0.17.0.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/semigroups/semigroups-" + version + ".tar.gz")) + (sha256 + (base32 + "0gvpfi7s6ys4qha3y9a1zl1a15gf9cgg33wjb94ghg82ivcxnc3r")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-nats" ,ghc-nats) + ("ghc-tagged" ,ghc-tagged) + ("ghc-unordered-containers" ,ghc-unordered-containers))) + (inputs + `(("ghc-text" ,ghc-text) + ("ghc-hashable" ,ghc-hashable))) + (home-page "http://github.com/ekmett/semigroups/") + (synopsis "Semigroup operations for Haskell") + (description "This package provides semigroups for Haskell. In +mathematics, a semigroup is an algebraic structure consisting of a set +together with an associative binary operation. A semigroup generalizes a +monoid in that there might not exist an identity element. It +also (originally) generalized a group (a monoid with all inverses) to a type +where every element did not have to have an inverse, thus the name +semigroup.") + (license bsd-3))) + +(define-public ghc-free + (package + (name "ghc-free") + (version "4.12.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/free/free-" + version + ".tar.gz")) + (sha256 + (base32 + "0sr8phvrb4ny8j1wzq55rdn8q4br23q4pw2j276npr844825jr9p")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-prelude-extras" ,ghc-prelude-extras) + ("ghc-profunctors" ,ghc-profunctors) + ("ghc-exceptions" ,ghc-exceptions))) + (inputs + `(("ghc-bifunctors" ,ghc-bifunctors) + ("ghc-comonad" ,ghc-comonad) + ("ghc-distributive" ,ghc-distributive) + ("ghc-mtl" ,ghc-mtl) + ("ghc-semigroupoids" ,ghc-semigroupoids) + ("ghc-semigroups" ,ghc-semigroups))) + (home-page "http://github.com/ekmett/free/") + (synopsis "Unrestricted monads for Haskell") + (description "This library provides free monads, which are useful for many +tree-like structures and domain specific languages. If @code{f} is a +@code{Functor} then the free @code{Monad} on @code{f} is the type of trees +whose nodes are labeled with the constructors of @code{f}. The word \"free\" +is used in the sense of \"unrestricted\" rather than \"zero-cost\": @code{Free +f} makes no constraining assumptions beyond those given by @code{f} and the +definition of @code{Monad}.") + (license bsd-3))) + +(define-public ghc-adjunctions + (package + (name "ghc-adjunctions") + (version "4.2.2") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/adjunctions/adjunctions-" + version + ".tar.gz")) + (sha256 + (base32 + "00p030iypjzjib8pxz1x6mxfi59wvyrwjj11zv9bh766dgkdbwjq")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-profunctors" ,ghc-profunctors))) + (inputs + `(("ghc-comonad" ,ghc-comonad) + ("ghc-contravariant" ,ghc-contravariant) + ("ghc-distributive" ,ghc-distributive) + ("ghc-free" ,ghc-free) + ("ghc-mtl" ,ghc-mtl) + ("ghc-tagged" ,ghc-tagged) + ("ghc-semigroupoids" ,ghc-semigroupoids) + ("ghc-semigroups" ,ghc-semigroups) + ("ghc-void" ,ghc-void))) + (home-page "http://github.com/ekmett/adjunctions/") + (synopsis "Adjunctions and representable functors") + (description "This library provides adjunctions and representable functors +for Haskell.") + (license bsd-3))) + +(define-public ghc-fast-logger + (package + (name "ghc-fast-logger") + (version "2.4.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/fast-logger/fast-logger-" + version + ".tar.gz")) + (sha256 + (base32 + "0kjk1861qcls8m8y7i55msfpprws5wk6c5mxzi35g2qbl2sih4p5")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-bytestring-builder" ,ghc-bytestring-builder) + ("ghc-auto-update" ,ghc-auto-update))) + (inputs + `(("ghc-hspec" ,ghc-hspec) + ("ghc-text" ,ghc-text))) + (home-page "https://hackage.haskell.org/package/fast-logger") + (synopsis "Fast logging system") + (description "This library provides a fast logging system for Haskell.") + (license bsd-3))) + +(define-public ghc-doctest + (package + (name "ghc-doctest") + (version "0.10.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/doctest/doctest-" + version + ".tar.gz")) + (sha256 + (base32 + "1jbyhzbi2hfrfg7vbkpj6vriaap8cn99nnmzwcfscwaijz09jyrm")))) + (build-system haskell-build-system) + (arguments `(#:tests? #f)) ; FIXME: missing test framework + (propagated-inputs + `(("ghc-syb" ,ghc-syb) + ("ghc-paths" ,ghc-paths))) + (inputs + `(("ghc-base-compat" ,ghc-base-compat) + ("ghc-hunit" ,ghc-hunit) + ("ghc-hspec" ,ghc-hspec) + ("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-stringbuilder" ,ghc-stringbuilder) + ("ghc-silently" ,ghc-silently) + ("ghc-setenv" ,ghc-setenv))) + (home-page + "https://github.com/sol/doctest#readme") + (synopsis "Test interactive Haskell examples") + (description "The doctest program checks examples in source code comments. +It is modeled after doctest for Python, see +@uref{http://docs.python.org/library/doctest.html, the Doctest website}.") + (license expat))) + +(define-public ghc-lifted-base + (package + (name "ghc-lifted-base") + (version "0.2.3.6") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/lifted-base/lifted-base-" + version + ".tar.gz")) + (sha256 + (base32 + "1yz14a1rsgknwyl08n4kxrlc26hfwmb95a3c2drbnsgmhdyq7iap")))) + (build-system haskell-build-system) + (arguments `(#:tests? #f)) ; FIXME: Missing testing libraries. + (propagated-inputs + `(("ghc-transformers-base" ,ghc-transformers-base) + ("ghc-monad-control" ,ghc-monad-control))) + (inputs + `(("ghc-transformers-compat" ,ghc-transformers-compat) + ("ghc-hunit" ,ghc-hunit))) + (home-page "https://github.com/basvandijk/lifted-base") + (synopsis "Lifted IO operations from the base library") + (description "Lifted-base exports IO operations from the @code{base} +library lifted to any instance of @code{MonadBase} or @code{MonadBaseControl}. +Note that not all modules from @code{base} are converted yet. The package +includes a copy of the @code{monad-peel} test suite written by Anders +Kaseorg.") + (license bsd-3))) + +(define-public ghc-word8 + (package + (name "ghc-word8") + (version "0.1.2") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/word8/word8-" + version + ".tar.gz")) + (sha256 + (base32 + "1pbn8ra3qhwvw07p375cdmp7jzlg07hgdcr4cpscz3h7b9sy7fiw")))) + (build-system haskell-build-system) + (inputs + `(("ghc-hspec" ,ghc-hspec))) + (home-page "http://hackage.haskell.org/package/word8") + (synopsis "Word8 library for Haskell") + (description "Word8 library to be used with @code{Data.ByteString}.") + (license bsd-3))) + +(define-public ghc-stringsearch + (package + (name "ghc-stringsearch") + (version "0.3.6.6") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/stringsearch/stringsearch-" + version + ".tar.gz")) + (sha256 + (base32 + "0jpy9xjcjdbpi3wk6mg7xwd7wfi2mma70p97v1ij5i8bj9qijpr9")))) + (build-system haskell-build-system) + (home-page "https://bitbucket.org/dafis/stringsearch") + (synopsis "Fast searching, splitting and replacing of ByteStrings") + (description "This package provides several functions to quickly search +for substrings in strict or lazy @code{ByteStrings}. It also provides +functions for breaking or splitting on substrings and replacing all +occurrences of a substring (the first in case of overlaps) with another.") + (license bsd-3))) + +(define-public ghc-tasty-quickcheck + (package + (name "ghc-tasty-quickcheck") + (version "0.8.4") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/tasty-quickcheck/" + "tasty-quickcheck-" version ".tar.gz")) + (sha256 + (base32 + "15rjxib5jmjq0hzj47x15kgp3awc73va4cy1pmpf7k3hvfv4qprn")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-quickcheck" ,ghc-quickcheck))) + (inputs + `(("ghc-tagged" ,ghc-tagged) + ("ghc-tasty" ,ghc-tasty) + ("ghc-random" ,ghc-random) + ("ghc-ansi-terminal" ,ghc-ansi-terminal) + ("ghc-tasty-hunit" ,ghc-tasty-hunit) + ("ghc-pcre-light" ,ghc-pcre-light))) + (home-page "http://documentup.com/feuerbach/tasty") + (synopsis "QuickCheck support for the Tasty test framework") + (description "This package provides QuickCheck support for the Tasty +Haskell test framework.") + (license expat))) + +(define-public ghc-tasty-golden + (package + (name "ghc-tasty-golden") + (version "2.3.0.2") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/tasty-golden/tasty-golden-" + version + ".tar.gz")) + (sha256 + (base32 + "0n7nll1sx75n3lffwhgnjrxdn0jz1g0921z9mj193fxqw0wz8axh")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-temporary" ,ghc-temporary))) + (inputs + `(("ghc-tasty" ,ghc-tasty) + ("ghc-mtl" ,ghc-mtl) + ("ghc-optparse-applicative" ,ghc-optparse-applicative) + ("ghc-tagged" ,ghc-tagged) + ("ghc-async" ,ghc-async) + ("ghc-tasty-hunit" ,ghc-tasty-hunit) + ("ghc-temporary-rc" ,ghc-temporary-rc))) + (home-page + "https://github.com/feuerbach/tasty-golden") + (synopsis "Golden tests support for tasty") + (description + "This package provides support for 'golden testing'. A golden test is an +IO action that writes its result to a file. To pass the test, this output +file should be identical to the corresponding 'golden' file, which contains +the correct result for the test.") + (license expat))) + +(define-public ghc-tasty + (package + (name "ghc-tasty") + (version "0.11.0.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/tasty/tasty-" + version + ".tar.gz")) + (sha256 + (base32 + "1chapivmmwsb1ghwagvdm80bfj3hdk75m94z4p212ng2i4ghpjkx")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-stm" ,ghc-stm) + ("ghc-mtl" ,ghc-mtl) + ("ghc-tagged" ,ghc-tagged) + ("ghc-regex-tdfa-rc" ,ghc-regex-tdfa-rc) + ("ghc-optparse-applicative" ,ghc-optparse-applicative) + ("ghc-unbounded-delays" ,ghc-unbounded-delays) + ("ghc-async" ,ghc-async) + ("ghc-ansi-terminal" ,ghc-ansi-terminal) + ("ghc-clock-bootstrap" ,ghc-clock-bootstrap))) + (home-page "http://documentup.com/feuerbach/tasty") + (synopsis "Modern and extensible testing framework") + (description "Tasty is a modern testing framework for Haskell. It lets +you combine your unit tests, golden tests, QuickCheck/SmallCheck properties, +and any other types of tests into a single test suite.") + (license expat))) + +(define-public ghc-tasty-hunit + (package + (name "ghc-tasty-hunit") + (version "0.9.2") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/tasty-hunit/tasty-hunit-" + version + ".tar.gz")) + (sha256 + (base32 + "08qnxaw34wfnzi9irs1jd4d0zczqm3k5ffkd4zwhkz0dflmgq7mf")))) + (build-system haskell-build-system) + (inputs + `(("ghc-tasty" ,ghc-tasty))) + (home-page "http://documentup.com/feuerbach/tasty") + (synopsis "HUnit support for the Tasty test framework") + (description "This package provides HUnit support for the Tasty Haskell +test framework.") + (license expat))) + +(define-public ghc-cookie + (package + (name "ghc-cookie") + (version "0.4.1.6") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/cookie/cookie-" + version + ".tar.gz")) + (sha256 + (base32 + "0b6ym6fn29p5az4dwydy036lxj131kagrmgb93w4bbkqfkds8b9s")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-old-locale" ,ghc-old-locale))) + (inputs + `(("ghc-blaze-builder" ,ghc-blaze-builder) + ("ghc-text" ,ghc-text) + ("ghc-data-default-class" ,ghc-data-default-class) + ("ghc-hunit" ,ghc-hunit) + ("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-tasty" ,ghc-tasty) + ("ghc-tasty-hunit" ,ghc-tasty-hunit) + ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck))) + (home-page "http://github.com/snoyberg/cookie") + (synopsis "HTTP cookie parsing and rendering") + (description "HTTP cookie parsing and rendering library for Haskell.") + (license bsd-3))) + +(define-public ghc-scientific + (package + (name "ghc-scientific") + (version "0.3.4.2") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/scientific/scientific-" + version + ".tar.gz")) + (sha256 + (base32 + "0mimdkva0cgzaychr6whv9if29z0r5wwhkss9bmd4rz8kq1kgngn")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-hashable" ,ghc-hashable) + ("ghc-vector" ,ghc-vector))) + (inputs + `(("ghc-text" ,ghc-text) + ("ghc-tasty" ,ghc-tasty) + ("ghc-tasty-ant-xml" ,ghc-tasty-ant-xml) + ("ghc-tasty-hunit" ,ghc-tasty-hunit) + ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck) + ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck) + ("ghc-smallcheck" ,ghc-smallcheck) + ("ghc-quickcheck" ,ghc-quickcheck))) + (home-page "https://github.com/basvandijk/scientific") + (synopsis "Numbers represented using scientific notation") + (description "This package provides @code{Data.Scientific}, which provides +the number type @code{Scientific}. Scientific numbers are arbitrary precision +and space efficient. They are represented using +@uref{http://en.wikipedia.org/wiki/Scientific_notation, scientific +notation}.") + (license bsd-3))) + +(define-public ghc-aeson + (package + (name "ghc-aeson") + (version "0.10.0.0") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/aeson/aeson-" + version + ".tar.gz")) + (sha256 + (base32 + "19kp33rfivr4d3myyr8xn803wd7p8x5nc4wb3qvlgjwgyqjaxvrz")))) + (build-system haskell-build-system) + (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing. + (propagated-inputs + `(("ghc-attoparsec" ,ghc-attoparsec) + ("ghc-dlist" ,ghc-dlist) + ("ghc-mtl" ,ghc-mtl) + ("ghc-scientific" ,ghc-scientific) + ("ghc-syb" ,ghc-syb) + ("ghc-vector" ,ghc-vector))) + (inputs + `(("ghc-hashable" ,ghc-hashable) + ("ghc-text" ,ghc-text) + ("ghc-unordered-containers" ,ghc-unordered-containers) + ("ghc-hunit" ,ghc-hunit) + ("ghc-quickcheck" ,ghc-quickcheck))) + (home-page "https://github.com/bos/aeson") + (synopsis "Fast JSON parsing and encoding") + (description "This package provides a JSON parsing and encoding library +for Haskell, optimized for ease of use and high performance. (A note on +naming: in Greek mythology, Aeson was the father of Jason.)") + (license bsd-3))) + +(define-public ghc-wai + (package + (name "ghc-wai") + (version "3.0.4.0") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/wai/wai-" + version + ".tar.gz")) + (sha256 + (base32 + "1551n0g0n22vml33v0jz5xgjcy6j79algvsdqg11a1z5ljjrjlqf")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-bytestring-builder" ,ghc-bytestring-builder) + ("ghc-unix-compat" ,ghc-unix-compat) + ("ghc-vault" ,ghc-vault) + ("ghc-blaze-builder" ,ghc-blaze-builder) + ("ghc-network" ,ghc-network))) + (inputs + `(("ghc-quickcheck" ,ghc-quickcheck) + ("ghc-hunit" ,ghc-hunit) + ("ghc-hspec" ,ghc-hspec) + ("ghc-text" ,ghc-text) + ("ghc-http-types" ,ghc-http-types))) + (home-page "https://hackage.haskell.org/package/wai") + (synopsis "Web application interface for Haskell") + (description "This package provides a Web Application Interface (WAI) +library for the Haskell language. It defines a common protocol for +communication between web applications and web servers.") + (license bsd-3))) + +(define-public ghc-wai-logger + (package + (name "ghc-wai-logger") + (version "2.2.4.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/wai-logger/wai-logger-" + version + ".tar.gz")) + (sha256 + (base32 + "1s6svvy3ci4j1dj1jaw8hg628miwj8f5gpy9n8d8hpsaxav6nzgk")))) + (build-system haskell-build-system) + (arguments `(#:tests? #f)) ; FIXME: Tests cannot find libraries exported + ; by propagated-inputs. + (propagated-inputs + `(("ghc-auto-update" ,ghc-auto-update) + ("ghc-byteorder" ,ghc-byteorder) + ("ghc-easy-file" ,ghc-easy-file) + ("ghc-unix-time" ,ghc-unix-time))) + (inputs + `(("ghc-blaze-builder" ,ghc-blaze-builder) + ("ghc-case-insensitive" ,ghc-case-insensitive) + ("ghc-fast-logger" ,ghc-fast-logger) + ("ghc-http-types" ,ghc-http-types) + ("ghc-network" ,ghc-network) + ("ghc-wai" ,ghc-wai))) + (home-page "http://hackage.haskell.org/package/wai-logger") + (synopsis "Logging system for WAI") + (description "This package provides the logging system for WAI.") + (license bsd-3))) + +(define-public ghc-wai-extra + (package + (name "ghc-wai-extra") + (version "3.0.11.1") + (source + (origin + (method url-fetch) + (uri (string-append + "http://hackage.haskell.org/package/wai-extra/wai-extra-" + version + ".tar.gz")) + (sha256 + (base32 + "1kr2s5qyx1dvnwr372h7pca4sgxjv0pdx96xkgsfi180h3mb0vq8")))) + (build-system haskell-build-system) + (propagated-inputs + `(("ghc-ansi-terminal" ,ghc-ansi-terminal) + ("ghc-base64-bytestring" ,ghc-base64-bytestring) + ("ghc-cookie" ,ghc-cookie) + ("ghc-blaze-builder" ,ghc-blaze-builder) + ("ghc-network" ,ghc-network) + ("ghc-lifted-base" ,ghc-lifted-base) + ("ghc-streaming-commons" ,ghc-streaming-commons) + ("ghc-stringsearch" ,ghc-stringsearch) + ("ghc-resourcet" ,ghc-resourcet) + ("ghc-fast-logger" ,ghc-fast-logger) + ("ghc-wai-logger" ,ghc-wai-logger) + ("ghc-zlib" ,ghc-zlib) + ("ghc-word8" ,ghc-word8) + ("ghc-iproute" ,ghc-iproute) + ("ghc-void" ,ghc-void))) + (inputs + `(("ghc-wai" ,ghc-wai) + ("ghc-http-types" ,ghc-http-types) + ("ghc-text" ,ghc-text) + ("ghc-case-insensitive" ,ghc-case-insensitive) + ("ghc-data-default-class" ,ghc-data-default-class) + ("ghc-unix-compat" ,ghc-unix-compat) + ("ghc-vault" ,ghc-vault) + ("ghc-aeson" ,ghc-aeson) + ("ghc-hspec" ,ghc-hspec) + ("ghc-hunit" ,ghc-hunit))) + (home-page "http://github.com/yesodweb/wai") + (synopsis "Some basic WAI handlers and middleware") + (description "This library provides basic WAI handlers and middleware +functionality.") + (license expat))) + +(define-public idris + (package + (name "idris") + (version "0.9.19.1") + (source + (origin + (method url-fetch) + (uri (string-append "https://hackage.haskell.org/package/idris-" + version "/idris-" version ".tar.gz")) + (sha256 + (base32 + "10641svdsjlxbxmbvylpia04cz5nn9486lpiay8ibqcrc1792qgc")) + (modules '((guix build utils))) + (snippet + '(substitute* "idris.cabal" + ;; Package description file has a too-tight version restriction, + ;; rendering it incompatible with GHC 7.10.2. This is fixed + ;; upstream. See + ;; <https://github.com/idris-lang/Idris-dev/issues/2734>. + (("vector < 0.11") "vector < 0.12"))))) + (build-system haskell-build-system) + (arguments + `(#:phases (modify-phases %standard-phases + (add-before 'configure 'patch-cc-command + (lambda _ + (setenv "CC" "gcc")))))) + (inputs + `(("gmp" ,gmp) + ("ncurses" ,ncurses) + ("ghc-annotated-wl-pprint" ,ghc-annotated-wl-pprint) + ("ghc-ansi-terminal" ,ghc-ansi-terminal) + ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint) + ("ghc-base64-bytestring" ,ghc-base64-bytestring) + ("ghc-blaze-html" ,ghc-blaze-html) + ("ghc-blaze-markup" ,ghc-blaze-markup) + ("ghc-cheapskate" ,ghc-cheapskate) + ("ghc-fingertree" ,ghc-fingertree) + ("ghc-mtl" ,ghc-mtl) + ("ghc-network" ,ghc-network) + ("ghc-optparse-applicative" ,ghc-optparse-applicative) + ("ghc-parsers" ,ghc-parsers) + ("ghc-safe" ,ghc-safe) + ("ghc-split" ,ghc-split) + ("ghc-text" ,ghc-text) + ("ghc-trifecta" ,ghc-trifecta) + ("ghc-uniplate" ,ghc-uniplate) + ("ghc-unordered-containers" ,ghc-unordered-containers) + ("ghc-utf8-string" ,ghc-utf8-string) + ("ghc-vector-binary-instances" ,ghc-vector-binary-instances) + ("ghc-vector" ,ghc-vector) + ("ghc-zip-archive" ,ghc-zip-archive) + ("ghc-zlib" ,ghc-zlib))) + (home-page "http://www.idris-lang.org") + (synopsis "General purpose language with full dependent types") + (description "Idris is a general purpose language with full dependent +types. It is compiled, with eager evaluation. Dependent types allow types to +be predicated on values, meaning that some aspects of a program's behaviour +can be specified precisely in the type. The language is closely related to +Epigram and Agda.") + (license bsd-3))) + ;;; haskell.scm ends here diff --git a/gnu/packages/less.scm b/gnu/packages/less.scm index a1914b6953..efdf8ab0c4 100644 --- a/gnu/packages/less.scm +++ b/gnu/packages/less.scm @@ -26,7 +26,7 @@ (define-public less (package (name "less") - (version "451") + (version "481") (source (origin (method url-fetch) @@ -34,7 +34,7 @@ version ".tar.gz")) (sha256 (base32 - "0mszdd9m1dsbg59pav62swg9f87xmjpfspcw2jsazzksciy2is4z")))) + "19fxj0h10y5bhr3a1xa7kqvnwl44db3sdypz8jxl1q79yln8z8rz")))) (build-system gnu-build-system) (inputs `(("ncurses" ,ncurses))) (home-page "https://www.gnu.org/software/less/") diff --git a/gnu/packages/linux.scm b/gnu/packages/linux.scm index 2c2ebab2e4..ecb0fd090b 100644 --- a/gnu/packages/linux.scm +++ b/gnu/packages/linux.scm @@ -210,7 +210,7 @@ for SYSTEM, or #f if there is no configuration for SYSTEM." #f))) (define-public linux-libre - (let* ((version "4.2.3") + (let* ((version "4.2.4") (build-phase '(lambda* (#:key system inputs #:allow-other-keys #:rest args) ;; Apply the neat patch. @@ -283,7 +283,7 @@ for SYSTEM, or #f if there is no configuration for SYSTEM." (uri (linux-libre-urls version)) (sha256 (base32 - "1xpx32k6bzxqg5y8lyaana97jjcli00iyqklh5fdhirfvjb9dimd")))) + "11r9yhi4c2zwfb8i21zk014gcm1kvnabq410wjy6g6a015d5v37w")))) (build-system gnu-build-system) (native-inputs `(("perl" ,perl) ("bc" ,bc) diff --git a/gnu/packages/man.scm b/gnu/packages/man.scm index 31598d0168..46b7d8b9b0 100644 --- a/gnu/packages/man.scm +++ b/gnu/packages/man.scm @@ -162,7 +162,7 @@ Linux kernel and C library interfaces employed by user-space programs.") (define-public help2man (package (name "help2man") - (version "1.47.1") + (version "1.47.2") (source (origin (method url-fetch) @@ -170,7 +170,7 @@ Linux kernel and C library interfaces employed by user-space programs.") version ".tar.xz")) (sha256 (base32 - "01ib718afwc28bmh1n0p5h7245vs3rrfm7bj1sq4avmh1kv2d6y5")))) + "0z1zgw6k1fba59fii6ksfi1g2gci6i4ysa3kdfh3j475fdkn1if4")))) (build-system gnu-build-system) (arguments `(;; There's no `check' target. #:tests? #f)) diff --git a/gnu/packages/music.scm b/gnu/packages/music.scm index a72f7543dd..c693f0faf0 100644 --- a/gnu/packages/music.scm +++ b/gnu/packages/music.scm @@ -1,5 +1,6 @@ ;;; GNU Guix --- Functional package management for GNU ;;; Copyright © 2015 Ricardo Wurmus <rekado@elephly.net> +;;; Copyright © 2015 Paul van der Walt <paul@denknerd.org> ;;; ;;; This file is part of GNU Guix. ;;; @@ -33,6 +34,7 @@ #:use-module (gnu packages base) ;libbdf #:use-module (gnu packages boost) #:use-module (gnu packages bison) + #:use-module (gnu packages cdrom) #:use-module (gnu packages code) #:use-module (gnu packages check) #:use-module (gnu packages compression) @@ -55,6 +57,7 @@ #:use-module (gnu packages linux) ; for alsa-utils #:use-module (gnu packages man) #:use-module (gnu packages mp3) + #:use-module (gnu packages ncurses) #:use-module (gnu packages netpbm) #:use-module (gnu packages pdf) #:use-module (gnu packages perl) @@ -67,6 +70,7 @@ #:use-module (gnu packages tcl) #:use-module (gnu packages texinfo) #:use-module (gnu packages texlive) + #:use-module (gnu packages video) #:use-module (gnu packages web) #:use-module (gnu packages xml) #:use-module (gnu packages xorg) @@ -74,6 +78,67 @@ #:use-module (gnu packages zip) #:use-module ((srfi srfi-1) #:select (last))) +(define-public cmus + (package + (name "cmus") + (version "2.7.1") + (source (origin + (method url-fetch) + (uri (string-append + "https://github.com/" name "/" name "/archive/v" + version ".tar.gz")) + (file-name (string-append name "-" version ".tar.gz")) + (sha256 + (base32 + "0raixgjavkm7hxppzsc5zqbfbh2bhjcmbiplhnsxsmyj8flafyc1")))) + (build-system gnu-build-system) + (arguments + `(#:tests? #f ; cmus does not include tests + #:phases + (modify-phases %standard-phases + (replace + 'configure + (lambda* (#:key outputs #:allow-other-keys) + (let ((out (assoc-ref outputs "out"))) + + ;; It's an idiosyncratic configure script that doesn't + ;; understand --prefix=..; it wants prefix=.. instead. + (zero? + (system* "./configure" + (string-append "prefix=" out))))))))) + ;; TODO: cmus optionally supports the following formats, which haven't yet + ;; been added to Guix: + ;; + ;; - Roar, libroar + ;; + ;; - DISCID_LIBS, apparently different from cd-discid which is included in + ;; Guix. See <http://sourceforge.net/projects/discid/> + (native-inputs + `(("pkg-config" ,pkg-config))) + (inputs + `(("alsa-lib" ,alsa-lib) + ("ao" ,ao) + ("ffmpeg" ,ffmpeg) + ("flac" ,flac) + ("jack" ,jack-1) + ("libcddb" ,libcddb) + ("libcdio-paranoia" ,libcdio-paranoia) + ("libcue" ,libcue) + ("libmad" ,libmad) + ("libmodplug" ,libmodplug) + ("libmpcdec" ,libmpcdec) + ("libsamplerate" ,libsamplerate) + ("libvorbis" ,libvorbis) + ("ncurses" ,ncurses) + ("opusfile" ,opusfile) + ("pulseaudio" ,pulseaudio) + ("wavpack" ,wavpack))) + (home-page "https://cmus.github.io/") + (synopsis "Small console music player") + (description "Cmus is a small and fast console music player. It supports +many input formats and provides a customisable Vi-style user interface.") + (license license:gpl2+))) + (define-public hydrogen (package (name "hydrogen") diff --git a/gnu/packages/ntp.scm b/gnu/packages/ntp.scm index a53d98efdd..9e6db67e3e 100644 --- a/gnu/packages/ntp.scm +++ b/gnu/packages/ntp.scm @@ -35,7 +35,7 @@ (define-public ntp (package (name "ntp") - (version "4.2.8p3") + (version "4.2.8p4") (source (origin (method url-fetch) (uri (string-append @@ -44,7 +44,7 @@ "/ntp-" version ".tar.gz")) (sha256 (base32 - "13zkzcvjm5kbxl4xbcmaq07slplhmpkgahzcqnqlba3cxpra9341")) + "1fgxbhv0wyiivi6kh5zpzrd0yqmc48z7d3zmjspw9lj84mbn2s8d")) (modules '((guix build utils))) (snippet '(begin diff --git a/gnu/packages/patches/evilwm-lost-focus-bug.patch b/gnu/packages/patches/evilwm-lost-focus-bug.patch new file mode 100644 index 0000000000..af24af8fe9 --- /dev/null +++ b/gnu/packages/patches/evilwm-lost-focus-bug.patch @@ -0,0 +1,18 @@ +evilwm may sometimes lose focus after closing a window. This means that +evilwm stops responding to keyboard shortcuts, and if no other window is open +which the mouse can be moved over to regain focus evilwm becomes unusable and +has to be restarted. + +Patch derived from discussion at +https://wiki.archlinux.org/index.php/Evilwm#Lost_focus_bug_fix + +--- evilwm-1.1.1/client.c ++++ evilwm-1.1.1/client.c +@@ -172,6 +172,7 @@ + * _NET_WM_STATE) */ + if (c->remove) { + LOG_DEBUG("setting WithdrawnState\n"); ++ XSetInputFocus(dpy, PointerRoot, RevertToPointerRoot, CurrentTime); + set_wm_state(c, WithdrawnState); + ewmh_withdraw_client(c); + } else { diff --git a/gnu/packages/python.scm b/gnu/packages/python.scm index 9db578ed96..54d882cb6e 100644 --- a/gnu/packages/python.scm +++ b/gnu/packages/python.scm @@ -3060,6 +3060,43 @@ that client code uses to construct the grammar directly in Python code.") (define-public python2-numpydoc (package-with-python2 python-numpydoc)) +(define-public python-numexpr + (package + (name "python-numexpr") + (version "2.4.4") + (source + (origin + (method url-fetch) + (uri (string-append "https://pypi.python.org/packages/source/" + "n/numexpr/numexpr-" version ".tar.gz")) + (sha256 + (base32 + "0nsnff5312fm38w6dm34bw7ghfqqy8vl9gig0al963h4mz8zm8nz")))) + (build-system python-build-system) + (arguments `(#:tests? #f)) ; no tests included + (propagated-inputs + `(("python-numpy" ,python-numpy))) + (home-page "https://github.com/pydata/numexpr") + (synopsis "Fast numerical expression evaluator for NumPy") + (description + "Numexpr is a fast numerical expression evaluator for NumPy. With it, +expressions that operate on arrays are accelerated and use less memory than +doing the same calculation in Python. In addition, its multi-threaded +capabilities can make use of all your cores, which may accelerate +computations, most specially if they are not memory-bounded (e.g. those using +transcendental functions).") + (license license:expat))) + +(define-public python2-numexpr + (let ((numexpr (package-with-python2 python-numexpr))) + (package (inherit numexpr) + ;; Make sure to use special packages for Python 2 instead + ;; of those automatically rewritten by package-with-python2. + (propagated-inputs + `(("python2-numpy" ,python2-numpy) + ,@(alist-delete "python-numpy" + (package-propagated-inputs numexpr))))))) + (define-public python-matplotlib (package (name "python-matplotlib") diff --git a/gnu/packages/statistics.scm b/gnu/packages/statistics.scm index f854a44d96..0c0464c2b9 100644 --- a/gnu/packages/statistics.scm +++ b/gnu/packages/statistics.scm @@ -24,6 +24,7 @@ #:use-module (guix utils) #:use-module (guix build-system gnu) #:use-module (guix build-system r) + #:use-module (guix build-system python) #:use-module (gnu packages) #:use-module (gnu packages compression) #:use-module (gnu packages gcc) @@ -35,11 +36,14 @@ #:use-module (gnu packages pcre) #:use-module (gnu packages perl) #:use-module (gnu packages pkg-config) + #:use-module (gnu packages python) #:use-module (gnu packages readline) #:use-module (gnu packages texlive) #:use-module (gnu packages texinfo) #:use-module (gnu packages base) - #:use-module (gnu packages xorg)) + #:use-module (gnu packages xorg) + #:use-module (gnu packages zip) + #:use-module (srfi srfi-1)) (define-public r (package @@ -933,3 +937,119 @@ times.") large data (e.g. 100GB in RAM), fast ordered joins, fast add/modify/delete of columns by group, column listing and fast file reading.") (license license:gpl2+))) + +(define-public python-patsy + (package + (name "python-patsy") + (version "0.4.0") + (source (origin + (method url-fetch) + (uri (string-append "https://pypi.python.org/packages/source/" + "p/patsy/patsy-" version ".zip")) + (sha256 + (base32 + "1kbs996xc2haxalmhd19rr1wh5fa4gbbxf81czkf5w4kam7h7wz4")))) + (build-system python-build-system) + (arguments + `(#:phases + (modify-phases %standard-phases + (replace 'check (lambda _ (zero? (system* "nosetests" "-v")))) + (add-after 'unpack 'prevent-generation-of-egg-archive + (lambda _ + (substitute* "setup.py" + (("from setuptools import setup") + "from distutils.core import setup")) + #t))))) + (propagated-inputs + `(("python-numpy" ,python-numpy) + ("python-scipy" ,python-scipy) + ("python-six" ,python-six))) + (native-inputs + `(("python-nose" ,python-nose) + ("unzip" ,unzip))) + (home-page "https://github.com/pydata/patsy") + (synopsis "Describe statistical models and build design matrices") + (description + "Patsy is a Python package for describing statistical models and for +building design matrices.") + ;; The majority of the code is distributed under BSD-2. The module + ;; patsy.compat contains code derived from the Python standard library, + ;; and is covered by the PSFL. + (license (list license:bsd-2 license:psfl)))) + +(define-public python2-patsy + (let ((patsy (package-with-python2 python-patsy))) + (package (inherit patsy) + (native-inputs + `(("python2-setuptools" ,python2-setuptools) + ,@(package-native-inputs patsy))) + (propagated-inputs + `(("python2-numpy" ,python2-numpy) + ("python2-scipy" ,python2-scipy) + ,@(alist-delete "python-numpy" + (alist-delete "python-scipy" + (package-propagated-inputs patsy)))))))) + +(define-public python-statsmodels + (package + (name "python-statsmodels") + (version "0.6.1") + (source + (origin + (method url-fetch) + (uri (string-append "https://pypi.python.org/packages/source/" + "s/statsmodels/statsmodels-" version ".tar.gz")) + (sha256 + (base32 + "0xn67sqr0cc1lmlhzm71352hrb4hw7g318p5ff5q97pc98vl8kmy")))) + (build-system python-build-system) + (arguments + `(#:phases + (modify-phases %standard-phases + ;; tests must be run after installation + (delete 'check) + (add-after 'unpack 'set-matplotlib-backend-to-agg + (lambda _ + ;; Set the matplotlib backend to Agg to avoid problems using the + ;; GTK backend without a display. + (substitute* (find-files "statsmodels/graphics/tests" "\\.py") + (("import matplotlib\\.pyplot as plt" line) + (string-append "import matplotlib;matplotlib.use('Agg');" + line))) + #t)) + (add-after 'install 'check + (lambda _ + (with-directory-excursion "/tmp" + (zero? (system* "nosetests" + "--stop" + "-v" "statsmodels")))))))) + (propagated-inputs + `(("python-numpy" ,python-numpy) + ("python-scipy" ,python-scipy) + ("python-pandas" ,python-pandas) + ("python-patsy" ,python-patsy) + ("python-matplotlib" ,python-matplotlib))) + (native-inputs + `(("python-cython" ,python-cython) + ("python-nose" ,python-nose) + ("python-sphinx" ,python-sphinx))) + (home-page "http://statsmodels.sourceforge.net/") + (synopsis "Statistical modeling and econometrics in Python") + (description + "Statsmodels is a Python package that provides a complement to scipy for +statistical computations including descriptive statistics and estimation and +inference for statistical models.") + (license license:bsd-3))) + +(define-public python2-statsmodels + (let ((stats (package-with-python2 python-statsmodels))) + (package (inherit stats) + (propagated-inputs + `(("python2-numpy" ,python2-numpy) + ("python2-scipy" ,python2-scipy) + ("python2-pandas" ,python2-pandas) + ("python2-patsy" ,python2-patsy) + ("python2-matplotlib" ,python2-matplotlib))) + (native-inputs + `(("python2-setuptools" ,python2-setuptools) + ,@(package-native-inputs stats)))))) diff --git a/gnu/packages/video.scm b/gnu/packages/video.scm index ced17f0e30..a95fe83bbd 100644 --- a/gnu/packages/video.scm +++ b/gnu/packages/video.scm @@ -3,6 +3,7 @@ ;;; Copyright © 2014, 2015 David Thompson <davet@gnu.org> ;;; Copyright © 2014, 2015 Mark H Weaver <mhw@netris.org> ;;; Copyright © 2015 Taylan Ulrich Bayırlı/Kammer <taylanbayirli@gmail.com> +;;; Copyright © 2015 Efraim Flashner <efraim@flashner.co.il> ;;; ;;; This file is part of GNU Guix. ;;; @@ -584,7 +585,7 @@ treaming protocols.") (define-public mplayer (package (name "mplayer") - (version "1.1.1") + (version "1.2") (source (origin (method url-fetch) (uri (string-append @@ -592,7 +593,7 @@ treaming protocols.") version ".tar.xz")) (sha256 (base32 - "0xlcg7rszrwmw29wqr0plsw5d1rq0hb7vjsq7bmmfsly2z1wg3yf")))) + "1dp2lbxyhgjr8sn91kf6xw3w6d7dsgq08v4dgrq20afz1bqzdrzz")))) (build-system gnu-build-system) ;; FIXME: Add additional inputs once available. (native-inputs @@ -601,8 +602,11 @@ treaming protocols.") `(("alsa-lib" ,alsa-lib) ("cdparanoia" ,cdparanoia) ("fontconfig" ,fontconfig) + ("ffmpeg", ffmpeg) ("freetype" ,freetype) ("lame" ,lame) + ("libdvdcss", libdvdcss) + ("libdvdnav", libdvdnav) ("libmpg123" ,mpg123) ; audio codec for MP3 ;; ("giflib" ,giflib) ; uses QuantizeBuffer, requires version >= 5 ("libjpeg" ,libjpeg) @@ -639,7 +643,7 @@ treaming protocols.") "./configure" (string-append "--extra-cflags=-I" libx11 "/include") ; to detect libx11 - "--disable-tremor-internal" ; forces external libvorbis + "--disable-ffmpeg_a" ; disables bundled ffmpeg (string-append "--prefix=" out) ;; Enable runtime cpu detection where supported, ;; and choose a suitable target. diff --git a/gnu/packages/wm.scm b/gnu/packages/wm.scm index e0859ccf30..db5fa1e3da 100644 --- a/gnu/packages/wm.scm +++ b/gnu/packages/wm.scm @@ -3,6 +3,7 @@ ;;; Copyright © 2015 Siniša Biđin <sinisa@bidin.eu> ;;; Copyright © 2015 Eric Bavier <bavier@member.fsf.org> ;;; Copyright © 2015 xd1le <elisp.vim@gmail.com> +;;; Copyright © 2015 Paul van der Walt <paul@denknerd.org> ;;; ;;; This file is part of GNU Guix. ;;; @@ -22,6 +23,7 @@ (define-module (gnu packages wm) #:use-module (guix licenses) #:use-module (guix packages) + #:use-module (gnu packages) #:use-module (gnu packages linux) #:use-module (guix build-system gnu) #:use-module (guix build-system haskell) @@ -190,10 +192,19 @@ developers.") (source (origin (method url-fetch) (uri (string-append "http://hackage.haskell.org/package/xmonad/" - "xmonad-" version ".tar.gz")) + name "-" version ".tar.gz")) (sha256 (base32 - "1pfjssamiwpwjp1qqkm9m9p9s35pv381m0cwg6jxg0ppglibzq1r")))) + "1pfjssamiwpwjp1qqkm9m9p9s35pv381m0cwg6jxg0ppglibzq1r")) + (modules '((guix build utils))) + (snippet + ;; Here we update the constraints on the utf8-string package in + ;; the Cabal file. We allow a newer version which is compatible + ;; with GHC 7.10.2. The same change is applied on Hackage. See + ;; <https://hackage.haskell.org/package/xmonad-0.11.1/revisions/>. + '(substitute* "xmonad.cabal" + (("utf8-string >= 0.3 && < 0.4") + "utf8-string >= 0.3 && < 1.1"))))) (build-system haskell-build-system) (inputs `(("ghc-mtl" ,ghc-mtl) @@ -232,7 +243,7 @@ tiled on several screens.") (define-public ghc-xmonad-contrib (package (name "ghc-xmonad-contrib") - (version "0.11.3") + (version "0.11.4") (source (origin (method url-fetch) @@ -240,10 +251,11 @@ tiled on several screens.") "xmonad-contrib-" version ".tar.gz")) (sha256 (base32 - "14h9vr33yljymswj50wbimav263y9abdcgi07mvfis0zd08rxqxa")))) + "1g5cw9vvnfbiyi599fngk02zlmdhrf82x0bndhypkn6kybab6yd3")))) (build-system haskell-build-system) (propagated-inputs `(("ghc-mtl" ,ghc-mtl) + ("ghc-old-time" ,ghc-old-time) ("ghc-random" ,ghc-random) ("ghc-utf8-string" ,ghc-utf8-string) ("ghc-extensible-exceptions" ,ghc-extensible-exceptions) @@ -256,3 +268,46 @@ tiled on several screens.") "Third party tiling algorithms, configurations, and scripts to Xmonad, a tiling window manager for X.") (license bsd-3))) + +(define-public evilwm + (package + (name "evilwm") + (version "1.1.1") + (source + (origin + (method url-fetch) + (uri (string-append "http://www.6809.org.uk/evilwm/evilwm-" + version ".tar.gz")) + (sha256 + (base32 + "0ak0yajzk3v4dg5wmaghv6acf7v02a4iw8qxmq5yw5ard8lrqn3r")) + (patches (map search-patch '("evilwm-lost-focus-bug.patch"))))) + (build-system gnu-build-system) + (inputs + `(("libx11" ,libx11) + ("libxext" ,libxext) + ("libxrandr" ,libxrandr))) + (arguments + `(#:modules ((srfi srfi-26) + (guix build utils) + (guix build gnu-build-system)) + #:make-flags (let ((inputs (map (cut assoc-ref %build-inputs <>) + '("libx11" "libxext" "libxrandr"))) + (join (lambda (proc strs) + (string-join (map proc strs) " "))) + (dash-I (cut string-append "-I" <> "/include")) + (dash-L (cut string-append "-L" <> "/lib"))) + `("desktopfilesdir=$(prefix)/share/xsessions" + ,(string-append "prefix=" (assoc-ref %outputs "out")) + ,(string-append "CPPFLAGS=" (join dash-I inputs)) + ,(string-append "LDFLAGS=" (join dash-L inputs)))) + #:tests? #f ;no tests + #:phases (modify-phases %standard-phases + (delete 'configure)))) ;no configure script + (home-page "http://www.6809.org.uk/evilwm/") + (synopsis "Minimalist window manager for the X Window System") + (description + "evilwm is a minimalist window manager based on aewm, extended to feature +many keyboard controls with repositioning and maximize toggles, solid window +drags, snap-to-border support, and virtual desktops.") + (license (x11-style "file:///README")))) diff --git a/gnu/packages/xiph.scm b/gnu/packages/xiph.scm index c4db640d0f..705ebe1d73 100644 --- a/gnu/packages/xiph.scm +++ b/gnu/packages/xiph.scm @@ -4,6 +4,7 @@ ;;; Copyright © 2013 David Thompson <dthompson2@worcester.edu> ;;; Copyright © 2014 Sree Harsha Totakura <sreeharsha@totakura.in> ;;; Copyright © 2014 Mark H Weaver <mhw@netris.org> +;;; Copyright © 2015 Paul van der Walt <paul@denknerd.org> ;;; ;;; This file is part of GNU Guix. ;;; @@ -46,6 +47,7 @@ libkate vorbis-tools opus + opusfile opus-tools)) (define libogg @@ -341,6 +343,34 @@ decoding .opus files.") (license license:bsd-3) (home-page "http://www.opus-codec.org"))) +(define opusfile + (package + (name "opusfile") + (version "0.6") + (source (origin + (method url-fetch) + (uri (string-append + "http://downloads.xiph.org/releases/opus/opusfile-" version + ".tar.gz")) + (sha256 + (base32 + "19iys2kld75k0210b807i4illrdmj3cmmnrgxlc9y4vf6mxp2a14")))) + (build-system gnu-build-system) + (propagated-inputs + `(("opus" ,opus))) + (native-inputs + `(("pkg-config" ,pkg-config))) + (inputs + `(("libogg" ,libogg) + ("openssl" ,openssl))) + (synopsis "Versatile audio codec") + (description + "The opusfile library provides seeking, decode, and playback of Opus +streams in the Ogg container (.opus files) including over http(s) on posix and +windows systems.") + (license license:bsd-3) + (home-page "http://www.opus-codec.org"))) + (define-public icecast (package (name "icecast") diff --git a/gnu/packages/xorg.scm b/gnu/packages/xorg.scm index f90c75ae10..b85a9c3aaf 100644 --- a/gnu/packages/xorg.scm +++ b/gnu/packages/xorg.scm @@ -1,7 +1,7 @@ ;;; GNU Guix --- Functional package management for GNU ;;; Copyright © 2013, 2014 Andreas Enge <andreas@enge.fr> ;;; Copyright © 2014, 2015 Mark H Weaver <mhw@netris.org> -;;; Copyright © 2014 Eric Bavier <bavier@member.fsf.org> +;;; Copyright © 2014, 2015 Eric Bavier <bavier@member.fsf.org> ;;; Copyright © 2015 Ludovic Courtès <ludo@gnu.org> ;;; Copyright © 2015 Eric Dvorsak <eric@dvorsak.fr> ;;; @@ -413,6 +413,23 @@ provided.") "16ic8wfwwr3jicaml7b5a0sk6plcgc1kg84w02881yhwmqm3nicb")))) (build-system gnu-build-system) (native-inputs `(("pkg-config" ,pkg-config))) + (arguments + `(#:phases (modify-phases %standard-phases + (add-after + 'install 'install-fonts-dir + ;; The X font server will not add directories to the font + ;; path unless they contain a "fonts.dir" file, so add some + ;; dummy files. + (lambda* (#:key outputs #:allow-other-keys) + (let ((out (assoc-ref outputs "out"))) + (for-each (lambda (d) + (call-with-output-file + (string-append out "/share/fonts/X11" + "/" d "/fonts.dir") + (lambda (p) + (format p "0~%")))) + '("75dpi" "100dpi" "misc" "cyrillic")) + #t)))))) (home-page "http://www.x.org/wiki/") (synopsis "Xorg font aliases") (description @@ -3826,6 +3843,34 @@ running on X server.") (license license:x11))) +(define-public xlsfonts + (package + (name "xlsfonts") + (version "1.0.5") + (source + (origin + (method url-fetch) + (uri (string-append + "mirror://xorg/individual/app/xlsfonts-" + version + ".tar.bz2")) + (sha256 + (base32 + "1yi774g6r1kafsbnxbkrwyndd3i60362ck1fps9ywz076pn5naa0")))) + (build-system gnu-build-system) + (inputs + `(("xproto" ,xproto) + ("libx11" ,libx11))) + (native-inputs + `(("pkg-config" ,pkg-config))) + (home-page "http://www.x.org/wiki/") + (synopsis "List fonts available from an X server") + (description + "xlsfonts lists fonts available from an X server via the X11 core +protocol.") + (license license:x11))) + + (define-public xmodmap (package (name "xmodmap") diff --git a/gnu/services/xorg.scm b/gnu/services/xorg.scm index 812cb3f725..3a57891a96 100644 --- a/gnu/services/xorg.scm +++ b/gnu/services/xorg.scm @@ -89,6 +89,10 @@ EndSection")) (apply mixed-text-file "xserver.conf" " Section \"Files\" + FontPath \"" font-alias "/share/fonts/X11/75dpi\" + FontPath \"" font-alias "/share/fonts/X11/100dpi\" + FontPath \"" font-alias "/share/fonts/X11/misc\" + FontPath \"" font-alias "/share/fonts/X11/cyrillic\" FontPath \"" font-adobe75dpi "/share/fonts/X11/75dpi\" ModulePath \"" xf86-video-vesa "/lib/xorg/modules/drivers\" ModulePath \"" xf86-video-fbdev "/lib/xorg/modules/drivers\" diff --git a/guix/gnu-maintenance.scm b/guix/gnu-maintenance.scm index e09df4b3ef..5af1b884ce 100644 --- a/guix/gnu-maintenance.scm +++ b/guix/gnu-maintenance.scm @@ -29,16 +29,10 @@ #:use-module (system foreign) #:use-module (guix http-client) #:use-module (guix ftp-client) - #:use-module (guix ui) #:use-module (guix utils) #:use-module (guix records) + #:use-module (guix upstream) #:use-module (guix packages) - #:use-module ((guix download) #:select (download-to-store)) - #:use-module (guix gnupg) - #:use-module (rnrs io ports) - #:use-module (guix base32) - #:use-module ((guix build utils) - #:select (substitute)) #:export (gnu-package-name gnu-package-mundane-name gnu-package-copyright-holder @@ -56,21 +50,12 @@ find-packages gnu-package? - gnu-release? - gnu-release-package - gnu-release-version - gnu-release-directory - gnu-release-files - releases latest-release gnu-release-archive-types gnu-package-name->name+version - download-tarball - package-update-path - package-update - update-package-source)) + %gnu-updater)) ;;; Commentary: ;;; @@ -218,13 +203,6 @@ network to check in GNU's database." ;;; Latest release. ;;; -(define-record-type* <gnu-release> gnu-release make-gnu-release - gnu-release? - (package gnu-release-package) - (version gnu-release-version) - (directory gnu-release-directory) - (files gnu-release-files)) - (define (ftp-server/directory project) "Return the FTP server and directory where PROJECT's tarball are stored." @@ -284,29 +262,6 @@ true." (gnu-package-name->name+version (sans-extension tarball)))) version)) -(define (coalesce-releases releases) - "Coalesce the elements of RELEASES that correspond to the same version." - (define (same-version? r1 r2) - (string=? (gnu-release-version r1) (gnu-release-version r2))) - - (define (release>? r1 r2) - (version>? (gnu-release-version r1) (gnu-release-version r2))) - - (fold (lambda (release result) - (match result - ((head . tail) - (if (same-version? release head) - (cons (gnu-release - (inherit release) - (files (append (gnu-release-files release) - (gnu-release-files head)))) - tail) - (cons release result))) - (() - (list release)))) - '() - (sort releases release>?))) - (define (releases project) "Return the list of releases of PROJECT as a list of release name/directory pairs. Example: (\"mit-scheme-9.0.1\" . \"/gnu/mit-scheme/stable.pkg/9.0.1\"). " @@ -319,13 +274,24 @@ pairs. Example: (\"mit-scheme-9.0.1\" . \"/gnu/mit-scheme/stable.pkg/9.0.1\"). (match directories (() (ftp-close conn) - (coalesce-releases result)) + (coalesce-sources result)) ((directory rest ...) (let* ((files (ftp-list conn directory)) (subdirs (filter-map (match-lambda - ((name 'directory . _) name) - (_ #f)) + ((name 'directory . _) name) + (_ #f)) files))) + (define (file->url file) + (string-append "ftp://" server directory "/" file)) + + (define (file->source file) + (let ((url (file->url file))) + (upstream-source + (package project) + (version (tarball->version file)) + (urls (list url)) + (signature-urls (list (string-append url ".sig")))))) + (loop (append (map (cut string-append directory "/" <>) subdirs) rest) @@ -335,15 +301,10 @@ pairs. Example: (\"mit-scheme-9.0.1\" . \"/gnu/mit-scheme/stable.pkg/9.0.1\"). ;; in /gnu/guile, filter out guile-oops and ;; guile-www; in mit-scheme, filter out binaries. (filter-map (match-lambda - ((file 'file . _) - (if (release-file? project file) - (gnu-release - (package project) - (version (tarball->version file)) - (directory directory) - (files (list file))) - #f)) - (_ #f)) + ((file 'file . _) + (and (release-file? project file) + (file->source file))) + (_ #f)) files) result)))))))) @@ -355,7 +316,7 @@ open (resp. close) FTP connections; this can be useful to reuse connections." (if (version>? a b) a b)) (define (latest-release a b) - (if (version>? (gnu-release-version a) (gnu-release-version b)) + (if (version>? (upstream-source-version a) (upstream-source-version b)) a b)) (define contains-digit? @@ -368,6 +329,17 @@ open (resp. close) FTP connections; this can be useful to reuse connections." (let-values (((server directory) (ftp-server/directory project))) (define conn (ftp-open server)) + (define (file->url file) + (string-append "ftp://" server directory "/" file)) + + (define (file->source file) + (let ((url (file->url file))) + (upstream-source + (package project) + (version (tarball->version file)) + (urls (list url)) + (signature-urls (list (string-append url ".sig")))))) + (let loop ((directory directory) (result #f)) (let* ((entries (ftp-list conn directory)) @@ -375,12 +347,12 @@ open (resp. close) FTP connections; this can be useful to reuse connections." ;; Filter out sub-directories that do not contain digits---e.g., ;; /gnuzilla/lang and /gnupg/patches. (subdirs (filter-map (match-lambda - (((? patch-directory-name? dir) - 'directory . _) - #f) - (((? contains-digit? dir) 'directory . _) - dir) - (_ #f)) + (((? patch-directory-name? dir) + 'directory . _) + #f) + (((? contains-digit? dir) 'directory . _) + dir) + (_ #f)) entries)) ;; Whether or not SUBDIRS is empty, compute the latest releases @@ -390,19 +362,14 @@ open (resp. close) FTP connections; this can be useful to reuse connections." (releases (filter-map (match-lambda ((file 'file . _) (and (release-file? project file) - (gnu-release - (package project) - (version - (tarball->version file)) - (directory directory) - (files (list file))))) + (file->source file))) (_ #f)) entries))) ;; Assume that SUBDIRS correspond to versions, and jump into the ;; one with the highest version number. (let* ((release (reduce latest-release #f - (coalesce-releases releases))) + (coalesce-sources releases))) (result (if (and result release) (latest-release release result) (or release result))) @@ -414,10 +381,18 @@ open (resp. close) FTP connections; this can be useful to reuse connections." (ftp-close conn) result))))))) -(define (gnu-release-archive-types release) - "Return the available types of archives for RELEASE---a list of strings such -as \"gz\" or \"xz\"." - (map file-extension (gnu-release-files release))) +(define (latest-release* package) + "Like 'latest-release', but ignore FTP errors that might occur when PACKAGE +is not actually a GNU package, or not hosted on ftp.gnu.org, or not under that +name (this is the case for \"emacs-auctex\", for instance.)" + (catch 'ftp-error + (lambda () + (latest-release package)) + (lambda (key port . rest) + (if (ftp-connection? port) + (ftp-close port) + (close-port port)) + #f))) (define %package-name-rx ;; Regexp for a package name, e.g., "foo-X.Y". Since TeXmacs uses @@ -431,121 +406,15 @@ as \"gz\" or \"xz\"." (values name+version #f) (values (match:substring match 1) (match:substring match 2))))) - -;;; -;;; Auto-update. -;;; +(define (non-emacs-gnu-package? package) + "Return true if PACKAGE is a non-Emacs GNU package. This excludes AucTeX, +for instance, whose releases are now uploaded to elpa.gnu.org." + (and (not (string-prefix? "emacs-" (package-name package))) + (gnu-package? package))) -(define (package-update-path package) - "Return an update path for PACKAGE, or #f if no update is needed." - (and (gnu-package? package) - (match (latest-release (package-name package)) - (($ <gnu-release> name version directory) - (and (version>? version (package-version package)) - `(,version . ,directory))) - (_ #f)))) - -(define* (download-tarball store project directory version - #:key (archive-type "gz") - (key-download 'interactive)) - "Download PROJECT's tarball over FTP and check its OpenPGP signature. On -success, return the tarball file name. KEY-DOWNLOAD specifies a download -policy for missing OpenPGP keys; allowed values: 'interactive' (default), -'always', and 'never'." - (let* ((server (ftp-server/directory project)) - (base (string-append project "-" version ".tar." archive-type)) - (url (string-append "ftp://" server "/" directory "/" base)) - (sig-url (string-append url ".sig")) - (tarball (download-to-store store url)) - (sig (download-to-store store sig-url))) - (let ((ret (gnupg-verify* sig tarball #:key-download key-download))) - (if ret - tarball - (begin - (warning (_ "signature verification failed for `~a'~%") - base) - (warning (_ "(could be because the public key is not in your keyring)~%")) - #f))))) - -(define* (package-update store package #:key (key-download 'interactive)) - "Return the new version and the file name of the new version tarball for -PACKAGE, or #f and #f when PACKAGE is up-to-date. KEY-DOWNLOAD specifies a -download policy for missing OpenPGP keys; allowed values: 'always', 'never', -and 'interactive' (default)." - (match (package-update-path package) - ((version . directory) - (let-values (((name) - (package-name package)) - ((archive-type) - (let ((source (package-source package))) - (or (and (origin? source) - (file-extension (origin-uri source))) - "gz")))) - (let ((tarball (download-tarball store name directory version - #:archive-type archive-type - #:key-download key-download))) - (values version tarball)))) - (_ - (values #f #f)))) - -(define (update-package-source package version hash) - "Modify the source file that defines PACKAGE to refer to VERSION, -whose tarball has SHA256 HASH (a bytevector). Return the new version string -if an update was made, and #f otherwise." - (define (new-line line matches replacement) - ;; Iterate over MATCHES and return the modified line based on LINE. - ;; Replace each match with REPLACEMENT. - (let loop ((m* matches) ; matches - (o 0) ; offset in L - (r '())) ; result - (match m* - (() - (let ((r (cons (substring line o) r))) - (string-concatenate-reverse r))) - ((m . rest) - (loop rest - (match:end m) - (cons* replacement - (substring line o (match:start m)) - r)))))) - - (define (update-source file old-version version - old-hash hash) - ;; Update source file FILE, replacing occurrences OLD-VERSION by VERSION - ;; and occurrences of OLD-HASH by HASH (base32 representation thereof). - - ;; TODO: Currently this is a bit of a sledgehammer: if VERSION occurs in - ;; different unrelated places, we may modify it more than needed, for - ;; instance. We should try to make changes only within the sexp that - ;; corresponds to the definition of PACKAGE. - (let ((old-hash (bytevector->nix-base32-string old-hash)) - (hash (bytevector->nix-base32-string hash))) - (substitute file - `((,(regexp-quote old-version) - . ,(cut new-line <> <> version)) - (,(regexp-quote old-hash) - . ,(cut new-line <> <> hash)))) - version)) - - (let ((name (package-name package)) - (loc (package-field-location package 'version))) - (if loc - (let ((old-version (package-version package)) - (old-hash (origin-sha256 (package-source package))) - (file (and=> (location-file loc) - (cut search-path %load-path <>)))) - (if file - (update-source file - old-version version - old-hash hash) - (begin - (warning (_ "~a: could not locate source file") - (location-file loc)) - #f))) - (begin - (format (current-error-port) - (_ "~a: ~a: no `version' field in source; skipping~%") - (location->string (package-location package)) - name))))) +(define %gnu-updater + (upstream-updater 'gnu + non-emacs-gnu-package? + latest-release*)) ;;; gnu-maintenance.scm ends here diff --git a/guix/http-client.scm b/guix/http-client.scm index 8d1cc9b8f3..bee8cdc834 100644 --- a/guix/http-client.scm +++ b/guix/http-client.scm @@ -241,7 +241,7 @@ Raise an '&http-get-error' condition if downloading fails." ;;; Caching. ;;; -(define (%http-cache-ttl) +(define %http-cache-ttl ;; Time-to-live in seconds of the HTTP cache of in ~/.cache/guix. (make-parameter (* 3600 (or (and=> (getenv "GUIX_HTTP_CACHE_TTL") diff --git a/guix/import/cran.scm b/guix/import/cran.scm index 585cb9fec2..6284c9eef3 100644 --- a/guix/import/cran.scm +++ b/guix/import/cran.scm @@ -1,5 +1,6 @@ ;;; GNU Guix --- Functional package management for GNU ;;; Copyright © 2015 Ricardo Wurmus <rekado@elephly.net> +;;; Copyright © 2015 Ludovic Courtès <ludo@gnu.org> ;;; ;;; This file is part of GNU Guix. ;;; @@ -20,6 +21,7 @@ #:use-module (ice-9 match) #:use-module (ice-9 regex) #:use-module (srfi srfi-1) + #:use-module (srfi srfi-26) #:use-module (sxml simple) #:use-module (sxml match) #:use-module (sxml xpath) @@ -29,7 +31,10 @@ #:use-module (guix base32) #:use-module ((guix download) #:select (download-to-store)) #:use-module (guix import utils) - #:export (cran->guix-package)) + #:use-module (guix upstream) + #:use-module (guix packages) + #:export (cran->guix-package + %cran-updater)) ;;; Commentary: ;;; @@ -89,7 +94,7 @@ first cell of a table row is considered a label cell." "Return an sxml representation of the CRAN page for the R package NAME, or #f on failure. NAME is case-sensitive." ;; This API always returns the latest release of the module. - (let ((cran-url (string-append %cran-url name))) + (let ((cran-url (string-append %cran-url name "/"))) (false-if-exception (xml->sxml (http-fetch cran-url) #:trim-whitespace? #t @@ -108,12 +113,25 @@ or #f on failure. NAME is case-sensitive." name) (symbol->string name)))))))) +(define (downloads->url downloads) + "Extract from DOWNLOADS, the downloads item of the CRAN sxml tree, the +download URL." + (string-append "mirror://cran/" + ;; Remove double dots, because we want an + ;; absolute path. + (regexp-substitute/global + #f "\\.\\./" + (string-join ((sxpath '((xhtml:a 1) @ href *text*)) + (table-datum downloads " Package source: "))) + 'pre 'post))) + +(define (nodes->text nodeset) + "Return the concatenation of the text nodes among NODESET." + (string-join ((sxpath '(// *text*)) nodeset) " ")) + (define (cran-sxml->sexp sxml) "Return the `package' s-expression for a CRAN package from the SXML representation of the package page." - (define (nodes->text nodeset) - (string-join ((sxpath '(// *text*)) nodeset) " ")) - (define (guix-name name) (if (string-prefix? "r-" name) (string-downcase name) @@ -136,16 +154,7 @@ representation of the package page." (table-datum summary "License:"))) (home-page (nodes->text ((sxpath '((xhtml:a 1))) (table-datum summary "URL:")))) - (source-url (string-append "mirror://cran/" - ;; Remove double dots, because we want an - ;; absolute path. - (regexp-substitute/global - #f "\\.\\./" - (string-join - ((sxpath '((xhtml:a 1) @ href *text*)) - (table-datum downloads - " Package source: "))) - 'pre 'post))) + (source-url (downloads->url downloads)) (tarball (with-store store (download-to-store store source-url))) (sysdepends (map match:substring (list-matches @@ -186,3 +195,49 @@ representation of the package page." `package' s-expression corresponding to that package, or #f on failure." (let ((module-meta (cran-fetch package-name))) (and=> module-meta cran-sxml->sexp))) + + +;;; +;;; Updater. +;;; + +(define (latest-release package) + "Return an <upstream-source> for the latest release of PACKAGE." + (define name + (if (string-prefix? "r-" package) + (string-drop package 2) + package)) + + (define sxml + (cran-fetch name)) + + (and sxml + (sxml-match-let* + (((*TOP* (xhtml:html + ,head + (xhtml:body + (xhtml:h2 ,name-and-synopsis) + (xhtml:p ,description) + ,summary + (xhtml:h4 "Downloads:") ,downloads + . ,rest))) + sxml)) + (let ((version (nodes->text (table-datum summary "Version:"))) + (url (downloads->url downloads))) + ;; CRAN does not provide signatures. + (upstream-source + (package package) + (version version) + (urls (list url))))))) + +(define (cran-package? package) + "Return true if PACKAGE is an R package from CRAN." + ;; Assume all R packages are available on CRAN. + (string-prefix? "r-" (package-name package))) + +(define %cran-updater + (upstream-updater 'cran + cran-package? + latest-release)) + +;;; cran.scm ends here diff --git a/guix/import/elpa.scm b/guix/import/elpa.scm index b3a3a963a6..37fc2b80fe 100644 --- a/guix/import/elpa.scm +++ b/guix/import/elpa.scm @@ -1,5 +1,6 @@ ;;; GNU Guix --- Functional package management for GNU ;;; Copyright © 2015 Federico Beffa <beffa@fbengineering.ch> +;;; Copyright © 2015 Ludovic Courtès <ludo@gnu.org> ;;; ;;; This file is part of GNU Guix. ;;; @@ -19,6 +20,7 @@ (define-module (guix import elpa) #:use-module (ice-9 match) #:use-module (ice-9 rdelim) + #:use-module (web uri) #:use-module (srfi srfi-1) #:use-module (srfi srfi-9) #:use-module (srfi srfi-9 gnu) @@ -26,13 +28,17 @@ #:use-module (srfi srfi-26) #:use-module ((guix download) #:select (download-to-store)) #:use-module (guix import utils) + #:use-module (guix http-client) #:use-module (guix store) #:use-module (guix ui) #:use-module (guix hash) #:use-module (guix base32) + #:use-module (guix upstream) + #:use-module (guix packages) #:use-module ((guix utils) #:select (call-with-temporary-output-file memoize)) - #:export (elpa->guix-package)) + #:export (elpa->guix-package + %elpa-updater)) (define (elpa-dependencies->names deps) "Convert DEPS, a list of symbol/version pairs à la ELPA, to a list of @@ -74,20 +80,16 @@ NAMES (strings)." (let ((url (and=> (elpa-url repo) (cut string-append <> "/archive-contents")))) (if url - (call-with-downloaded-file url read) + ;; Use a relatively small TTL for the archive itself. + (parameterize ((%http-cache-ttl (* 6 3600))) + (call-with-downloaded-file url read)) (leave (_ "~A: currently not supported~%") repo)))) (define* (call-with-downloaded-file url proc #:optional (error-thunk #f)) "Fetch URL, store the content in a temporary file and call PROC with that file. Returns the value returned by PROC. On error call ERROR-THUNK and return its value or leave if it's false." - (call-with-temporary-output-file - (lambda (temp port) - (or (and (url-fetch url temp) - (call-with-input-file temp proc)) - (if error-thunk - (error-thunk) - (leave (_ "~A: download failed~%") url)))))) + (proc (http-fetch/cached (string->uri url)))) (define (is-elpa-package? name elpa-pkg-spec) "Return true if the string NAME corresponds to the name of the package @@ -231,4 +233,47 @@ type '<elpa-package>'." (let ((pkg (fetch-elpa-package name repo))) (and=> pkg elpa-package->sexp))) + +;;; +;;; Updates. +;;; + +(define (latest-release package) + "Return an <upstream-release> for the latest release of PACKAGE. PACKAGE +may be a Guix package name such as \"emacs-debbugs\" or an upstream name such +as \"debbugs\"." + (define name + (if (string-prefix? "emacs-" package) + (string-drop package 6) + package)) + + (let* ((repo 'gnu) + (info (elpa-package-info name repo)) + (version (match info + ((name raw-version . _) + (elpa-version->string raw-version)))) + (url (match info + ((_ raw-version reqs synopsis kind . rest) + (package-source-url kind name version repo))))) + (upstream-source + (package package) + (version version) + (urls (list url)) + (signature-urls (list (string-append url ".sig")))))) + +(define (package-from-gnu.org? package) + "Return true if PACKAGE is from elpa.gnu.org." + (match (and=> (package-source package) origin-uri) + ((? string? uri) + (let ((uri (string->uri uri))) + (and uri (string=? (uri-host uri) "elpa.gnu.org")))) + (_ #f))) + +(define %elpa-updater + ;; The ELPA updater. We restrict it to packages hosted on elpa.gnu.org + ;; because for other repositories, we typically grab the source elsewhere. + (upstream-updater 'elpa + package-from-gnu.org? + latest-release)) + ;;; elpa.scm ends here diff --git a/guix/import/hackage.scm b/guix/import/hackage.scm index b5574a8d9f..3baa514aa1 100644 --- a/guix/import/hackage.scm +++ b/guix/import/hackage.scm @@ -32,37 +32,35 @@ #:export (hackage->guix-package)) (define ghc-standard-libraries - ;; List of libraries distributed with ghc (7.8.4). We include GHC itself as + ;; List of libraries distributed with ghc (7.10.2). We include GHC itself as ;; some packages list it. - '("ghc" - "haskell98" - "hoopl" + '("array" "base" - "transformers" - "deepseq" - "array" + "bin-package-db" "binary" "bytestring" + "cabal" ;; in the output of `ghc-pkg list` Cabal is uppercased, but + ;; hackage-name->package-name takes this into account. "containers" - "time" - "cabal" - "bin-package-db" + "deepseq" + "directory" + "filepath" + "ghc" "ghc-prim" + "haskeline" + "hoopl" + "hpc" "integer-gmp" - "integer-simple" - "win32" - "template-haskell" + "pretty" "process" - "haskeline" + "rts" + "template-haskell" "terminfo" - "directory" - "filepath" - "old-locale" + "time" + "transformers" "unix" - "old-time" - "pretty" - "xhtml" - "hpc")) + "win32" + "xhtml")) (define package-name-prefix "ghc-") diff --git a/guix/scripts/import/hackage.scm b/guix/scripts/import/hackage.scm index 8d31128c47..8c4e640bf3 100644 --- a/guix/scripts/import/hackage.scm +++ b/guix/scripts/import/hackage.scm @@ -55,7 +55,7 @@ version.\n")) (display (_ " -s, --stdin read from standard input")) (display (_ " - -t, --no-test-dependencies don't include test only dependencies")) + -t, --no-test-dependencies don't include test-only dependencies")) (display (_ " -V, --version display version information and exit")) (newline) diff --git a/guix/scripts/refresh.scm b/guix/scripts/refresh.scm index 097059e372..6f7ca4a41b 100644 --- a/guix/scripts/refresh.scm +++ b/guix/scripts/refresh.scm @@ -25,7 +25,10 @@ #:use-module (guix store) #:use-module (guix utils) #:use-module (guix packages) - #:use-module (guix gnu-maintenance) + #:use-module (guix upstream) + #:use-module ((guix gnu-maintenance) #:select (%gnu-updater)) + #:use-module (guix import elpa) + #:use-module (guix import cran) #:use-module (guix gnupg) #:use-module (gnu packages) #:use-module ((gnu packages commencement) #:select (%final-inputs)) @@ -63,6 +66,9 @@ (x (leave (_ "~a: invalid selection; expected `core' or `non-core'~%") arg))))) + (option '(#\t "type") #t #f + (lambda (opt name arg result) + (alist-cons 'updater (string->symbol arg) result))) (option '(#\l "list-dependent") #f #f (lambda (opt name arg result) (alist-cons 'list-dependent? #t result))) @@ -104,6 +110,8 @@ specified with `--select'.\n")) -s, --select=SUBSET select all the packages in SUBSET, one of `core' or `non-core'")) (display (_ " + -t, --type=UPDATER restrict to updates from UPDATER--e.g., 'gnu'")) + (display (_ " -l, --list-dependent list top-level dependent packages that would need to be rebuilt as a result of upgrading PACKAGE...")) (newline) @@ -124,19 +132,33 @@ specified with `--select'.\n")) (newline) (show-bug-report-information)) -(define* (update-package store package #:key (key-download 'interactive)) + +;;; +;;; Updates. +;;; + +(define %updaters + ;; List of "updaters" used by default. They are consulted in this order. + (list %gnu-updater + %elpa-updater + %cran-updater)) + +(define (lookup-updater name) + "Return the updater called NAME." + (find (lambda (updater) + (eq? name (upstream-updater-name updater))) + %updaters)) + +(define* (update-package store package updaters + #:key (key-download 'interactive)) "Update the source file that defines PACKAGE with the new version. KEY-DOWNLOAD specifies a download policy for missing OpenPGP keys; allowed values: 'interactive' (default), 'always', and 'never'." (let-values (((version tarball) - (catch #t - (lambda () - (package-update store package #:key-download key-download)) - (lambda _ - (values #f #f)))) + (package-update store package updaters + #:key-download key-download)) ((loc) - (or (package-field-location package - 'version) + (or (package-field-location package 'version) (package-location package)))) (when version (if (and=> tarball file-exists?) @@ -153,7 +175,6 @@ values: 'interactive' (default), 'always', and 'never'." downloaded and authenticated; not updating~%") (package-name package) version))))) - ;;; ;;; Entry point. @@ -169,6 +190,19 @@ downloaded and authenticated; not updating~%") (alist-cons 'argument arg result)) %default-options)) + (define (options->updaters opts) + ;; Return the list of updaters to use. + (match (filter-map (match-lambda + (('updater . name) + (lookup-updater name)) + (_ #f)) + opts) + (() + ;; Use the default updaters. + %updaters) + (lst + lst))) + (define (keep-newest package lst) ;; If a newer version of PACKAGE is already in LST, return LST; otherwise ;; return LST minus the other version of PACKAGE in it, plus PACKAGE. @@ -185,8 +219,8 @@ downloaded and authenticated; not updating~%") (define core-package? (let* ((input->package (match-lambda - ((name (? package? package) _ ...) package) - (_ #f))) + ((name (? package? package) _ ...) package) + (_ #f))) (final-inputs (map input->package %final-inputs)) (core (append final-inputs (append-map (compose (cut filter-map input->package <>) @@ -205,6 +239,7 @@ update would trigger a complete rebuild." (let* ((opts (parse-options)) (update? (assoc-ref opts 'update?)) + (updaters (options->updaters opts)) (list-dependent? (assoc-ref opts 'list-dependent?)) (key-download (assoc-ref opts 'key-download)) (packages @@ -215,18 +250,18 @@ update would trigger a complete rebuild." (specification->package spec)) (_ #f)) opts) - (() ; default to all packages - (let ((select? (match (assoc-ref opts 'select) - ('core core-package?) - ('non-core (negate core-package?)) - (_ (const #t))))) - (fold-packages (lambda (package result) - (if (select? package) - (keep-newest package result) - result)) - '()))) - (some ; user-specified packages - some)))) + (() ; default to all packages + (let ((select? (match (assoc-ref opts 'select) + ('core core-package?) + ('non-core (negate core-package?)) + (_ (const #t))))) + (fold-packages (lambda (package result) + (if (select? package) + (keep-newest package result) + result)) + '()))) + (some ; user-specified packages + some)))) (with-error-handling (cond (list-dependent? @@ -258,18 +293,19 @@ dependent packages are rebuilt: ~{~a~^ ~}~%" (or (assoc-ref opts 'gpg-command) (%gpg-command)))) (for-each - (cut update-package store <> #:key-download key-download) + (cut update-package store <> updaters + #:key-download key-download) packages)))) (else (for-each (lambda (package) - (match (false-if-exception (package-update-path package)) - ((new-version . directory) + (match (package-update-path package updaters) + ((? upstream-source? source) (let ((loc (or (package-field-location package 'version) (package-location package)))) (format (current-error-port) (_ "~a: ~a would be upgraded from ~a to ~a~%") (location->string loc) (package-name package) (package-version package) - new-version))) - (_ #f))) + (upstream-source-version source)))) + (#f #f))) packages)))))) diff --git a/guix/upstream.scm b/guix/upstream.scm new file mode 100644 index 0000000000..9300113ac6 --- /dev/null +++ b/guix/upstream.scm @@ -0,0 +1,259 @@ +;;; GNU Guix --- Functional package management for GNU +;;; Copyright © 2010, 2011, 2012, 2013, 2014, 2015 Ludovic Courtès <ludo@gnu.org> +;;; +;;; This file is part of GNU Guix. +;;; +;;; GNU Guix is free software; you can redistribute it and/or modify it +;;; under the terms of the GNU General Public License as published by +;;; the Free Software Foundation; either version 3 of the License, or (at +;;; your option) any later version. +;;; +;;; GNU Guix is distributed in the hope that it will be useful, but +;;; WITHOUT ANY WARRANTY; without even the implied warranty of +;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;;; GNU General Public License for more details. +;;; +;;; You should have received a copy of the GNU General Public License +;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>. + +(define-module (guix upstream) + #:use-module (guix records) + #:use-module (guix utils) + #:use-module ((guix download) + #:select (download-to-store)) + #:use-module ((guix build utils) + #:select (substitute)) + #:use-module (guix gnupg) + #:use-module (guix packages) + #:use-module (guix ui) + #:use-module (guix base32) + #:use-module (srfi srfi-1) + #:use-module (srfi srfi-9) + #:use-module (srfi srfi-11) + #:use-module (srfi srfi-26) + #:use-module (ice-9 match) + #:use-module (ice-9 regex) + #:export (upstream-source + upstream-source? + upstream-source-package + upstream-source-version + upstream-source-urls + upstream-source-signature-urls + + coalesce-sources + + upstream-updater + upstream-updater? + upstream-updater-name + upstream-updater-predicate + upstream-updater-latest + + download-tarball + package-update-path + package-update + update-package-source)) + +;;; Commentary: +;;; +;;; This module provides tools to represent and manipulate a upstream source +;;; code, and to auto-update package recipes. +;;; +;;; Code: + +;; Representation of upstream's source. There can be several URLs--e.g., +;; tar.gz, tar.gz, etc. There can be correspond signature URLs, one per +;; source URL. +(define-record-type* <upstream-source> + upstream-source make-upstream-source + upstream-source? + (package upstream-source-package) ;string + (version upstream-source-version) ;string + (urls upstream-source-urls) ;list of strings + (signature-urls upstream-source-signature-urls ;#f | list of strings + (default #f))) + +(define (upstream-source-archive-types release) + "Return the available types of archives for RELEASE---a list of strings such +as \"gz\" or \"xz\"." + (map file-extension (upstream-source-urls release))) + +(define (coalesce-sources sources) + "Coalesce the elements of SOURCES, a list of <upstream-source>, that +correspond to the same version." + (define (same-version? r1 r2) + (string=? (upstream-source-version r1) (upstream-source-version r2))) + + (define (release>? r1 r2) + (version>? (upstream-source-version r1) (upstream-source-version r2))) + + (fold (lambda (release result) + (match result + ((head . tail) + (if (same-version? release head) + (cons (upstream-source + (inherit release) + (urls (append (upstream-source-urls release) + (upstream-source-urls head))) + (signature-urls + (append (upstream-source-signature-urls release) + (upstream-source-signature-urls head)))) + tail) + (cons release result))) + (() + (list release)))) + '() + (sort sources release>?))) + + +;;; +;;; Auto-update. +;;; + +(define-record-type <upstream-updater> + (upstream-updater name pred latest) + upstream-updater? + (name upstream-updater-name) + (pred upstream-updater-predicate) + (latest upstream-updater-latest)) + +(define (lookup-updater package updaters) + "Return an updater among UPDATERS that matches PACKAGE, or #f if none of +them matches." + (any (match-lambda + (($ <upstream-updater> _ pred latest) + (and (pred package) latest))) + updaters)) + +(define (package-update-path package updaters) + "Return an upstream source to update PACKAGE to, or #f if no update is +needed or known." + (match (lookup-updater package updaters) + ((? procedure? latest-release) + (match (latest-release (package-name package)) + ((and source ($ <upstream-source> name version)) + (and (version>? version (package-version package)) + source)) + (_ #f))) + (#f #f))) + +(define* (download-tarball store url signature-url + #:key (key-download 'interactive)) + "Download the tarball at URL to the store; check its OpenPGP signature at +SIGNATURE-URL, unless SIGNATURE-URL is false. On success, return the tarball +file name. KEY-DOWNLOAD specifies a download policy for missing OpenPGP keys; +allowed values: 'interactive' (default), 'always', and 'never'." + (let ((tarball (download-to-store store url))) + (if (not signature-url) + tarball + (let* ((sig (download-to-store store signature-url)) + (ret (gnupg-verify* sig tarball #:key-download key-download))) + (if ret + tarball + (begin + (warning (_ "signature verification failed for `~a'~%") + url) + (warning (_ "(could be because the public key is not in your keyring)~%")) + #f)))))) + +(define (find2 pred lst1 lst2) + "Like 'find', but operate on items from both LST1 and LST2. Return two +values: the item from LST1 and the item from LST2 that match PRED." + (let loop ((lst1 lst1) (lst2 lst2)) + (match lst1 + ((head1 . tail1) + (match lst2 + ((head2 . tail2) + (if (pred head1 head2) + (values head1 head2) + (loop tail1 tail2))))) + (() + (values #f #f))))) + +(define* (package-update store package updaters + #:key (key-download 'interactive)) + "Return the new version and the file name of the new version tarball for +PACKAGE, or #f and #f when PACKAGE is up-to-date. KEY-DOWNLOAD specifies a +download policy for missing OpenPGP keys; allowed values: 'always', 'never', +and 'interactive' (default)." + (match (package-update-path package updaters) + (($ <upstream-source> _ version urls signature-urls) + (let*-values (((name) + (package-name package)) + ((archive-type) + (match (and=> (package-source package) origin-uri) + ((? string? uri) + (or (file-extension uri) "gz")) + (_ + "gz"))) + ((url signature-url) + (find2 (lambda (url sig-url) + (string-suffix? archive-type url)) + urls + (or signature-urls (circular-list #f))))) + (let ((tarball (download-tarball store url signature-url + #:key-download key-download))) + (values version tarball)))) + (#f + (values #f #f)))) + +(define (update-package-source package version hash) + "Modify the source file that defines PACKAGE to refer to VERSION, +whose tarball has SHA256 HASH (a bytevector). Return the new version string +if an update was made, and #f otherwise." + (define (new-line line matches replacement) + ;; Iterate over MATCHES and return the modified line based on LINE. + ;; Replace each match with REPLACEMENT. + (let loop ((m* matches) ; matches + (o 0) ; offset in L + (r '())) ; result + (match m* + (() + (let ((r (cons (substring line o) r))) + (string-concatenate-reverse r))) + ((m . rest) + (loop rest + (match:end m) + (cons* replacement + (substring line o (match:start m)) + r)))))) + + (define (update-source file old-version version + old-hash hash) + ;; Update source file FILE, replacing occurrences OLD-VERSION by VERSION + ;; and occurrences of OLD-HASH by HASH (base32 representation thereof). + + ;; TODO: Currently this is a bit of a sledgehammer: if VERSION occurs in + ;; different unrelated places, we may modify it more than needed, for + ;; instance. We should try to make changes only within the sexp that + ;; corresponds to the definition of PACKAGE. + (let ((old-hash (bytevector->nix-base32-string old-hash)) + (hash (bytevector->nix-base32-string hash))) + (substitute file + `((,(regexp-quote old-version) + . ,(cut new-line <> <> version)) + (,(regexp-quote old-hash) + . ,(cut new-line <> <> hash)))) + version)) + + (let ((name (package-name package)) + (loc (package-field-location package 'version))) + (if loc + (let ((old-version (package-version package)) + (old-hash (origin-sha256 (package-source package))) + (file (and=> (location-file loc) + (cut search-path %load-path <>)))) + (if file + (update-source file + old-version version + old-hash hash) + (begin + (warning (_ "~a: could not locate source file") + (location-file loc)) + #f))) + (begin + (format (current-error-port) + (_ "~a: ~a: no `version' field in source; skipping~%") + (location->string (package-location package)) + name))))) + +;;; upstream.scm ends here diff --git a/po/guix/POTFILES.in b/po/guix/POTFILES.in index d9fc04495d..0c4e4f8443 100644 --- a/po/guix/POTFILES.in +++ b/po/guix/POTFILES.in @@ -23,7 +23,7 @@ guix/scripts/edit.scm guix/scripts/size.scm guix/scripts/graph.scm guix/scripts/challenge.scm -guix/gnu-maintenance.scm +guix/upstream.scm guix/ui.scm guix/http-client.scm guix/nar.scm |