ryan77627/guix
1
0
Fork 0
mirror of https://git.in.rschanz.org/ryan77627/guix.git synced 2025-01-11 21:59:08 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch 'master' into core-updates

Browse source
This commit is contained in:
Leo Famulari 2018-10-07 20:49:14 -04:00
commit e8bd1946ec
No known key found for this signature in database
GPG key ID: 2646FA30BACA7F08
27 changed files with 1426 additions and 387 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
gnu/local.mk
View file

@ -77,6 +77,7 @@ GNU_SYSTEM_MODULES = \
%D%/packages/backup.scm \
%D%/packages/base.scm \
%D%/packages/bash.scm \
%D%/packages/batik.scm \
%D%/packages/bdw-gc.scm \
%D%/packages/benchmark.scm \
%D%/packages/bioconductor.scm \
@ -591,11 +592,13 @@ dist_patch_DATA = \
%D%/packages/patches/awesome-reproducible-png.patch \
%D%/packages/patches/azr3.patch \
%D%/packages/patches/bash-completion-directories.patch \
%D%/packages/patches/bastet-change-source-of-unordered_set.patch \
%D%/packages/patches/bazaar-CVE-2017-14176.patch \
%D%/packages/patches/beignet-correct-file-names.patch \
%D%/packages/patches/binutils-loongson-workaround.patch \
%D%/packages/patches/blast+-fix-makefile.patch \
%D%/packages/patches/boost-fix-icu-build.patch \
%D%/packages/patches/borg-respect-storage-quota.patch \
%D%/packages/patches/byobu-writable-status.patch \
%D%/packages/patches/cairo-CVE-2016-9082.patch \
%D%/packages/patches/cairo-setjmp-wrapper.patch \
@ -763,6 +766,7 @@ dist_patch_DATA = \
%D%/packages/patches/gnome-todo-libical-compat.patch \
%D%/packages/patches/gnome-tweak-tool-search-paths.patch \
%D%/packages/patches/gnucash-price-quotes-perl.patch \
%D%/packages/patches/gnucash-disable-failing-tests.patch \
%D%/packages/patches/gnutls-skip-trust-store-test.patch \
%D%/packages/patches/gnutls-skip-pkgconfig-test.patch \
%D%/packages/patches/gobject-introspection-absolute-shlib-path.patch \
@ -954,7 +958,6 @@ dist_patch_DATA = \
%D%/packages/patches/mcrypt-CVE-2012-4409.patch \
%D%/packages/patches/mcrypt-CVE-2012-4426.patch \
%D%/packages/patches/mcrypt-CVE-2012-4527.patch \
%D%/packages/patches/mes-nyacc-0.86.0.patch \
%D%/packages/patches/mesa-skip-disk-cache-test.patch \
%D%/packages/patches/meson-for-build-rpath.patch \
%D%/packages/patches/metabat-fix-compilation.patch \

4
gnu/packages/android.scm
View file

@ -863,14 +863,14 @@ (define-public python-androguard
(define-public fdroidserver
(package
(name "fdroidserver")
(version "1.0.9")
(version "1.0.10")
(source
(origin
(method url-fetch)
(uri (pypi-uri "fdroidserver" version))
(sha256
(base32
"0cwb1fmindw6v9jkiim9yn3496rk1pvnk94s1r0vz2hxgz16xp7n"))))
"0n6kkby65qzqdx1jn72grfffvr1w1j1rby5pwm9z8rymmsh8s0pm"))))
(build-system python-build-system)
(arguments
`(#:phases

7
gnu/packages/astronomy.scm
View file

@ -68,7 +68,7 @@ (define-public cfitsio
(define-public wcslib
(package
(name "wcslib")
(version "5.18")
(version "5.20")
(source
(origin
(method url-fetch)
@ -76,7 +76,7 @@ (define-public wcslib
"ftp://ftp.atnf.csiro.au/pub/software/wcslib/" name "-" version
".tar.bz2"))
(sha256
(base32 "16jh568k99c9p0y3qzcgps2rii933x9wlay7q1xm0lr59zqzp4xn"))))
(base32 "1c8g9kv4dxrnawnqi4spi2p10s2xs7x75pdfxhbqxgcc97dkgh0b"))))
(inputs
`(("cfitsio" ,cfitsio)))
(build-system gnu-build-system)
@ -89,8 +89,7 @@ (define-public wcslib
(("/bin/sh") "sh"))
#t))
(delete 'install-license-files)) ; installed by ‘make install’
;; Both the build and tests fail randomly when run in parallel.
#:parallel-build? #f
;; Parallel execution of the test suite is not supported.
#:parallel-tests? #f))
(home-page "https://www.atnf.csiro.au/people/mcalabre/WCS")
(synopsis "Library which implements the FITS WCS standard")

15
gnu/packages/audio.scm
View file

@ -291,12 +291,14 @@ (define-public audacity
(version "2.2.2")
(source
(origin
(method url-fetch)
(uri (string-append "https://github.com/audacity/audacity/archive"
"/Audacity-" version ".tar.gz"))
(method git-fetch)
(uri (git-reference
(url "https://github.com/audacity/audacity.git")
(commit (string-append "Audacity-" version))))
(file-name (git-file-name name version))
(sha256
(base32
"18q7i77ynihx7xp45lz2lv0k0wrh6736pcrivlpwrxjgbvyqx7km"))
"10maxmjxbmjybj7n4m7a9bbm7g8xxw8f8vbsf7c9ih5j2gr15ihs"))
(patches (search-patches "audacity-build-with-system-portaudio.patch"))
(modules '((guix build utils)))
(snippet
@ -411,11 +413,6 @@ (define-public audacity
(substitute* "src/prefs/MidiIOPrefs.cpp"
(("../../lib-src/portmidi/pm_common/portmidi.h") "portmidi.h"))
#t)))
;; The translation Makefile generation is performed improperly for
;; out-of-tree builds.
;; XXX This can be removed if the glib-or-gkt-build-system
;; switches to #:out-of-source? #t. See <https://bugs.gnu.org/32887>.
#:out-of-source? #f
;; The test suite is not "well exercised" according to the developers,
;; and fails with various errors. See
;; <http://sourceforge.net/p/audacity/mailman/message/33524292/>.

1
gnu/packages/backup.scm
View file

@ -498,6 +498,7 @@ (define-public borg
(origin
(method url-fetch)
(uri (pypi-uri "borgbackup" version))
(patches (search-patches "borg-respect-storage-quota.patch"))
(sha256
(base32
"1p3zia62vyg9vadkdjzzkzbj4dmgijr7ix5lmhfbxpwy5q9imdgp"))

250
gnu/packages/batik.scm Normal file
View file

@ -0,0 +1,250 @@
;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2018 Danny Milosavljevic <dannym@scratchpost.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 (gnu packages batik)
#:use-module ((guix licenses) #:prefix license:)
#:use-module (guix utils)
#:use-module (guix download)
#:use-module (guix git-download)
#:use-module (guix packages)
#:use-module (guix build-system ant)
#:use-module (gnu packages)
#:use-module (gnu packages compression)
#:use-module (gnu packages java)
#:use-module (gnu packages textutils)
#:use-module (gnu packages xml))
(define-public java-w3c-smil-3.0
(package
(name "java-w3c-smil")
(version "3.0")
(source #f)
(build-system ant-build-system)
(arguments
`(#:jar-name "w3c-smil.jar"
#:source-dir "."
#:tests? #f ; No tests exist.
#:phases
(modify-phases %standard-phases
(replace 'unpack
(lambda* (#:key source #:allow-other-keys)
;; https://www.w3.org/TR/SMIL3/smil-timing.html#q142
(mkdir-p "org/w3c/dom/smil")
(call-with-output-file "org/w3c/dom/smil/ElementTimeControl.java"
(lambda (port)
(format port "
package org.w3c.dom.smil;
import org.w3c.dom.DOMException;
public interface ElementTimeControl {
public boolean beginElement();
public boolean beginElementAt(float offset);
public boolean endElement();
public boolean endElementAt(float offset);
}
")))
(call-with-output-file "org/w3c/dom/smil/TimeEvent.java"
(lambda (port)
(format port "
package org.w3c.dom.smil;
import org.w3c.dom.events.Event;
import org.w3c.dom.views.AbstractView;
public interface TimeEvent extends Event {
public AbstractView getView();
public int getDetail();
public void initTimeEvent(String typeArg,
AbstractView viewArg,
int detailArg);
}
")))
#t)))))
(native-inputs
`(("unzip" ,unzip)))
(home-page "https://www.w3.org/Style/CSS/SAC/")
(synopsis "W3C SAC interface for CSS parsers in Java")
(description "This package provides a SAC interface by the W3C.
SAC is an interface for CSS parsers.")
(license license:w3c)))
(define-public java-w3c-svg-1.0
(package
(name "java-w3c-svg")
(version "20010904")
(source
(origin
(method url-fetch)
(uri (string-append "http://www.w3.org/TR/2001/REC-SVG-" version
"/java-binding.zip"))
(sha256
(base32
"0gnxvx51bg6ijplf6l2q0i1m07101f7fickawshfygnsdjqfdnbp"))))
(build-system ant-build-system)
(arguments
`(#:jar-name "w3c-svg.jar"
#:source-dir "."
#:tests? #f ; No tests exist.
#:phases
(modify-phases %standard-phases
(replace 'unpack
(lambda* (#:key source #:allow-other-keys)
(invoke "unzip" source)))
(add-after 'unpack 'patch-interface
(lambda _
;; Make it compatible with batik.
;; This is equivalent to usingxml commons externals'
;; "externals" part from https://xerces.apache.org/mirrors.cgi
(substitute* "SVGFEConvolveMatrixElement.java"
(("public SVGAnimatedLength[ ]*getKernelUnitLength")
"public SVGAnimatedNumber getKernelUnitLength"))
(substitute* "SVGFEMorphologyElement.java"
(("public SVGAnimatedLength[ ]*getRadius")
"public SVGAnimatedNumber getRadius"))
(call-with-output-file "EventListenerInitializer.java"
(lambda (port)
(format port "
// License: http://www.apache.org/licenses/LICENSE-2.0
package org.w3c.dom.svg;
public interface EventListenerInitializer {
public void initializeEventListeners(SVGDocument doc);
}
")))
#t)))))
(propagated-inputs
`(("java-w3c-smil" ,java-w3c-smil-3.0)))
(native-inputs
`(("unzip" ,unzip)))
(home-page "https://www.w3.org/Style/CSS/SAC/")
(synopsis "W3C SVG interface")
(description "This package provides a SVG interface.")
(license license:w3c)))
(define-public java-w3c-svg
(package
(inherit java-w3c-svg-1.0)
(version "20110816")
(source
(origin
(method url-fetch)
(uri (string-append "http://www.w3.org/TR/2011/REC-SVG11-" version
"/java-binding.zip"))
(sha256
(base32
"0jicqcrxav8ggs37amgvvwgc2f0qp1c5wns4rb2i3si83s2m09ns"))))
(propagated-inputs
`())))
(define-public java-w3c-sac
(package
(name "java-w3c-sac")
(version "1.3")
(source
(origin
(method url-fetch)
(uri (string-append "https://www.w3.org/2002/06/sacjava-" version
".zip"))
(sha256
(base32
"1djp2nnzf8jchnwz1ij9i5jfx4cg1ryf3lbw133yzjy0wkhcla52"))))
(build-system ant-build-system)
(arguments
`(#:jar-name "w3c-sac.jar"
#:source-dir "sac-1.3"
#:tests? #f ; No tests exist.
#:phases
(modify-phases %standard-phases
(replace 'unpack
(lambda* (#:key source #:allow-other-keys)
(invoke "unzip" source))))))
(native-inputs
`(("unzip" ,unzip)))
(home-page "https://www.w3.org/Style/CSS/SAC/")
(synopsis "W3C SAC interface for CSS parsers in Java")
(description "This package provides a SAC interface by the W3C.
SAC is an interface for CSS parsers.")
(license license:w3c)))
(define-public java-xmlgraphics-commons
(package
(name "java-xmlgraphics-commons")
(version "2.3")
(source
(origin
(method url-fetch)
(uri (string-append
"mirror://apache/xmlgraphics/commons/source/xmlgraphics-commons-"
version "-src.tar.gz"))
(sha256
(base32
"0a432a4ca3vgnbada5cy9mlmfzmq6hi4i176drfxrp17q2d43w23"))
(modules '((guix build utils)))
(snippet
`(begin
(delete-file-recursively "lib")
#t))))
(build-system ant-build-system)
(arguments
`(#:build-target "jar-main"
#:test-target "junit"
#:phases
(modify-phases %standard-phases
(add-after 'unpack 'make-reproducible
(lambda _
(substitute* "build.xml"
(("<attribute name=\"Build-Id\" value=\"[^\"]*\"")
"<attribute name=\"Build-Id\" value=\"\""))
#t))
(add-before 'build 'prepare-build-directories
(lambda _
(mkdir "lib")
(mkdir "lib/build")
#t))
(replace 'install
(lambda* (#:key outputs #:allow-other-keys)
(let* ((out (assoc-ref outputs "out"))
(out-share (string-append out "/share/java")))
(for-each (lambda (name)
(install-file name out-share))
(find-files "build"
"xmlgraphics-commons.*\\.jar$"))
#t))))))
(native-inputs
`(("java-apache-xml-commons-resolver" ,java-apache-xml-commons-resolver)
("java-asm" ,java-asm)
("java-cglib" ,java-cglib)
("java-hamcrest" ,java-hamcrest-core)
("java-junit" ,java-junit)
("java-mockito" ,java-mockito-1)
("java-objenesis" ,java-objenesis)))
(propagated-inputs
`(("java-commons-io" ,java-commons-io)
("java-commons-logging-minimal" ,java-commons-logging-minimal)))
(home-page "https://xmlgraphics.apache.org/commons/")
(synopsis "XMLGraphics constants")
(description "This package provides XMLGraphics constants (originally
from @code{batik}).")
(license license:asl2.0)))

91
gnu/packages/bioinformatics.scm
View file

@ -38,6 +38,7 @@ (define-module (gnu packages bioinformatics)
#:use-module (guix build-system ant)
#:use-module (guix build-system gnu)
#:use-module (guix build-system cmake)
#:use-module (guix build-system haskell)
#:use-module (guix build-system ocaml)
#:use-module (guix build-system perl)
#:use-module (guix build-system python)
@ -72,6 +73,8 @@ (define-module (gnu packages bioinformatics)
#:use-module (gnu packages groff)
#:use-module (gnu packages guile)
#:use-module (gnu packages haskell)
#:use-module (gnu packages haskell-check)
#:use-module (gnu packages haskell-web)
#:use-module (gnu packages image)
#:use-module (gnu packages imagemagick)
#:use-module (gnu packages java)
@ -6863,14 +6866,14 @@ (define-public bio-blastxmlparser
(define-public bioruby
(package
(name "bioruby")
(version "1.5.1")
(version "1.5.2")
(source
(origin
(method url-fetch)
(uri (rubygems-uri "bio" version))
(sha256
(base32
"0hdl0789c9n4mprnx5pgd46bfwl8d000rqpamj5h6kkjgspijv49"))))
"1d56amdsjv1mag7m6gv2w0xij8hqx1v5xbdjsix8sp3yp36m7938"))))
(build-system ruby-build-system)
(propagated-inputs
`(("ruby-libxml" ,ruby-libxml)))
@ -13970,3 +13973,87 @@ (define-public r-absfiltergsea
Without filtering, users can perform (original) two-tailed or one-tailed
absolute GSEA.")
(license license:gpl2)))
(define-public ngless
(package
(name "ngless")
(version "0.9.1")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://gitlab.com/ngless/ngless.git")
(commit (string-append "v" version))))
(file-name (git-file-name name version))
(sha256
(base32
"0mc2gi7h4lx74zylvyp76mvc0w6706j858ii9vlgzqsw6acpr117"))))
(build-system haskell-build-system)
(arguments
`(#:haddock? #f ; The haddock phase fails with: NGLess/CmdArgs.hs:20:1:
; error: parse error on input import
; import Options.Applicative
#:phases
(modify-phases %standard-phases
(add-after 'unpack 'create-cabal-file
(lambda _ (invoke "hpack") #t)))))
(inputs
`(("ghc-aeson" ,ghc-aeson)
("ghc-ansi-terminal" ,ghc-ansi-terminal)
("ghc-async" ,ghc-async)
("ghc-atomic-write" ,ghc-atomic-write)
("ghc-bytestring-lexing" ,ghc-bytestring-lexing)
("ghc-chart" ,ghc-chart)
("ghc-chart-cairo" ,ghc-chart-cairo)
("ghc-conduit" ,ghc-conduit)
("ghc-conduit-algorithms" ,ghc-conduit-algorithms)
("ghc-conduit-combinators" ,ghc-conduit-combinators)
("ghc-conduit-extra" ,ghc-conduit-extra)
("ghc-configurator" ,ghc-configurator)
("ghc-convertible" ,ghc-convertible)
("ghc-data-default" ,ghc-data-default)
("ghc-double-conversion" ,ghc-double-conversion)
("ghc-edit-distance" ,ghc-edit-distance)
("ghc-either" ,ghc-either)
("ghc-errors" ,ghc-errors)
("ghc-extra" ,ghc-extra)
("ghc-filemanip" ,ghc-filemanip)
("ghc-file-embed" ,ghc-file-embed)
("ghc-gitrev" ,ghc-gitrev)
("ghc-hashtables" ,ghc-hashtables)
("ghc-http-conduit" ,ghc-http-conduit)
("ghc-inline-c" ,ghc-inline-c)
("ghc-inline-c-cpp" ,ghc-inline-c-cpp)
("ghc-intervalmap" ,ghc-intervalmap)
("ghc-missingh" ,ghc-missingh)
("ghc-optparse-applicative" ,ghc-optparse-applicative)
("ghc-parsec" ,ghc-parsec)
("ghc-regex" ,ghc-regex)
("ghc-safe" ,ghc-safe)
("ghc-safeio" ,ghc-safeio)
("ghc-strict" ,ghc-strict)
("ghc-tar" ,ghc-tar)
("ghc-text" ,ghc-text)
("ghc-unliftio" ,ghc-unliftio)
("ghc-unliftio-core" ,ghc-unliftio-core)
("ghc-vector" ,ghc-vector)
("ghc-yaml" ,ghc-yaml)
("ghc-zlib" ,ghc-zlib)))
(propagated-inputs
`(("r-r6" ,r-r6)
("r-hdf5r" ,r-hdf5r)
("r-iterators" ,r-iterators)
("r-itertools" ,r-itertools)
("r-matrix" ,r-matrix)))
(native-inputs
`(("ghc-hpack" ,ghc-hpack)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-hunit",ghc-test-framework-hunit)
("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
("ghc-test-framework-th" ,ghc-test-framework-th)))
(home-page "https://gitlab.com/ngless/ngless")
(synopsis "DSL for processing next-generation sequencing data")
(description "Ngless is a domain-specific language for
@dfn{next-generation sequencing} (NGS) data processing.")
(license license:expat)))

8
gnu/packages/ftp.scm
View file

@ -170,7 +170,7 @@ (define-public weex
(define-public libfilezilla
(package
(name "libfilezilla")
(version "0.13.2")
(version "0.14.0")
(source
(origin
(method url-fetch)
@ -178,7 +178,7 @@ (define-public libfilezilla
name "/" name "-" version ".tar.bz2"))
(sha256
(base32
"0z9cqscca4w94j9npgcknrrw8gfwn5ids903042fczlr977j0i19"))))
"15cfz98asypf9rfybv4c6kx8nk3wak7qlm1azldc0gd1nqm4xqvz"))))
(build-system gnu-build-system)
(native-inputs
`(("cppunit" ,cppunit)
@ -207,14 +207,14 @@ (define-public libfilezilla
(define-public filezilla
(package
(name "filezilla")
(version "3.37.1")
(version "3.37.4")
(source
(origin
(method url-fetch)
(uri (string-append "https://download.filezilla-project.org/client/"
"FileZilla_" version "_src.tar.bz2"))
(sha256
(base32 "1bbxlm8gc0r5jing8xmkdbhj5a1qfbjn8varhny3mrk1am4m7s7l"))))
(base32 "169wy7ilsh518mcinkjmr6m0kzxbzchmc9mivf5c9b4zp1w4gg3i"))))
(build-system gnu-build-system)
(arguments
;; Don't let filezilla phone home to check for updates.

64
gnu/packages/games.scm
View file

@ -181,6 +181,70 @@ (define-public armagetronad
settings to tweak as well.")
(license license:gpl2+)))
(define-public bastet
(package
(name "bastet")
(version "0.43.2")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/fph/bastet.git")
(commit version)))
(file-name (git-file-name name version))
(sha256
(base32 "09kamxapm9jw9przpsgjfg33n9k94bccv65w95dakj0br33a75wn"))
(patches
(search-patches "bastet-change-source-of-unordered_set.patch"))))
(build-system gnu-build-system)
(arguments
`(#:make-flags
(list (string-append "CXXFLAGS=-I"
(assoc-ref %build-inputs "boost") "/include"))
#:phases
(modify-phases %standard-phases
(delete 'configure) ; no configure script
(replace 'check
;; The 'Test' target builds the tests, but doesn't actually run them.
(lambda* (#:key make-flags #:allow-other-keys)
(apply invoke "make" "Test" make-flags)
(setenv "HOME" ".")
(invoke "./Test")))
(replace 'install
(lambda* (#:key outputs #:allow-other-keys)
(let* ((out (assoc-ref outputs "out"))
(share (string-append out "/share"))
(hicolor (string-append share "/icons/hicolor")))
(install-file "bastet"
(string-append out "/bin"))
(install-file "bastet.desktop"
(string-append share "/applications"))
(install-file "bastet.svg"
(string-append hicolor "/scalable/apps"))
(install-file "bastet.appdata.xml"
(string-append share "/appdata"))
(install-file "bastet.6"
(string-append out "/share/man/man6"))
#t))))))
(native-inputs
`(("hicolor-icon-theme" ,hicolor-icon-theme)))
(inputs
`(("boost" ,boost)
("ncurses" ,ncurses)))
(home-page "http://fph.altervista.org/prog/bastet.html")
(synopsis "Antagonistic Tetris-style falling brick game for text terminals")
(description
"Bastet (short for Bastard Tetris) is a simple ncurses-based falling brick
game. Unlike normal Tetris, Bastet does not choose the next brick at random.
Instead, it uses a special algorithm to choose the worst brick possible.
Playing bastet can be a painful experience, especially if you usually make
canyons and wait for the long I-shaped block to clear four rows at a time.")
(license license:gpl3+)))
(define-public cataclysm-dda
(let ((commit "ad3b0c3d521292d119f97a83390e7acfe9e9e7f7")
(revision "1"))

47
gnu/packages/gnucash.scm
View file

@ -28,6 +28,7 @@ (define-module (gnu packages gnucash)
#:use-module (guix build-system cmake)
#:use-module (gnu packages)
#:use-module (gnu packages autotools)
#:use-module (gnu packages base)
#:use-module (gnu packages boost)
#:use-module (gnu packages check)
#:use-module (gnu packages cmake)
@ -50,7 +51,7 @@ (define-module (gnu packages gnucash)
(define-public gnucash
(package
(name "gnucash")
(version "3.0")
(version "3.3")
(source
(origin
(method url-fetch)
@ -58,11 +59,9 @@ (define-public gnucash
version "/gnucash-" version ".tar.bz2"))
(sha256
(base32
"1ffvf1rryg5yin86fnf1zvy6hnpwzrjarbdfmjmrf2mqlmv48xac"))
;; TODO: rebase this patch
; (patches (search-patches "gnucash-price-quotes-perl.patch"))
))
"0grr5qi5rn1xvr7qx5d7mcxa2mcgycy2b325ry73bb485a6yv5l3"))
(patches (search-patches "gnucash-price-quotes-perl.patch"
"gnucash-disable-failing-tests.patch"))))
(build-system cmake-build-system)
(inputs
`(("guile" ,guile-2.2)
@ -76,7 +75,8 @@ (define-public gnucash
("webkitgtk" ,webkitgtk)
("aqbanking" ,aqbanking)
("perl-date-manip" ,perl-date-manip)
("perl-finance-quote" ,perl-finance-quote)))
("perl-finance-quote" ,perl-finance-quote)
("tzdata" ,tzdata-for-tests)))
(native-inputs
`(("glib" ,glib "bin") ; glib-compile-schemas, etc.
("intltool" ,intltool)
@ -90,6 +90,13 @@ (define-public gnucash
#:configure-flags
(list "-DWITH_OFX=OFF" ; libofx is not available yet
"-DWITH_SQL=OFF") ; without dbi.h
#:make-flags '("GUILE_AUTO_COMPILE=0")
#:modules ((guix build cmake-build-system)
((guix build glib-or-gtk-build-system) #:prefix glib-or-gtk:)
(guix build utils))
#:imported-modules (,@%gnu-build-system-modules
(guix build cmake-build-system)
(guix build glib-or-gtk-build-system))
#:phases
(modify-phases %standard-phases
(add-after 'unpack 'unpack-gmock
@ -99,14 +106,28 @@ (define-public gnucash
"-C" "gmock" "--strip-components=1")
(setenv "GMOCK_ROOT" (string-append (getcwd) "/gmock/googlemock"))
#t))
(add-after 'unpack 'set-env-vars
(lambda* (#:key inputs #:allow-other-keys)
(let ((tzdata (assoc-ref inputs "tzdata")))
;; At least one test is time-related and requires this
;; environment variable.
(setenv "TZDIR"
(string-append tzdata
"/share/zoneinfo"))
(substitute* "CMakeLists.txt"
(("set\\(SHELL /bin/bash\\)")
(string-append "set(SHELL " (which "bash") ")")))
#t)))
;; There are about 100 megabytes of documentation.
(add-after
'install 'install-docs
(lambda* (#:key inputs outputs #:allow-other-keys)
(let ((docs (assoc-ref inputs "gnucash-docs"))
(doc-output (assoc-ref outputs "doc")))
(mkdir-p (string-append doc-output "/share"))
(symlink (string-append docs "/share/gnome")
(string-append doc-output "/share/gnome")))))
(string-append doc-output "/share/gnome"))
#t)))
(add-after
'install-docs 'wrap-programs
(lambda* (#:key inputs outputs #:allow-other-keys)
@ -134,7 +155,11 @@ (define-public gnucash
'("gnucash"
"gnc-fq-check"
"gnc-fq-helper"
"gnc-fq-dump")))))))
"gnc-fq-dump"))))
(add-after 'install 'glib-or-gtk-compile-schemas
(assoc-ref glib-or-gtk:%standard-phases 'glib-or-gtk-compile-schemas))
(add-after 'install 'glib-or-gtk-wrap
(assoc-ref glib-or-gtk:%standard-phases 'glib-or-gtk-wrap)))))
(home-page "https://www.gnucash.org/")
(synopsis "Personal and small business financial accounting software")
(description
@ -154,11 +179,11 @@ (define gnucash-docs
(source
(origin
(method url-fetch)
(uri (string-append "mirror://sourceforge/gnucash/gnucash-docs/"
(uri (string-append "mirror://sourceforge/gnucash/gnucash%20%28stable%29/"
version "/gnucash-docs-" version ".tar.gz"))
(sha256
(base32
"0yq65s3z3dwdwdf2nq1d1w9ckdjdyjwkfpmvhzyib54b66q65xh5"))))
"10v4hw4lh888r8yv473pqrvzfjg8dwamk62sghs93rn88ndwm16c"))))
(build-system gnu-build-system)
;; These are native-inputs because they are only required for building the
;; documentation.

128
gnu/packages/golang.scm
View file

@ -386,123 +386,9 @@ (define-public go-1.9
,@(package-native-inputs go-1.4)))
(supported-systems %supported-systems)))
(define-public go-1.10
(package
(inherit go-1.9)
(name "go")
(version "1.10.4")
(source
(origin
(method url-fetch)
(uri (string-append "https://storage.googleapis.com/golang/"
name version ".src.tar.gz"))
(sha256
(base32
"10ap5pan71y2hdwzv4cg8wx4sy8fkcz5520rm1ldjg25xmjlkr3g"))))
(arguments
(substitute-keyword-arguments (package-arguments go-1.9)
((#:phases phases)
`(modify-phases ,phases
(replace 'prebuild
(lambda* (#:key inputs outputs #:allow-other-keys)
(let* ((gcclib (string-append (assoc-ref inputs "gcc:lib") "/lib"))
(ld (string-append (assoc-ref inputs "libc") "/lib"))
(loader (car (find-files ld "^ld-linux.+")))
(net-base (assoc-ref inputs "net-base"))
(tzdata-path
(string-append (assoc-ref inputs "tzdata") "/share/zoneinfo"))
(output (assoc-ref outputs "out")))
;; Removing net/ tests, which fail when attempting to access
;; network resources not present in the build container.
(for-each delete-file
'("net/listen_test.go"
"net/parse_test.go"
"net/cgo_unix_test.go"))
(substitute* "os/os_test.go"
(("/usr/bin") (getcwd))
(("/bin/pwd") (which "pwd"))
(("/bin/sh") (which "sh")))
;; Add libgcc to runpath
(substitute* "cmd/link/internal/ld/lib.go"
(("!rpath.set") "true"))
(substitute* "cmd/go/internal/work/gccgo.go"
(("cgoldflags := \\[\\]string\\{\\}")
(string-append "cgoldflags := []string{"
"\"-rpath=" gcclib "\""
"}"))
(("\"-lgcc_s\", ")
(string-append
"\"-Wl,-rpath=" gcclib "\", \"-lgcc_s\", ")))
(substitute* "cmd/go/internal/work/gc.go"
(("ldflags = setextld\\(ldflags, compiler\\)")
(string-append
"ldflags = setextld(ldflags, compiler)\n"
"ldflags = append(ldflags, \"-r\")\n"
"ldflags = append(ldflags, \"" gcclib "\")\n")))
;; Disable failing tests: these tests attempt to access
;; commands or network resources which are neither available
;; nor necessary for the build to succeed.
(for-each
(match-lambda
((file regex)
(substitute* file
((regex all before test_name)
(string-append before "Disabled" test_name)))))
'(("net/net_test.go" "(.+)(TestShutdownUnix.+)")
("net/dial_test.go" "(.+)(TestDialTimeout.+)")
("os/os_test.go" "(.+)(TestHostname.+)")
("time/format_test.go" "(.+)(TestParseInSydney.+)")
("time/format_test.go" "(.+)(TestParseInLocation.+)")
("os/exec/exec_test.go" "(.+)(TestEcho.+)")
("os/exec/exec_test.go" "(.+)(TestCommandRelativeName.+)")
("os/exec/exec_test.go" "(.+)(TestCatStdin.+)")
("os/exec/exec_test.go" "(.+)(TestCatGoodAndBadFile.+)")
("os/exec/exec_test.go" "(.+)(TestExitStatus.+)")
("os/exec/exec_test.go" "(.+)(TestPipes.+)")
("os/exec/exec_test.go" "(.+)(TestStdinClose.+)")
("os/exec/exec_test.go" "(.+)(TestIgnorePipeErrorOnSuccess.+)")
("syscall/syscall_unix_test.go" "(.+)(TestPassFD\\(.+)")
("os/exec/exec_test.go" "(.+)(TestExtraFiles/areturn.+)")
("cmd/go/go_test.go" "(.+)(TestCoverageWithCgo.+)")
("cmd/go/go_test.go" "(.+)(TestTwoPkgConfigs.+)")
("os/exec/exec_test.go" "(.+)(TestOutputStderrCapture.+)")
("os/exec/exec_test.go" "(.+)(TestExtraFiles.+)")
("os/exec/exec_test.go" "(.+)(TestExtraFilesRace.+)")
("net/lookup_test.go" "(.+)(TestLookupPort.+)")
("syscall/exec_linux_test.go"
"(.+)(TestCloneNEWUSERAndRemapNoRootDisableSetgroups.+)")))
;; fix shebang for testar script
;; note the target script is generated at build time.
(substitute* "../misc/cgo/testcarchive/carchive_test.go"
(("#!/usr/bin/env") (string-append "#!" (which "env"))))
(substitute* "net/lookup_unix.go"
(("/etc/protocols") (string-append net-base "/etc/protocols")))
(substitute* "net/port_unix.go"
(("/etc/services") (string-append net-base "/etc/services")))
(substitute* "time/zoneinfo_unix.go"
(("/usr/share/zoneinfo/") tzdata-path))
(substitute* (find-files "cmd" "\\.go")
(("/lib(64)?/ld-linux.*\\.so\\.[0-9]") loader))
#t)))
(replace 'set-bootstrap-variables
(lambda* (#:key outputs inputs #:allow-other-keys)
;; Tell the build system where to find the bootstrap Go.
(let ((go (assoc-ref inputs "go")))
(setenv "GOROOT_BOOTSTRAP" go)
(setenv "GOGC" "400")
;; Go 1.10 tries to write to $HOME in a test
(setenv "HOME" "/tmp")
#t)))))))))
(define-public go-1.11
(package
(inherit go-1.10)
(inherit go-1.9)
(name "go")
(version "1.11.1")
(source
@ -514,7 +400,7 @@ (define-public go-1.11
(base32
"05qivf2f59pv4bfrmdr4m0xvswkmvvl9c5a2h5dy45g2k8b8r3sm"))))
(arguments
(substitute-keyword-arguments (package-arguments go-1.10)
(substitute-keyword-arguments (package-arguments go-1.9)
((#:phases phases)
`(modify-phases ,phases
(replace 'prebuild
@ -533,7 +419,7 @@ (define-public go-1.11
'("net/listen_test.go"
"net/parse_test.go"
"net/cgo_unix_test.go"
;; A side affect of these test scripts is testing
;; A side effect of these test scripts is testing
;; cgo. Attempts at using cgo flags and
;; directives with these scripts as specified
;; here (https://golang.org/cmd/cgo/) have not
@ -616,7 +502,13 @@ (define-public go-1.11
(("/usr/share/zoneinfo/") tzdata-path))
(substitute* (find-files "cmd" "\\.go")
(("/lib(64)?/ld-linux.*\\.so\\.[0-9]") loader))
#t)))))))))
#t)))
(replace 'set-bootstrap-variables
(lambda* (#:key outputs inputs #:allow-other-keys)
;; Tell the build system where to find the bootstrap Go.
(let ((go (assoc-ref inputs "go")))
(setenv "GOROOT_BOOTSTRAP" go)
(setenv "GOGC" "400"))))))))))
(define-public go go-1.9)

1
gnu/packages/haskell-web.scm
View file

@ -369,7 +369,6 @@ (define-public ghc-http-conduit
("ghc-warp" ,ghc-warp)
("ghc-wai-conduit" ,ghc-wai-conduit)
("ghc-http-types" ,ghc-http-types)
("ghc-http-client" ,ghc-http-client)
("ghc-cookie" ,ghc-cookie)
("ghc-conduit-extra" ,ghc-conduit-extra)
("ghc-streaming-commons" ,ghc-streaming-commons)

723
gnu/packages/haskell.scm
View file

@ -43,6 +43,7 @@ (define-module (gnu packages haskell)
#:use-module (gnu packages ghostscript)
#:use-module (gnu packages gl)
#:use-module (gnu packages graphviz)
#:use-module (gnu packages gtk)
#:use-module (gnu packages haskell-check)
#:use-module (gnu packages haskell-crypto)
#:use-module (gnu packages haskell-web)
@ -3003,6 +3004,17 @@ (define-public ghc-regex
(base32
"1sjkpkgv4phy5b5v2lr89x4vx4dh44pj0sbvlsp6n86w9v6v4jwb"))))
(build-system haskell-build-system)
(arguments
`(#:phases
(modify-phases %standard-phases
(add-after 'unpack 'relax-dependencies
(lambda _
(substitute* "regex.cabal"
(("base-compat.*>=.*0.6.*")
"base-compat >= 0.6\n")
(("template-haskell.*>=.*2.7.*")
"template-haskell >= 2.7\n"))
#t)))))
(inputs
`(("ghc-base-compat" ,ghc-base-compat)
("ghc-hashable" ,ghc-hashable)
@ -10576,6 +10588,533 @@ (define-public ghc-rio
@end itemize")
(license license:expat)))
(define-public ghc-cairo
(package
(name "ghc-cairo")
(version "0.13.5.0")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/cairo/"
"cairo-" version ".tar.gz"))
(sha256
(base32
"1wxylv4d8120ri0vgar168ikqa9m6533ipdwi38qlmxmw20ws2j2"))))
(build-system haskell-build-system)
(arguments
`(#:modules ((guix build haskell-build-system)
(guix build utils)
(ice-9 match)
(srfi srfi-26))
#:phases
(modify-phases %standard-phases
;; FIXME: This is a copy of the standard configure phase with a tiny
;; difference: this package needs the -package-db flag to be passed
;; to "runhaskell" in addition to the "configure" action, because it
;; depends on gtk2hs-buildtools, which provide setup hooks. Without
;; this option the Setup.hs file cannot be evaluated. The
;; haskell-build-system should be changed to pass "-package-db" to
;; "runhaskell" in any case.
(replace 'configure
(lambda* (#:key outputs inputs tests? (configure-flags '())
#:allow-other-keys)
(let* ((out (assoc-ref outputs "out"))
(input-dirs (match inputs
(((_ . dir) ...)
dir)
(_ '())))
(ghc-path (getenv "GHC_PACKAGE_PATH"))
(params (append `(,(string-append "--prefix=" out))
`(,(string-append "--libdir=" out "/lib"))
`(,(string-append "--bindir=" out "/bin"))
`(,(string-append
"--docdir=" out
"/share/doc/" ((@@ (guix build haskell-build-system)
package-name-version) out)))
'("--libsubdir=$compiler/$pkg-$version")
'("--package-db=../package.conf.d")
'("--global")
`(,@(map
(cut string-append "--extra-include-dirs=" <>)
(search-path-as-list '("include") input-dirs)))
`(,@(map
(cut string-append "--extra-lib-dirs=" <>)
(search-path-as-list '("lib") input-dirs)))
(if tests?
'("--enable-tests")
'())
configure-flags)))
(unsetenv "GHC_PACKAGE_PATH")
(apply invoke "runhaskell" "-package-db=../package.conf.d"
"Setup.hs" "configure" params)
(setenv "GHC_PACKAGE_PATH" ghc-path)
#t))))))
(inputs
`(("ghc-utf8-string" ,ghc-utf8-string)
("ghc-text" ,ghc-text)
("cairo" ,cairo)))
(native-inputs
`(("ghc-gtk2hs-buildtools" ,ghc-gtk2hs-buildtools)
("pkg-config" ,pkg-config)))
(home-page "http://projects.haskell.org/gtk2hs/")
(synopsis "Haskell bindings to the Cairo vector graphics library")
(description
"Cairo is a library to render high quality vector graphics. There exist
various backends that allows rendering to Gtk windows, PDF, PS, PNG and SVG
documents, amongst others.")
(license license:bsd-3)))
(define-public ghc-chart-cairo
(package
(name "ghc-chart-cairo")
(version "1.9")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/Chart-cairo/"
"Chart-cairo-" version ".tar.gz"))
(sha256
(base32
"0iany6lfyfb1cw0pxfs5aw5k0a6x41m6ql9ad9w59biwdckbsyqr"))))
(build-system haskell-build-system)
(inputs
`(("ghc-old-locale" ,ghc-old-locale)
("ghc-cairo" ,ghc-cairo)
("ghc-colour" ,ghc-colour)
("ghc-data-default-class" ,ghc-data-default-class)
("ghc-operational" ,ghc-operational)
("ghc-lens" ,ghc-lens)
("ghc-chart" ,ghc-chart)))
(home-page "https://github.com/timbod7/haskell-chart/wiki")
(synopsis "Cairo backend for Charts")
(description "This package provides a Cairo vector graphics rendering
backend for the Charts library.")
(license license:bsd-3)))
(define-public ghc-atomic-write
(package
(name "ghc-atomic-write")
(version "0.2.0.5")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/atomic-write/atomic-write-"
version
".tar.gz"))
(sha256
(base32
"1iaq0hprxcv0sl1sgwcgmm87zraf738va1bciwnx2jkk3k1v9iyv"))))
(build-system haskell-build-system)
(inputs
`(("ghc-temporary" ,ghc-temporary)
("ghc-unix-compat" ,ghc-unix-compat)
("ghc-text" ,ghc-text)))
(native-inputs
`(("ghc-temporary" ,ghc-temporary)
("ghc-unix-compat" ,ghc-unix-compat)
("ghc-text" ,ghc-text)
("ghc-hspec" ,ghc-hspec)
("hspec-discover" ,hspec-discover)))
(home-page "https://github.com/stackbuilders/atomic-write")
(synopsis "Atomically write to a file")
(description
"Atomically write to a file on POSIX-compliant systems while preserving
permissions. @code{mv} is an atomic operation. This makes it simple to write
to a file atomically just by using the @code{mv} operation. However, this
will destroy the permissions on the original file. This library preserves
permissions while atomically writing to a file.")
(license license:expat)))
(define-public ghc-cereal-conduit
(package
(name "ghc-cereal-conduit")
(version "0.8.0")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"cereal-conduit/cereal-conduit-"
version ".tar.gz"))
(sha256
(base32
"1srr7agvgfw78q5s1npjq5sgynvhjgllpihiv37ylkwqm4c4ap6r"))))
(build-system haskell-build-system)
(inputs
`(("ghc-conduit" ,ghc-conduit)
("ghc-resourcet" ,ghc-resourcet)
("ghc-cereal" ,ghc-cereal)))
(native-inputs
`(("ghc-hunit" ,ghc-hunit)))
(home-page "https://github.com/snoyberg/conduit")
(synopsis "Turn Data.Serialize Gets and Puts into Sources, Sinks, and Conduits")
(description
"This package turn @code{Data.Serialize} @code{Gets} and @code{Puts} into
@code{Sources}, @code{Sinks}, and @code{Conduits}.")
(license license:bsd-3)))
(define-public ghc-lzma
(package
(name "ghc-lzma")
(version "0.0.0.3")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/lzma/"
"lzma-" version ".tar.gz"))
(sha256
(base32
"0i416gqi8j55nd1pqbkxvf3f6hn6fjys6gq98lkkxphva71j30xg"))))
(build-system haskell-build-system)
(arguments
'(#:tests? #f ; requires older versions of QuickCheck and tasty.
#:cabal-revision
("3" "1sify6gnsalyp6dakfzi0mdy5jcz2kcp9jsdsgkmxd40nfzgd44m")))
(native-inputs
`(("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 "https://github.com/hvr/lzma")
(synopsis "LZMA/XZ compression and decompression")
(description
"This package provides a pure interface for compressing and
decompressing LZMA streams of data represented as lazy @code{ByteString}s. A
monadic incremental interface is provided as well.")
(license license:bsd-3)))
(define-public ghc-stm-conduit
(package
(name "ghc-stm-conduit")
(version "4.0.0")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/stm-conduit/"
"stm-conduit-" version ".tar.gz"))
(sha256
(base32
"0paapljn7nqfzrx889y0n8sszci38mdiaxkgr0bb00ph9246rr7z"))))
(build-system haskell-build-system)
(inputs
`(("ghc-stm" ,ghc-stm)
("ghc-stm-chans" ,ghc-stm-chans)
("ghc-cereal" ,ghc-cereal)
("ghc-cereal-conduit" ,ghc-cereal-conduit)
("ghc-conduit" ,ghc-conduit)
("ghc-conduit-extra" ,ghc-conduit-extra)
("ghc-exceptions" ,ghc-exceptions)
("ghc-resourcet" ,ghc-resourcet)
("ghc-async" ,ghc-async)
("ghc-monad-loops" ,ghc-monad-loops)
("ghc-unliftio" ,ghc-unliftio)))
(native-inputs
`(("ghc-doctest" ,ghc-doctest)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-hunit" ,ghc-hunit)
("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
(home-page "https://github.com/cgaebel/stm-conduit")
(synopsis "Introduces conduits to channels and promotes using conduits concurrently")
(description
"This package provides two simple conduit wrappers around STM channels: a
source and a sink.")
(license license:bsd-3)))
(define-public ghc-bindings-dsl
(package
(name "ghc-bindings-dsl")
(version "1.0.25")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/bindings-DSL/"
"bindings-DSL-" version ".tar.gz"))
(sha256
(base32
"0kqrd78nspl3lk4a0fqn47d8dirjg3b24dkvkigcrlb81hw35pk3"))))
(build-system haskell-build-system)
(home-page "https://github.com/jwiegley/bindings-dsl/wiki")
(synopsis "FFI domain specific language, on top of hsc2hs")
(description
"This is a set of macros to be used when writing Haskell FFI. They were
designed to be able to fully describe C interfaces, so that @code{hsc2hs} can
extract from them all Haskell code needed to mimic such interfaces. All
Haskell names used are automatically derived from C names, structures are
mapped to Haskell instances of @code{Storable}, and there are also macros you
can use with C code to help write bindings to inline functions or macro
functions.")
(license license:bsd-3)))
(define-public ghc-lzma-conduit
(package
(name "ghc-lzma-conduit")
(version "1.2.1")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/lzma-conduit/"
"lzma-conduit-" version ".tar.gz"))
(sha256
(base32
"0hm72da7xk9l3zxjh274yg444vf405djxqbkf3q3p2qhicmxlmg9"))))
(build-system haskell-build-system)
(inputs
`(("ghc-conduit" ,ghc-conduit)
("ghc-lzma" ,ghc-lzma)
("ghc-resourcet" ,ghc-resourcet)))
(native-inputs
`(("ghc-base-compat" ,ghc-base-compat)
("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
("ghc-hunit" ,ghc-hunit)
("ghc-quickcheck" ,ghc-quickcheck)))
(home-page "https://github.com/alphaHeavy/lzma-conduit")
(synopsis "Conduit interface for lzma/xz compression")
(description
"This package provides a @code{Conduit} interface for the LZMA
compression algorithm used in the @code{.xz} file format.")
(license license:bsd-3)))
(define-public ghc-bzlib-conduit
(package
(name "ghc-bzlib-conduit")
(version "0.3.0.1")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/bzlib-conduit/"
"bzlib-conduit-" version ".tar.gz"))
(sha256
(base32
"0fd2hnr782s7qgipazg2yxwia9qqhkvm9bcm90773c3zkxa13n23"))))
(build-system haskell-build-system)
(inputs
`(("ghc-bindings-dsl" ,ghc-bindings-dsl)
("ghc-conduit" ,ghc-conduit)
("ghc-data-default-class" ,ghc-data-default-class)
("ghc-resourcet" ,ghc-resourcet)))
(native-inputs
`(("ghc-hspec" ,ghc-hspec)
("ghc-random" ,ghc-random)))
(home-page "https://github.com/snoyberg/bzlib-conduit")
(synopsis "Streaming compression/decompression via conduits")
(description
"This package provides Haskell bindings to bzlib and Conduit support for
streaming compression and decompression.")
(license license:bsd-3)))
(define-public ghc-pqueue
(package
(name "ghc-pqueue")
(version "1.4.1.1")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"pqueue/pqueue-" version ".tar.gz"))
(sha256
(base32
"1zvwm1zcqqq5n101s1brjhgbay8rf9fviq6gxbplf40i63m57p1x"))))
(build-system haskell-build-system)
(native-inputs
`(("ghc-quickcheck" ,ghc-quickcheck)))
(home-page "https://hackage.haskell.org/package/pqueue")
(synopsis "Reliable, persistent, fast priority queues")
(description
"This package provides a fast, reliable priority queue implementation
based on a binomial heap.")
(license license:bsd-3)))
(define-public ghc-conduit-algorithms
(package
(name "ghc-conduit-algorithms")
(version "0.0.8.1")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"conduit-algorithms/conduit-algorithms-"
version ".tar.gz"))
(sha256
(base32
"07gx2q3d1bbfw14q41rmqg0i4m018pci10lswc0k1ij6lw7sb9fd"))))
(build-system haskell-build-system)
(inputs
`(("ghc-async" ,ghc-async)
("ghc-bzlib-conduit" ,ghc-bzlib-conduit)
("ghc-conduit" ,ghc-conduit)
("ghc-conduit-combinators" ,ghc-conduit-combinators)
("ghc-conduit-extra" ,ghc-conduit-extra)
("ghc-exceptions" ,ghc-exceptions)
("ghc-lzma-conduit" ,ghc-lzma-conduit)
("ghc-monad-control" ,ghc-monad-control)
("ghc-pqueue" ,ghc-pqueue)
("ghc-resourcet" ,ghc-resourcet)
("ghc-stm" ,ghc-stm)
("ghc-stm-conduit" ,ghc-stm-conduit)
("ghc-streaming-commons" ,ghc-streaming-commons)
("ghc-unliftio-core" ,ghc-unliftio-core)
("ghc-vector" ,ghc-vector)))
(native-inputs
`(("ghc-hunit" ,ghc-hunit)
("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
("ghc-test-framework-th" ,ghc-test-framework-th)))
(home-page "https://github.com/luispedro/conduit-algorithms#readme")
(synopsis "Conduit-based algorithms")
(description
"This package provides algorithms on @code{Conduits}, including higher
level asynchronous processing and some other utilities.")
(license license:expat)))
(define-public ghc-interpolate
(package
(name "ghc-interpolate")
(version "0.2.0")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/interpolate/"
"interpolate-" version ".tar.gz"))
(sha256
(base32
"1gkaj98yz363v38fv78sqby236mp8yqwqcilx7kr2b9z0w3204bf"))))
(build-system haskell-build-system)
(inputs
`(("ghc-haskell-src-meta" ,ghc-haskell-src-meta)))
(native-inputs
`(("ghc-base-compat" ,ghc-base-compat)
("ghc-hspec" ,ghc-hspec)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
("ghc-text" ,ghc-text)
("hspec-discover" ,hspec-discover)))
(home-page "https://github.com/sol/interpolate")
(synopsis "String interpolation library")
(description "This package provides a string interpolation library for
Haskell.")
(license license:expat)))
(define-public ghc-hpack
(package
(name "ghc-hpack")
(version "0.28.2")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/hpack/"
"hpack-" version ".tar.gz"))
(sha256
(base32
"18w0h76jdp3mk9vin8da9iz3cwhcxmw787xy8wlh8bxcpcr16q5r"))))
(build-system haskell-build-system)
(inputs
`(("ghc-aeson" ,ghc-aeson)
("ghc-bifunctors" ,ghc-bifunctors)
("ghc-cryptonite" ,ghc-cryptonite)
("ghc-glob" ,ghc-glob)
("ghc-http-client" ,ghc-http-client)
("ghc-http-client-tls" ,ghc-http-client-tls)
("ghc-http-types" ,ghc-http-types)
("ghc-scientific" ,ghc-scientific)
("ghc-text" ,ghc-text)
("ghc-unordered-containers" ,ghc-unordered-containers)
("ghc-vector" ,ghc-vector)
("ghc-yaml" ,ghc-yaml)))
(native-inputs
`(("ghc-hspec" ,ghc-hspec)
("ghc-hunit" ,ghc-hunit)
("ghc-interpolate" ,ghc-interpolate)
("ghc-mockery" ,ghc-mockery)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-temporary" ,ghc-temporary)
("hspec-discover" ,hspec-discover)))
(home-page "https://github.com/sol/hpack")
(synopsis "Tools for an alternative Haskell package format")
(description
"Hpack is a format for Haskell packages. It is an alternative to the
Cabal package format and follows different design principles. Hpack packages
are described in a file named @code{package.yaml}. Both @code{cabal2nix} and
@code{stack} support @code{package.yaml} natively. For other build tools the
@code{hpack} executable can be used to generate a @code{.cabal} file from
@code{package.yaml}.")
(license license:expat)))
(define-public ghc-raw-strings-qq
(package
(name "ghc-raw-strings-qq")
(version "1.1")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"raw-strings-qq/raw-strings-qq-"
version ".tar.gz"))
(sha256
(base32
"1lxy1wy3awf52968iy5y9r5z4qgnn2sxkdrh7js3m9gadb11w09f"))))
(build-system haskell-build-system)
(native-inputs `(("ghc-hunit" ,ghc-hunit)))
(home-page "https://github.com/23Skidoo/raw-strings-qq")
(synopsis "Raw string literals for Haskell")
(description
"This package provides a quasiquoter for raw string literals, i.e. string
literals that don't recognise the standard escape sequences. Basically, they
make your code more readable by freeing you from the responsibility to escape
backslashes. They are useful when working with regular expressions,
DOS/Windows paths and markup languages (such as XML).")
(license license:bsd-3)))
(define-public ghc-inline-c
(package
(name "ghc-inline-c")
(version "0.6.1.0")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/inline-c/"
"inline-c-" version ".tar.gz"))
(sha256
(base32
"0vbfrsqsi7mdziqsnj68bsqlwbqxxhvrmy9rv6w8z18d1m8w3n6h"))))
(build-system haskell-build-system)
(arguments
`(#:phases
(modify-phases %standard-phases
(add-after 'unpack 'create-Setup.hs
(lambda _
(with-output-to-file "Setup.hs"
(lambda _
(display "\
import Distribution.Simple
main = defaultMain")))
#t)))))
(inputs
`(("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
("ghc-cryptohash" ,ghc-cryptohash)
("ghc-hashable" ,ghc-hashable)
("ghc-parsec" ,ghc-parsec)
("ghc-parsers" ,ghc-parsers)
("ghc-unordered-containers" ,ghc-unordered-containers)
("ghc-vector" ,ghc-vector)))
(native-inputs
`(("ghc-quickcheck" ,ghc-quickcheck)
("ghc-hspec" ,ghc-hspec)
("ghc-raw-strings-qq" ,ghc-raw-strings-qq)
("ghc-regex-posix" ,ghc-regex-posix)))
(home-page "http://hackage.haskell.org/package/inline-c")
(synopsis "Write Haskell source files including C code inline")
(description
"inline-c lets you seamlessly call C libraries and embed high-performance
inline C code in Haskell modules. Haskell and C can be freely intermixed in
the same source file, and data passed to and from code in either language with
minimal overhead. No FFI required.")
(license license:expat)))
(define-public ghc-weigh
(package
(name "ghc-weigh")
@ -10641,4 +11180,188 @@ (define-public ghc-linear
vector spaces.")
(license license:bsd-3)))
(define-public ghc-safe-exceptions
(package
(name "ghc-safe-exceptions")
(version "0.1.7.0")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"safe-exceptions/safe-exceptions-"
version ".tar.gz"))
(sha256
(base32
"0sd0zfsm9pcll5bzzj523rbn45adjrnavdkz52hgmdjjgdcdrk8q"))))
(build-system haskell-build-system)
(arguments
'(#:cabal-revision
("4" "0fid41gishzsyb47wzxhd5falandfirqcp760hcja81qjpfmqd32")))
(inputs `(("ghc-exceptions" ,ghc-exceptions)))
(native-inputs
`(("ghc-hspec" ,ghc-hspec)
("ghc-void" ,ghc-void)
("hspec-discover" ,hspec-discover)))
(home-page "https://github.com/fpco/safe-exceptions")
(synopsis "Safe, consistent, and easy exception handling")
(description "Runtime exceptions - as exposed in @code{base} by the
@code{Control.Exception} module - have long been an intimidating part of the
Haskell ecosystem. This package is intended to overcome this. It provides a
safe and simple API on top of the existing exception handling machinery. The
API is equivalent to the underlying implementation in terms of power but
encourages best practices to minimize the chances of getting the exception
handling wrong.")
(license license:expat)))
(define-public ghc-inline-c-cpp
(package
(name "ghc-inline-c-cpp")
(version "0.2.2.1")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/inline-c-cpp/"
"inline-c-cpp-" version ".tar.gz"))
(sha256
(base32
"1rk7fmpkmxw9hhwr8df29kadnf0ybnwj64ggdbnsdrpfyhnkisci"))))
(build-system haskell-build-system)
(arguments
`(#:phases
(modify-phases %standard-phases
(add-after 'unpack 'create-Setup.hs
(lambda _
(with-output-to-file "Setup.hs"
(lambda _
(display "\
import Distribution.Simple
main = defaultMain")))
#t)))))
(inputs
`(("ghc-inline-c" ,ghc-inline-c)
("ghc-safe-exceptions" ,ghc-safe-exceptions)))
(native-inputs
`(("ghc-hspec" ,ghc-hspec)))
(home-page "https://hackage.haskell.org/package/inline-c-cpp")
(synopsis "Lets you embed C++ code into Haskell")
(description
"This package provides utilities to inline C++ code into Haskell using
@code{inline-c}.")
(license license:expat)))
(define-public ghc-bytestring-lexing
(package
(name "ghc-bytestring-lexing")
(version "0.5.0.2")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"bytestring-lexing/bytestring-lexing-"
version ".tar.gz"))
(sha256
(base32
"0wrzniawhgpphc6yx1v972gyqxdbv0pizaz9bafahrshyb9svy81"))))
(build-system haskell-build-system)
(home-page "http://code.haskell.org/~wren/")
(synopsis "Parse and produce literals from strict or lazy bytestrings")
(description
"This package provides tools to parse and produce literals efficiently
from strict or lazy bytestrings.")
(license license:bsd-2)))
(define-public ghc-configurator
(package
(name "ghc-configurator")
(version "0.3.0.0")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"configurator/configurator-"
version ".tar.gz"))
(sha256
(base32
"1d1iq1knwiq6ia5g64rw5hqm6dakz912qj13r89737rfcxmrkfbf"))))
(build-system haskell-build-system)
(inputs
`(("ghc-attoparsec" ,ghc-attoparsec)
("ghc-hashable" ,ghc-hashable)
("ghc-text" ,ghc-text)
("ghc-unix-compat" ,ghc-unix-compat)
("ghc-unordered-containers" ,ghc-unordered-containers)))
(native-inputs
`(("ghc-hunit" ,ghc-hunit)
("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
(home-page "http://github.com/bos/configurator")
(synopsis "Configuration management")
(description
"This package provides a configuration management library for programs
and daemons. The features include:
@enumerate
@item Automatic, dynamic reloading in response to modifications to
configuration files.
@item A simple, but flexible, configuration language, supporting several of
the most commonly needed types of data, along with interpolation of strings
from the configuration or the system environment (e.g. @code{$(HOME)}).
@item Subscription-based notification of changes to configuration properties.
@item An @code{import} directive allows the configuration of a complex
application to be split across several smaller files, or common configuration
data to be shared across several applications.
@end enumerate\n")
(license license:bsd-3)))
(define-public ghc-file-embed
(package
(name "ghc-file-embed")
(version "0.0.10.1")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/file-embed/"
"file-embed-" version ".tar.gz"))
(sha256
(base32
"0lj164cnzqyd487mli91nnr7137a4h4qsasfwsnsh77sx12fpk9k"))))
(build-system haskell-build-system)
(home-page "https://github.com/snoyberg/file-embed")
(synopsis "Use Template Haskell to embed file contents directly")
(description
"This package allows you to use Template Haskell to read a file or all
the files in a directory, and turn them into @code{(path, bytestring)} pairs
embedded in your Haskell code.")
(license license:bsd-3)))
(define-public ghc-safeio
(package
(name "ghc-safeio")
(version "0.0.5.0")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/safeio/"
"safeio-" version ".tar.gz"))
(sha256
(base32
"04g3070cbjdqj0h9l9ii6470xcbn40xfv4fr89a8yvnkdim9nyfm"))))
(build-system haskell-build-system)
(inputs
`(("ghc-conduit" ,ghc-conduit)
("ghc-conduit-combinators" ,ghc-conduit-combinators)
("ghc-exceptions" ,ghc-exceptions)
("ghc-resourcet" ,ghc-resourcet)))
(native-inputs
`(("ghc-hunit" ,ghc-hunit)
("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
("ghc-test-framework-th" ,ghc-test-framework-th)))
(home-page "https://github.com/luispedro/safeio")
(synopsis "Write output to disk atomically")
(description
"This package implements utilities to perform atomic output so as to
avoid the problem of partial intermediate files.")
(license license:expat)))
;;; haskell.scm ends here

33
gnu/packages/java.scm
View file

@ -9634,6 +9634,39 @@ (define-public java-xerces
the DOM level 3 load/save API's are in use.")
(license license:asl2.0)))
(define-public java-jakarta-regexp
(package
(name "java-jakarta-regexp")
(version "1.5")
(source
(origin
(method url-fetch)
(uri (string-append
"https://archive.apache.org/dist/jakarta/regexp/jakarta-regexp-"
version ".tar.gz"))
(sha256
(base32
"0zg9rmyif48dck0cv6ynpxv23mmcsx265am1fnnxss7brgw0ms3r"))))
(build-system ant-build-system)
(arguments
`(#:test-target "test"
#:phases
(modify-phases %standard-phases
(replace 'install
(lambda* (#:key outputs #:allow-other-keys)
(let* ((out (assoc-ref outputs "out"))
(out-share (string-append out "/share/java")))
(mkdir-p out-share)
(for-each (lambda (name)
(install-file name out-share))
(find-files "build" "^jakarta-regexp-.*\\.jar$"))
#t))))))
(home-page "https://attic.apache.org/projects/jakarta-regexp.html")
(synopsis "Regular expression parser generator for Java.")
(description "@code{jakarta-regexp} is an old regular expression parser
generator for Java.")
(license license:asl2.0)))
(define-public java-jline
(package
(name "java-jline")

3
gnu/packages/libreoffice.scm
View file

@ -1027,9 +1027,6 @@ (define-public libreoffice
(arguments
`(#:tests? #f ; Building the tests already fails.
#:make-flags '("build-nocheck") ; Do not build unit tests, which fails.
;; XXX Remove this if glib-or-gtk-build-system changes to in-source-tree
;; builds by default.
#:out-of-source? #f
#:phases
(modify-phases %standard-phases
(add-before 'configure 'prepare-src

5
gnu/packages/mes.scm
View file

@ -63,15 +63,14 @@ (define-public mes
(let ((triplet "i686-unknown-linux-gnu"))
(package
(name "mes")
(version "0.17.1")
(version "0.18")
(source (origin
(method url-fetch)
(uri (string-append "mirror://gnu/mes/"
"mes-" version ".tar.gz"))
(patches (search-patches "mes-nyacc-0.86.0.patch"))
(sha256
(base32
"02g8zig53ffd0ai8kqhv2zj7bj2366a8hr6ydkwakmi2d1amyrna"))))
"1dsaaqyanzsq9m5wrcd2bjhb3qd6928c9q97rg5r730pyqjwxyxf"))))
(build-system gnu-build-system)
(supported-systems '("i686-linux" "x86_64-linux"))
(propagated-inputs

16
gnu/packages/mpd.scm
View file

@ -47,6 +47,7 @@ (define-module (gnu packages mpd)
#:use-module (gnu packages linux)
#:use-module (gnu packages mp3)
#:use-module (gnu packages ncurses)
#:use-module (gnu packages pcre)
#:use-module (gnu packages pkg-config)
#:use-module (gnu packages python)
#:use-module (gnu packages pulseaudio)
@ -186,7 +187,7 @@ (define-public mpd-mpc
(define-public ncmpc
(package
(name "ncmpc")
(version "0.30")
(version "0.32")
(source (origin
(method url-fetch)
(uri
@ -195,11 +196,14 @@ (define-public ncmpc
"/ncmpc-" version ".tar.xz"))
(sha256
(base32
"18qj3cgqczgfk334x0ywxwa1ckrk9fbjyp34n4zzcxwaifshrzp3"))))
"1b01q1pcaw5yyhvmlffc3h0r3w8qy7rhn55a7xj4qkcfqvs8ap08"))))
(build-system meson-build-system)
(arguments
`(#:configure-flags
(list "-Dcurses=ncurses")
;; Otherwise, they are installed incorrectly, in
;; '$out/share/man/man/man1'.
(list (string-append "-Dmandir=" (assoc-ref %outputs "out")
"/share"))
#:phases
(modify-phases %standard-phases
(add-before 'configure 'expand-C++-include-path
@ -211,11 +215,13 @@ (define-public ncmpc
(setenv path (string-append c++ ":" (getenv path)))
#t))))))
(inputs `(("gcc", gcc-8) ; for its C++14 support
("glib" ,glib)
("boost" ,boost)
("pcre" ,pcre)
("libmpdclient" ,libmpdclient)
("ncurses" ,ncurses)))
(native-inputs `(("gettext" ,gettext-minimal) ; for xgettext
("pkg-config" ,pkg-config)))
("pkg-config" ,pkg-config)
("python-sphinx" ,python-sphinx)))
(synopsis "Curses Music Player Daemon client")
(description "ncmpc is a fully featured MPD client, which runs in a
terminal using ncurses.")

14
gnu/packages/music.scm
View file

@ -1726,7 +1726,7 @@ (define-public tuxguitar
(define-public pd
(package
(name "pd")
(version "0.47-1")
(version "0.49-0")
(source (origin
(method url-fetch)
(uri
@ -1734,16 +1734,20 @@ (define-public pd
version ".src.tar.gz"))
(sha256
(base32
"0k5s949kqd7yw97h3m8z81bjz32bis9m4ih8df1z0ymipnafca67"))))
"18rzqbpgnnvyslap7k0ly87aw1bbxkb0rk5agpr423ibs9slxq6j"))))
(build-system gnu-build-system)
(arguments
`(#:tests? #f ; no "check" target
#:configure-flags
(list
"--enable-jack"
(string-append "--with-wish=" (string-append
(assoc-ref %build-inputs "tk")
"/bin/wish8.6")))
#:phases
(modify-phases %standard-phases
(add-before 'configure 'fix-wish-path
(add-before 'configure 'fix-with-path
(lambda _
(substitute* "src/s_inter.c"
((" wish ") (string-append " " (which "wish8.6") " ")))
(substitute* "tcl/pd-gui.tcl"
(("exec wish ") (string-append "exec " (which "wish8.6") " ")))
#t))

40
gnu/packages/patches/bastet-change-source-of-unordered_set.patch Normal file
View file

@ -0,0 +1,40 @@
From: Tobias Geerinckx-Rice <me@tobias.gr>
Date: Wed, 3 Oct 2018 23:30:42 +0200
Subject: [PATCH] bastet: Change source of unordered_set.
This allows building bastet 0.43.2 with boost >=1.66.
It was backported verbatim from the upstream master branch.
From 0e03f8d4d6bc6949cf1c447e632ce0d1b98c4be1 Mon Sep 17 00:00:00 2001
From: Federico Poloni <fpoloni@di.unipi.it>
Date: Wed, 4 Oct 2017 19:35:01 +0200
Subject: [PATCH] Changed source of unordered_set (should hopefully fix #6
without reopening #1)
---
BastetBlockChooser.hpp | 5 ++---
1 file changed, 2 insertions(+), 3 deletions(-)
diff --git a/BastetBlockChooser.hpp b/BastetBlockChooser.hpp
index 992e556..7ee3b7c 100644
--- a/BastetBlockChooser.hpp
+++ b/BastetBlockChooser.hpp
@@ -23,8 +23,7 @@
#include "Well.hpp"
-#include <boost/tr1/tr1/unordered_set>
-#include <set>
+#include <boost/unordered_set.hpp>
#include <boost/functional/hash.hpp>
namespace Bastet{
@@ -75,7 +74,7 @@ namespace Bastet{
public:
Searcher(BlockType b, const Well *well, Vertex v, WellVisitor *visitor);
private:
- std::tr1::unordered_set<Vertex> _visited;
+ boost::unordered_set<Vertex> _visited;
//std::set<Vertex> _visited; ^^ the above is more efficient, we need to do many inserts
BlockType _block;
const Well *_well;

32
gnu/packages/patches/borg-respect-storage-quota.patch Normal file
View file

@ -0,0 +1,32 @@
Make sure the client respects the storage quota set by the server:
https://github.com/borgbackup/borg/issues/4093
Patch copied from upstream source repository:
https://github.com/borgbackup/borg/commit/975cc33206e0e3644626fb7204c34d2157715b61
From 975cc33206e0e3644626fb7204c34d2157715b61 Mon Sep 17 00:00:00 2001
From: Manu <manu@snapdragon.cc>
Date: Wed, 3 Oct 2018 23:47:36 +0800
Subject: [PATCH] Add storage_quota for forced_result if set by serve command.
---
src/borg/archiver.py | 1 +
1 file changed, 1 insertion(+)
diff --git a/src/borg/archiver.py b/src/borg/archiver.py
index 916725e7..279194c1 100644
--- a/src/borg/archiver.py
+++ b/src/borg/archiver.py
@@ -4276,6 +4276,7 @@ def get_args(self, argv, cmd):
result.restrict_to_paths = forced_result.restrict_to_paths
result.restrict_to_repositories = forced_result.restrict_to_repositories
result.append_only = forced_result.append_only
+ result.storage_quota = forced_result.storage_quota
return result
def parse_args(self, args=None):
--
2.19.1

39
gnu/packages/patches/gnucash-disable-failing-tests.patch Normal file
View file

@ -0,0 +1,39 @@
test-stress-options.scm does not exist, and test-qof passes when run in the
build directory after the gnucash build.
diff -ur gnucash-3.3.old/gnucash/report/standard-reports/test/CMakeLists.txt gnucash-3.3/gnucash/report/standard-reports/test/CMakeLists.txt
--- gnucash-3.3.old/gnucash/report/standard-reports/test/CMakeLists.txt 2018-10-04 09:29:00.916641417 -0400
+++ gnucash-3.3/gnucash/report/standard-reports/test/CMakeLists.txt 2018-10-04 09:30:52.962504860 -0400
@@ -13,10 +13,6 @@
test-income-gst.scm
)
-set(scm_test_with_textual_ports_SOURCES
- test-stress-options.scm
-)
-
set(GUILE_DEPENDS
scm-gnc-module
scm-app-utils
@@ -31,9 +27,6 @@
if (HAVE_SRFI64)
gnc_add_scheme_tests("${scm_test_with_srfi64_SOURCES}")
- if (HAVE_TEXT_PORTS)
- gnc_add_scheme_tests("${scm_test_with_textual_ports_SOURCES}")
- endif (HAVE_TEXT_PORTS)
endif (HAVE_SRFI64)
gnc_add_scheme_tests("${scm_test_standard_reports_SOURCES}")
diff -ur gnucash-3.3.old/libgnucash/engine/test/CMakeLists.txt gnucash-3.3/libgnucash/engine/test/CMakeLists.txt
--- gnucash-3.3.old/libgnucash/engine/test/CMakeLists.txt 2018-10-04 09:29:00.876640751 -0400
+++ gnucash-3.3/libgnucash/engine/test/CMakeLists.txt 2018-10-05 10:46:22.542962546 -0400
@@ -54,8 +54,6 @@
# This test does not run on Win32
if (NOT WIN32)
set(SOURCES ${test_qof_SOURCES} ${CMAKE_SOURCE_DIR}/common/test-core/unittest-support.c)
- add_engine_test(test-qof "${SOURCES}")
- target_compile_definitions(test-qof PRIVATE TESTPROG=test_qof)
set(SOURCES ${test_engine_SOURCES} ${CMAKE_SOURCE_DIR}/common/test-core/unittest-support.c)
add_engine_test(test-engine "${SOURCES}")

5
gnu/packages/patches/gnucash-price-quotes-perl.patch
View file

@ -1,8 +1,9 @@
After wrapping gnc-fq-check and gnc-fq-helper we can no longer execute them
with perl, so execute them directly instead.
--- gnucash-2.6.6/src/scm/price-quotes.scm.orig 2014-04-27 17:42:28.000000000 -0500
+++ gnucash-2.6.6/src/scm/price-quotes.scm 2015-07-09 16:12:11.196218472 -0500
diff -ur gnucash-3.2.old/libgnucash/scm/price-quotes.scm gnucash-3.2/libgnucash/scm/price-quotes.scm
--- gnucash-3.2.old/libgnucash/scm/price-quotes.scm 2018-09-15 00:48:33.718389646 -0400
+++ gnucash-3.2/libgnucash/scm/price-quotes.scm 2018-09-15 13:51:49.249862724 -0400
@@ -74,7 +74,7 @@
(define (start-program)
(if (not (string-null? gnc:*finance-quote-check*))

197
gnu/packages/patches/mes-nyacc-0.86.0.patch
View file

@ -1,197 +0,0 @@
From 9e610736bf779f3295c1192e748cd19cbbe3be28 Mon Sep 17 00:00:00 2001
From: Jan Nieuwenhuizen <janneke@gnu.org>
Date: Wed, 5 Sep 2018 20:28:06 +0200
Subject: [PATCH 1/2] mes: Support Nyacc 0.85.3: Add char-set-copy.
* mes/module/srfi/srfi-14.mes (char-set-copy): New function>
---
mes/module/srfi/srfi-14.mes | 3 +++
1 file changed, 3 insertions(+)
diff --git a/mes/module/srfi/srfi-14.mes b/mes/module/srfi/srfi-14.mes
index 0be39b1e..a16d16ce 100644
--- a/mes/module/srfi/srfi-14.mes
+++ b/mes/module/srfi/srfi-14.mes
@@ -52,3 +52,6 @@
(define (char-whitespace? c)
(char-set-contains? char-set:whitespace c))
+
+(define (char-set-copy cs)
+ (map identity cs))
--
2.18.0
From b952bdf44f11edbfc277600dc35236aae1769b54 Mon Sep 17 00:00:00 2001
From: Jan Nieuwenhuizen <janneke@gnu.org>
Date: Wed, 5 Sep 2018 22:14:34 +0200
Subject: [PATCH 2/2] mes: Support Nyacc 0.85.3: Integrate progress.
* mes/module/nyacc/lang/sx-util.mes: New file.
* mes/module/nyacc/version.mes: New file.
* mes/module/nyacc/lang/c99/cpp.mes (nyacc): Include them.
* mes/module/nyacc/lang/c99/parser.mes (nyacc): Include them.
* module/mescc/preprocess.scm (need-progress): New function.
(progress): New function.
(insert-progress-monitors): Use them to Integrate progress.
---
mes/module/mescc/preprocess.mes | 1 +
mes/module/nyacc/lang/c99/cpp.mes | 1 +
mes/module/nyacc/lang/c99/parser.mes | 1 +
mes/module/nyacc/lang/sx-util.mes | 27 +++++++++++++++++++++
mes/module/nyacc/version.mes | 26 +++++++++++++++++++++
module/mescc/preprocess.scm | 35 ++++++++++++++++++++++++++++
6 files changed, 91 insertions(+)
create mode 100644 mes/module/nyacc/lang/sx-util.mes
create mode 100644 mes/module/nyacc/version.mes
diff --git a/mes/module/mescc/preprocess.mes b/mes/module/mescc/preprocess.mes
index c7c5fcaa..022a372c 100644
--- a/mes/module/mescc/preprocess.mes
+++ b/mes/module/mescc/preprocess.mes
@@ -24,4 +24,5 @@
(mes-use-module (srfi srfi-13))
(mes-use-module (srfi srfi-26))
(mes-use-module (nyacc lang c99 parser))
+(mes-use-module (nyacc version))
(include-from-path "mescc/preprocess.scm")
diff --git a/mes/module/nyacc/lang/c99/cpp.mes b/mes/module/nyacc/lang/c99/cpp.mes
index fad1dc55..b25c4a93 100644
--- a/mes/module/nyacc/lang/c99/cpp.mes
+++ b/mes/module/nyacc/lang/c99/cpp.mes
@@ -28,5 +28,6 @@
(mes-use-module (nyacc parse))
(mes-use-module (nyacc lex))
+(mes-use-module (nyacc lang sx-util))
(mes-use-module (nyacc lang util))
(include-from-path "nyacc/lang/c99/cpp.scm")
diff --git a/mes/module/nyacc/lang/c99/parser.mes b/mes/module/nyacc/lang/c99/parser.mes
index c51552d6..1a9aaf73 100644
--- a/mes/module/nyacc/lang/c99/parser.mes
+++ b/mes/module/nyacc/lang/c99/parser.mes
@@ -32,6 +32,7 @@
(mes-use-module (nyacc lex))
(mes-use-module (nyacc parse))
+(mes-use-module (nyacc lang sx-util))
(mes-use-module (nyacc lang util))
(mes-use-module (nyacc lang c99 cpp))
diff --git a/mes/module/nyacc/lang/sx-util.mes b/mes/module/nyacc/lang/sx-util.mes
new file mode 100644
index 00000000..41ac5b4a
--- /dev/null
+++ b/mes/module/nyacc/lang/sx-util.mes
@@ -0,0 +1,27 @@
+;;; -*-scheme-*-
+
+;;; GNU Mes --- Maxwell Equations of Software
+;;; Copyright © 2018 Jan (janneke) Nieuwenhuizen <janneke@gnu.org>
+;;;
+;;; This file is part of GNU Mes.
+;;;
+;;; GNU Mes 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 Mes 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 Mes. If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;;; Code:
+
+(mes-use-module (srfi srfi-1))
+(mes-use-module (srfi srfi-16))
+(include-from-path "nyacc/lang/sx-util.scm")
diff --git a/mes/module/nyacc/version.mes b/mes/module/nyacc/version.mes
new file mode 100644
index 00000000..b9db628e
--- /dev/null
+++ b/mes/module/nyacc/version.mes
@@ -0,0 +1,26 @@
+;;; -*-scheme-*-
+
+;;; GNU Mes --- Maxwell Equations of Software
+;;; Copyright © 2018 Jan (janneke) Nieuwenhuizen <janneke@gnu.org>
+;;;
+;;; This file is part of GNU Mes.
+;;;
+;;; GNU Mes 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 Mes 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 Mes. If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;;; Code:
+
+(include-from-path "nyacc/version.scm")
+(display "nyacc version\n")
diff --git a/module/mescc/preprocess.scm b/module/mescc/preprocess.scm
index 9e341cba..c2efb32c 100644
--- a/module/mescc/preprocess.scm
+++ b/module/mescc/preprocess.scm
@@ -26,9 +26,44 @@
#:use-module (srfi srfi-1)
#:use-module (srfi srfi-26)
#:use-module (nyacc lang c99 parser)
+ #:use-module (nyacc lang c99 parser)
+ #:use-module (nyacc version)
#:use-module (mes guile)
#:export (c99-input->ast))
+(format (current-error-port) "*nyacc-version*=~a\n" *nyacc-version*)
+;; list of which rules you want progress reported
+(define need-progress
+ (assoc-ref
+ '(("0.85.3" (1 2 3))
+ ("0.86.0" (1 2 3)))
+ *nyacc-version*))
+
+(define (progress o)
+ (when (and o (getenv "NYACC_DEBUG"))
+ (display " :" (current-error-port))
+ (display o (current-error-port))
+ (display "\n" (current-error-port))))
+
+(define (insert-progress-monitors act-v len-v)
+ (let ((n (vector-length act-v)))
+ (let loop ((ix 0))
+ (when (< ix n)
+ (if (memq ix need-progress)
+ (vector-set
+ act-v ix
+ (lambda args
+ (progress (list-ref args (1- (vector-ref len-v ix))))
+ (apply (vector-ref act-v ix) args))))
+ (loop (1+ ix))))))
+
+(cond-expand
+ (guile
+ (insert-progress-monitors (@@ (nyacc lang c99 parser) c99-act-v)
+ (@@ (nyacc lang c99 parser) c99-len-v)))
+ (mes
+ (insert-progress-monitors c99-act-v c99-len-v)))
+
(define (logf port string . rest)
(apply format (cons* port string rest))
(force-output port)
--
2.18.0

62
gnu/packages/ruby.scm
View file

@ -1211,12 +1211,15 @@ (define-public ruby-shindo
#:phases
(modify-phases %standard-phases
(add-after 'unpack 'fix-tests
(lambda _
(substitute* "Rakefile"
(("system \"shindo") "system \"./bin/shindo")
;; This test doesn't work, so we disable it.
(("fail \"The build_error test should fail") "#"))
#t)))))
(lambda _
(substitute* "tests/tests_helper.rb"
(("-rubygems") ""))
(substitute* "Rakefile"
(("system \"shindo") "system \"./bin/shindo")
;; This test doesn't work, so we disable it.
(("fail \"The build_error test should fail") "#")
((" -rubygems") ""))
#t)))))
(propagated-inputs
`(("ruby-formatador" ,ruby-formatador)))
(synopsis "Simple depth first Ruby testing")
@ -2911,6 +2914,11 @@ (define-public ruby-term-ansicolor
(arguments
`(#:phases
(modify-phases %standard-phases
(add-after 'unpack 'fix-test
(lambda -
(substitute* "tests/hsl_triple_test.rb"
(("0\\\\\\.0%")
"0\\.?0?%"))))
(replace 'build
(lambda _
(invoke "gem" "build" "term-ansicolor.gemspec"))))))
@ -5100,6 +5108,29 @@ (define-public ruby-mail
(home-page "https://github.com/mikel/mail")
(license license:expat)))
(define-public ruby-mathn
(package
(name "ruby-mathn")
(version "0.1.0")
(source
(origin
(method url-fetch)
(uri (rubygems-uri "mathn" version))
(sha256
(base32
"1wn812llln9jzgybz2d7536q39z3gi99i6fi0j1dapcpzvhgrr0p"))))
(build-system ruby-build-system)
(native-inputs
`(("bundler" ,bundler)
("ruby-rake-compiler" ,ruby-rake-compiler)))
(synopsis "Extends math operations for increased precision")
(description
"This gem makes mathematical operations more precise in Ruby and
integrates other mathematical standard libraries. Prior to Ruby 2.5,
@code{mathn} was part of the Ruby standard library.")
(home-page "https://github.com/ruby/mathn")
(license license:bsd-2)))
(define-public ruby-code-statistics
(package
(name "ruby-code-statistics")
@ -5448,8 +5479,16 @@ (define-public ruby-sass-spec
("ruby-diffy" ,ruby-diffy)
("ruby-terminfo" ,ruby-terminfo)))
(arguments
;; No Rakefile
`(#:tests? #f))
`(;; This package contains tests for a sass implementation, and the to
;; avoid any circular dependencies, the tests are not run here
#:tests? #f
#:phases
(modify-phases %standard-phases
(add-after 'unpack 'patch-test
(lambda _
(delete-file "spec/values/colors/alpha_hex-3.5/error")
(substitute* "spec/values/colors/alpha_hex-3.5/expected_output.css"
(("string") "color")))))))
(home-page "https://github.com/sass/sass-spec")
(synopsis "Test suite for Sass")
(description "Sass Spec is a test suite for Sass. Test cases are all in
@ -5459,18 +5498,19 @@ (define-public ruby-sass-spec
(define-public ruby-sass
(package
(name "ruby-sass")
(version "3.5.7")
(version "3.6.0")
(source (origin
(method url-fetch)
(uri (rubygems-uri "sass" version))
(sha256
(base32
"1sy7xsbgpcy90j5ynbq967yplffp74pvph3r8ivn2sv2b44q6i61"))))
"18c6prbw9wl8bqhb2435pd9s0lzarl3g7xf8pmyla28zblvwxmyh"))))
(build-system ruby-build-system)
(propagated-inputs
`(("ruby-sass-listen" ,ruby-sass-listen)))
(native-inputs
`(("ruby-sass-spec" ,ruby-sass-spec)))
`(("ruby-sass-spec" ,ruby-sass-spec)
("ruby-mathn" ,ruby-mathn)))
(home-page "http://sass-lang.com/")
(synopsis "CSS extension language")
(description "Sass is a CSS extension language. It extends CSS with

10
gnu/packages/version-control.scm
View file

@ -146,14 +146,14 @@ (define-public git
(name "git")
;; XXX When updating Git, check if the special 'git-source' input to cgit
;; needs to be updated as well.
(version "2.19.0")
(version "2.19.1")
(source (origin
(method url-fetch)
(uri (string-append "mirror://kernel.org/software/scm/git/git-"
version ".tar.xz"))
(sha256
(base32
"1x1y5z3awabmfg7hk6zb331jxngad4nal4507v96bnf0izsyy3qq"))))
"1dfv43lmdnxz42504jc89sihbv1d4d6kgqcz3c5ji140kfm5cl1l"))))
(build-system gnu-build-system)
(native-inputs
`(("native-perl" ,perl)
@ -166,7 +166,7 @@ (define-public git
version ".tar.xz"))
(sha256
(base32
"1jvxiqvp9q4is3np063ny7rnmk5hm36d34bhi3cgv89njqdh8laf"))))))
"1vn6pi9yvw7rnb9dvi1yjrvv39fqd1m9mwbaffqwizs3gaf91br7"))))))
(inputs
`(("curl" ,curl)
("expat" ,expat)
@ -1119,14 +1119,14 @@ (define-public gitolite
(define-public mercurial
(package
(name "mercurial")
(version "4.4.1")
(version "4.6.2")
(source (origin
(method url-fetch)
(uri (string-append "https://www.mercurial-scm.org/"
"release/mercurial-" version ".tar.gz"))
(sha256
(base32
"0ik2ypzxjr6vpcghxvn39a73gw52629n7vwak04gnbycsq95aalg"))))
"1bv6wgcdx8glihjjfg22khhc52mclsn4kwfqvzbzlg0b42h4xl0w"))))
(build-system python-build-system)
(arguments
`(;; Restrict to Python 2, as Python 3 would require

2
guix/build-system/glib-or-gtk.scm
View file

@ -112,7 +112,7 @@ (define* (glib-or-gtk-build store name inputs
(configure-flags ''())
;; Disable icon theme cache generation.
(make-flags ''("gtk_update_icon_cache=true"))
(out-of-source? #t)
(out-of-source? #f)
(tests? #t)
(test-target "check")
(parallel-build? #t)

11
guix/progress.scm
View file

@ -289,6 +289,8 @@ (define* (progress-reporter/trace file url size
#:optional (log-port (current-output-port)))
"Like 'progress-reporter/file', but instead of returning human-readable
progress reports, write \"build trace\" lines to be processed elsewhere."
(define total 0) ;bytes transferred
(define (report-progress transferred)
(define message
(format #f "@ download-progress ~a ~a ~a ~a~%"
@ -299,13 +301,16 @@ (define message
(progress-reporter
(start (lambda ()
(set! total 0)
(display (format #f "@ download-started ~a ~a ~a~%"
file url (or size "-"))
log-port)))
(report (rate-limited report-progress %progress-interval))
(report (let ((report (rate-limited report-progress %progress-interval)))
(lambda (transferred)
(set! total transferred)
(report transferred))))
(stop (lambda ()
(let ((size (or (and=> (stat file #f) stat:size)
size)))
(let ((size (or size total)))
(report-progress size)
(display (format #f "@ download-succeeded ~a ~a ~a~%"
file url size)