;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2015 Paul van der Walt <paul@denknerd.org>
-;;; Copyright © 2015, 2016, 2018 Ricardo Wurmus <rekado@elephly.net>
+;;; Copyright © 2015, 2016, 2017, 2018 Ricardo Wurmus <rekado@elephly.net>
;;; Copyright © 2015 Federico Beffa <beffa@fbengineering.ch>
;;; Copyright © 2016 Ludovic Courtès <ludo@gnu.org>
;;; Copyright © 2017 rsiddharth <s@ricketyspace.net>
;;; Copyright © 2017 Tobias Geerinckx-Rice <me@tobias.gr>
+;;; Copyright © 2019 Robert Vollmert <rob@vllmrt.net>
+;;; Copyright © 2019 John Soo <jsoo1@asu.edu>
;;;
;;; This file is part of GNU Guix.
;;;
(define-module (gnu packages haskell-web)
#:use-module (gnu packages)
+ #:use-module (gnu packages curl)
#:use-module (gnu packages haskell)
#:use-module (gnu packages haskell-check)
#:use-module (gnu packages haskell-crypto)
- #:use-module (gnu packages tls)
+ #:use-module (gnu packages haskell-xyz)
#:use-module (guix build-system haskell)
#:use-module (guix download)
#:use-module ((guix licenses) #:prefix license:)
(define-public ghc-tagsoup
(package
(name "ghc-tagsoup")
- (version "0.14.3")
+ (version "0.14.6")
(source
(origin
(method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/tagsoup/tagsoup-"
- version
- ".tar.gz"))
+ (uri (string-append "https://hackage.haskell.org/package/tagsoup/"
+ "tagsoup-" version ".tar.gz"))
(sha256
(base32
- "00j2rm2sx0syn16kg2402fz4k8yqfl9knmi367jsiycds1q9zzf9"))))
+ "1yv3dbyb0i1yqm796jgc4jj5kxkla1sxb3b2klw5ks182kdx8kjb"))))
(build-system haskell-build-system)
- (inputs `(("ghc-text" ,ghc-text)))
(native-inputs
`(("ghc-quickcheck" ,ghc-quickcheck)))
(home-page "http://community.haskell.org/~ndm/tagsoup/")
(define-public ghc-cookie
(package
(name "ghc-cookie")
- (version "0.4.3")
+ (version "0.4.4")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "0qpdydhb9gw590ffabqg70x7xvjpg8l74idqnrfbhv5yrr7hryzv"))))
+ "1qy09i0jh2z9i9avy2khf8a8afq4fqgnv0fyrszgfg4kmq2fsi9j"))))
(build-system haskell-build-system)
(inputs
`(("ghc-old-locale" ,ghc-old-locale)
("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)
(description "HTTP cookie parsing and rendering library for Haskell.")
(license license:bsd-3)))
+(define-public ghc-httpd-shed
+ (package
+ (name "ghc-httpd-shed")
+ (version "0.4.0.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/httpd-shed/"
+ "httpd-shed-" version ".tar.gz"))
+ (sha256
+ (base32
+ "064jy1mqhnf1hvq6s04wlhmp916rd522x58djb9qixv13vc8gzxh"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-network-uri" ,ghc-network-uri)
+ ("ghc-network" ,ghc-network)))
+ (home-page "https://hackage.haskell.org/package/httpd-shed")
+ (synopsis "Simple web-server with an interact style API")
+ (description
+ "This web server promotes a function from @code{Request} to @code{IO
+Response} into a local web server. The user can decide how to interpret the
+requests, and the library is intended for implementing Ajax APIs.")
+ (license license:bsd-3)))
+
(define-public ghc-http-types
(package
(name "ghc-http-types")
- (version "0.11")
+ (version "0.12.3")
(source
(origin
(method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/http-types/http-types-"
- version
- ".tar.gz"))
+ (uri (string-append "https://hackage.haskell.org/package/http-types/"
+ "http-types-" version ".tar.gz"))
(sha256
(base32
- "08w30rf1i7kbh2j1iajqmj6yhhmglnb8kjggc8kdni3xahhrgcss"))))
+ "05j00b9nqmwh9zaq9y9x50k81v2pd3j7a71kd91zlnbl8xk4m2jf"))))
(build-system haskell-build-system)
(native-inputs
`(("ghc-doctest" ,ghc-doctest)
("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
("hspec-discover" ,hspec-discover)))
(inputs
- `(("ghc-case-insensitive" ,ghc-case-insensitive)
- ("ghc-blaze-builder" ,ghc-blaze-builder)
- ("ghc-text" ,ghc-text)))
+ `(("ghc-case-insensitive" ,ghc-case-insensitive)))
(home-page "https://github.com/aristidb/http-types")
(synopsis "Generic HTTP types for Haskell")
(description "This package provides generic HTTP types for Haskell (for
(define-public ghc-http
(package
(name "ghc-http")
- (version "4000.3.3")
+ (version "4000.3.12")
(outputs '("out" "doc"))
(source
(origin
(method url-fetch)
- (uri (string-append
- "https://hackage.haskell.org/package/HTTP/HTTP-"
- version
- ".tar.gz"))
+ (uri (string-append "https://hackage.haskell.org/package/HTTP/"
+ "HTTP-" version ".tar.gz"))
(sha256
(base32
- "1wlvvqcxsnd2is3khsla0vd8i9cy12v1pg6d6i13ihcd131a7bdv"))))
+ "140r6qy1ay25piv0z3hih11zhigyi08nkwc32097j43pjff6mzx3"))))
(build-system haskell-build-system)
(native-inputs
- `(("ghc-hunit" ,ghc-hunit)))
+ `(("ghc-httpd-shed" ,ghc-httpd-shed)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
(inputs
- `(("ghc-old-time" ,ghc-old-time)
- ("ghc-parsec" ,ghc-parsec)
- ("ghc-mtl" ,ghc-mtl)
+ `(("ghc-case-insensitive" ,ghc-case-insensitive)
+ ("ghc-conduit" ,ghc-conduit)
+ ("ghc-conduit-extra" ,ghc-conduit-extra)
+ ("ghc-http-types" ,ghc-http-types)
+ ("ghc-old-time" ,ghc-old-time)
+ ("ghc-puremd5" ,ghc-puremd5)
("ghc-network" ,ghc-network)
- ("ghc-network-uri" ,ghc-network-uri)))
+ ("ghc-network-uri" ,ghc-network-uri)
+ ("ghc-split" ,ghc-split)))
(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/HTTP")
(synopsis "Library for client-side HTTP")
(description
(define-public ghc-http-client
(package
(name "ghc-http-client")
- (version "0.5.7.1")
+ (version "0.5.13.1")
(source (origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
version ".tar.gz"))
(sha256
(base32
- "19cvnnfcjj2m3pgs6ivyjs21rw9wx5ynarh6hvb27a76cscai2fy"))))
+ "0szwbgvkkdz56lgi91armkagmb7nnfwbpp4j7cm9zhmffv3ba8g1"))))
(build-system haskell-build-system)
;; Tests require access to the web.
(arguments `(#:tests? #f))
(inputs
- `(("ghc-text" ,ghc-text)
- ("ghc-http-types" ,ghc-http-types)
+ `(("ghc-async" ,ghc-async)
+ ("ghc-base64-bytestring" ,ghc-base64-bytestring)
("ghc-blaze-builder" ,ghc-blaze-builder)
- ("ghc-data-default-class" ,ghc-data-default-class)
- ("ghc-network" ,ghc-network)
- ("ghc-streaming-commons" ,ghc-streaming-commons)
("ghc-case-insensitive" ,ghc-case-insensitive)
- ("ghc-base64-bytestring" ,ghc-base64-bytestring)
("ghc-cookie" ,ghc-cookie)
+ ("ghc-data-default-class" ,ghc-data-default-class)
("ghc-exceptions" ,ghc-exceptions)
- ("ghc-random" ,ghc-random)
+ ("ghc-http-types" ,ghc-http-types)
+ ("ghc-memory" ,ghc-memory)
("ghc-mime-types" ,ghc-mime-types)
- ("ghc-network-uri" ,ghc-network-uri)
("ghc-monad-control" ,ghc-monad-control)
- ("ghc-zlib" ,ghc-zlib)
- ("ghc-async" ,ghc-async)))
+ ("ghc-network" ,ghc-network)
+ ("ghc-network-uri" ,ghc-network-uri)
+ ("ghc-random" ,ghc-random)
+ ("ghc-streaming-commons" ,ghc-streaming-commons)
+ ("ghc-zlib" ,ghc-zlib)))
(native-inputs
`(("ghc-hspec" ,ghc-hspec)))
(home-page "https://github.com/snoyberg/http-client")
(define-public ghc-http-client-tls
(package
(name "ghc-http-client-tls")
- (version "0.3.5.1")
+ (version "0.3.5.3")
(source (origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
version ".tar.gz"))
(sha256
(base32
- "0n4mi8z77qaggfyq17z79cl304nf1f4h6gag60v4wjwghvmj7yn1"))))
+ "0qj3pcpgbsfsc4m52dz35khhl4hf1i0nmcpa445z82d9567vy6j7"))))
(build-system haskell-build-system)
;; Tests require Internet access
(arguments `(#:tests? #f))
(define-public ghc-http-date
(package
(name "ghc-http-date")
- (version "0.0.6.1")
+ (version "0.0.8")
(source
(origin
(method url-fetch)
"http-date-" version ".tar.gz"))
(sha256
(base32
- "0dknh28kyarnzqrsc80ssalxjrq0qbv7ir49247p2grb7rh0dqgj"))))
+ "09slbzqayjnqqz9zybk7slgzvizgplikqgg4b2flzgks91466k0g"))))
(build-system haskell-build-system)
(inputs
`(("ghc-attoparsec" ,ghc-attoparsec)))
("ghc-unordered-containers" ,ghc-unordered-containers)
("ghc-vector" ,ghc-vector)
("ghc-word8" ,ghc-word8)
- ("ghc-psqueues" ,ghc-psqueues)
- ("ghc-stm" ,ghc-stm)))
- (native-inputs
- `(("ghc-glob" ,ghc-glob)
- ("ghc-hspec" ,ghc-hspec)
- ("ghc-doctest" ,ghc-doctest)
- ("hspec-discover" ,hspec-discover)))
+ ("ghc-psqueues" ,ghc-psqueues)))
+ (native-inputs
+ `(("ghc-glob" ,ghc-glob)
+ ("ghc-hspec" ,ghc-hspec)
+ ("ghc-doctest" ,ghc-doctest)
+ ("hspec-discover" ,hspec-discover)))
(home-page "https://github.com/kazu-yamamoto/http2")
(synopsis "HTTP/2 library including frames, priority queues and HPACK")
(description "This package provides a HTTP/2.0 library including frames
(define-public ghc-http-conduit
(package
(name "ghc-http-conduit")
- (version "2.2.4")
+ (version "2.3.2")
(source
(origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"http-conduit-" version "/" "http-conduit-"
version ".tar.gz"))
- (sha256 (base32
- "1wcl3lpg4v1ylq9j77j9fmf6l9qbmp8dmj3a9829q19q6bbgza7l"))))
+ (sha256
+ (base32
+ "1iay4hr0mj8brkxvgkv1liqa8irl9axfc3qhn8qsvcyq4n1l95km"))))
(build-system haskell-build-system)
;; FIXME: `httpLbs TLS` in test-suite `test` fails with
;; ConnectionFailure getProtocolByName: does not exist (no such protocol
("ghc-http-client" ,ghc-http-client)
("ghc-http-client-tls" ,ghc-http-client-tls)
("ghc-monad-control" ,ghc-monad-control)
- ("ghc-mtl" ,ghc-mtl)
- ("ghc-exceptions" ,ghc-exceptions)))
+ ("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-unliftio" ,ghc-unliftio)))
(native-inputs
`(("ghc-hunit" ,ghc-hunit)
("ghc-hspec" ,ghc-hspec)
("ghc-connection" ,ghc-connection)
("ghc-warp-tls" ,ghc-warp-tls)
("ghc-blaze-builder" ,ghc-blaze-builder)
- ("ghc-text" ,ghc-text)
("ghc-conduit" ,ghc-conduit)
("ghc-utf8-string" ,ghc-utf8-string)
("ghc-case-insensitive" ,ghc-case-insensitive)
("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)
(define-public ghc-wai
(package
(name "ghc-wai")
- (version "3.2.1.1")
+ (version "3.2.1.2")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "08afasnirja21vr0bmzcywz4w29x736dmdv7h8nnh1l8bn7sd02x"))))
+ "0jr3b2789wa4m6mxkz12ynz4lfsqmgbrcy0am8karyqr3x3528r8"))))
(build-system haskell-build-system)
(inputs
`(("ghc-bytestring-builder" ,ghc-bytestring-builder)
("ghc-vault" ,ghc-vault)
("ghc-blaze-builder" ,ghc-blaze-builder)
("ghc-network" ,ghc-network)
- ("ghc-text" ,ghc-text)
("ghc-http-types" ,ghc-http-types)))
(native-inputs
`(("hspec-discover" ,hspec-discover)
(define-public ghc-wai-logger
(package
(name "ghc-wai-logger")
- (version "2.3.0")
+ (version "2.3.2")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "1w0b0vinsyqr37wciljkz8g5dcmfi2r210lq194a0wkycly9kkch"))))
+ "0w5ldq4gplc16zzk5ikmbbjw79imaqvw8p6lylaw3hlsbn3zzm4d"))))
(build-system haskell-build-system)
(arguments `(#:tests? #f)) ; FIXME: Tests cannot find libraries exported
; by propagated-inputs.
(define-public ghc-wai-extra
(package
(name "ghc-wai-extra")
- (version "3.0.18")
+ (version "3.0.24.2")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "0r079mqqdv14fp97w0rigdpwk6b88grpjlqsjc5y8bbc0skf5za2"))))
+ "07gcgq59dki5drkjci9ka34xjsy3bqilbsx0lsc4905w9jlyfbci"))))
(build-system haskell-build-system)
(inputs
`(("ghc-ansi-terminal" ,ghc-ansi-terminal)
("ghc-void" ,ghc-void)
("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)
(define-public ghc-wai-conduit
(package
(name "ghc-wai-conduit")
- (version "3.0.0.3")
+ (version "3.0.0.4")
(source
(origin
(method url-fetch)
"wai-conduit-" version ".tar.gz"))
(sha256
(base32
- "1zvsiwjq2mvkb9sjgp3ly9m968m7a2jjzr4id6jpi3mmqykj15z4"))))
+ "07yn41rn2skd5p3wqqa09wa761vj7ibl8l19gh4bi4i8slxhk417"))))
(build-system haskell-build-system)
(inputs
`(("ghc-conduit" ,ghc-conduit)
Haskell's Web Application Interface (WAI).")
(license license:expat)))
+(define-public ghc-bsb-http-chunked
+ (package
+ (name "ghc-bsb-http-chunked")
+ (version "0.0.0.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/"
+ "bsb-http-chunked/bsb-http-chunked-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1x6m6xkrcw6jiaig1bb2wb5pqyw31x8xr9k9pxgq2g3ng44pbjr8"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-bytestring-builder" ,ghc-bytestring-builder)))
+ (home-page "http://github.com/sjakobi/bsb-http-chunked")
+ (synopsis "Chunked HTTP transfer encoding for bytestring builders")
+ (description "This Haskell library contains functions for encoding
+bytestring builders for chunked Hypertext Transfer Protocol (HTTP) 1.1
+transfers.")
+ (license license:bsd-3)))
+
(define-public ghc-warp
(package
(name "ghc-warp")
- (version "3.2.11.1")
+ (version "3.2.27")
(source
(origin
(method url-fetch)
"warp-" version "/" "warp-" version
".tar.gz"))
(sha256
- (base32
- "1zp5cy0bbj508vdvms1n5z80z37m253kwsqc5a83cfc990n6fgw5"))))
+ (base32 "0p2w88q0zd55ms20qylipbi0qzbf324i9r8b9qqxyds5yc1anq76"))))
(build-system haskell-build-system)
- (arguments
- `(#:tests? #f)) ; FIXME: Test-Suite `spec` fails.
(inputs
`(("ghc-async" ,ghc-async)
("ghc-auto-update" ,ghc-auto-update)
- ("ghc-blaze-builder" ,ghc-blaze-builder)
- ("ghc-bytestring-builder" ,ghc-bytestring-builder)
+ ("ghc-bsb-http-chunked" ,ghc-bsb-http-chunked)
("ghc-case-insensitive" ,ghc-case-insensitive)
("ghc-hashable" ,ghc-hashable)
("ghc-http-types" ,ghc-http-types)
("ghc-iproute" ,ghc-iproute)
("ghc-network" ,ghc-network)
- ("ghc-stm" ,ghc-stm)
("ghc-streaming-commons" ,ghc-streaming-commons)
- ("ghc-text" ,ghc-text)
("ghc-unix-compat" ,ghc-unix-compat)
("ghc-vault" ,ghc-vault)
("ghc-wai" ,ghc-wai)
("ghc-word8" ,ghc-word8)
- ("ghc-lifted-base" ,ghc-lifted-base)
("ghc-http-date" ,ghc-http-date)
("ghc-simple-sendfile" ,ghc-simple-sendfile)
("ghc-http2" ,ghc-http2)))
(native-inputs
- `(("ghc-silently" ,ghc-silently)
+ `(("curl" ,curl)
+ ("ghc-silently" ,ghc-silently)
("ghc-hspec" ,ghc-hspec)
- ("ghc-auto-update" ,ghc-auto-update)
("ghc-doctest" ,ghc-doctest)
+ ("ghc-lifted-base" ,ghc-lifted-base)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-hunit" ,ghc-hunit)
- ("ghc-http" ,ghc-http)
+ ("ghc-http-client" ,ghc-http-client)
("hspec-discover" ,hspec-discover)))
(home-page "http://github.com/yesodweb/wai")
(synopsis "HTTP server library for Haskell's WAI")
based WAI (Web Application Interface in Haskell).")
(license license:expat)))
+(define-public ghc-tls-session-manager
+ (package
+ (name "ghc-tls-session-manager")
+ (version "0.0.0.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/"
+ "tls-session-manager/tls-session-manager-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0rvmln545vghsx8zhxp44f0f6pzma8cylarmfhhysy55ipywr1n5"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-auto-update" ,ghc-auto-update)
+ ("ghc-clock" ,ghc-clock)
+ ("ghc-psqueues" ,ghc-psqueues)
+ ("ghc-tls" ,ghc-tls)))
+ (home-page "http://hackage.haskell.org/package/tls-session-manager")
+ (synopsis "In-memory TLS session manager")
+ (description "This Haskell library provides a TLS session manager with
+limitation, automatic pruning, energy saving and replay resistance.")
+ (license license:bsd-3)))
+
(define-public ghc-warp-tls
(package
(name "ghc-warp-tls")
- (version "3.2.3")
+ (version "3.2.4.3")
(source
(origin
(method url-fetch)
"warp-tls-" version ".tar.gz"))
(sha256
(base32
- "14m2bzk5ivz9gdpxlcj6qnh46f2lycm1ybdjnfkj2876zrqwii7m"))))
+ "17gj295fr98l7mkz2gdz6kahdnmja0sql3kvy2zab6q168g53kc4"))))
(build-system haskell-build-system)
(inputs
`(("ghc-cryptonite" ,ghc-cryptonite)
("ghc-network" ,ghc-network)
("ghc-streaming-commons" ,ghc-streaming-commons)
("ghc-tls" ,ghc-tls)
+ ("ghc-tls-session-manager" ,ghc-tls-session-manager)
("ghc-wai" ,ghc-wai)
("ghc-warp" ,ghc-warp)))
(home-page "http://github.com/yesodweb/wai")
(define-public ghc-xss-sanitize
(package
(name "ghc-xss-sanitize")
- (version "0.3.5.7")
+ (version "0.3.6")
(source
(origin
(method url-fetch)
version ".tar.gz"))
(sha256
(base32
- "005cmhaw9xbzkcn42jmhvcvk63bzmg4lml368xwmqdvh7r0mcn4m"))))
+ "1d72s3a6520iwwc1wbn9v2znqgbw6a5wwzb23iq8ny9ccnjyx1dk"))))
(build-system haskell-build-system)
(inputs
`(("ghc-tagsoup" ,ghc-tagsoup)
("ghc-css-text" ,ghc-css-text)
("ghc-network-uri" ,ghc-network-uri)))
(native-inputs
- `(("ghc-text" ,ghc-text)
- ("ghc-attoparsec" ,ghc-attoparsec)
+ `(("ghc-attoparsec" ,ghc-attoparsec)
("ghc-hspec" ,ghc-hspec)
("ghc-hunit" ,ghc-hunit)))
(home-page "https://github.com/yesodweb/haskell-xss-sanitize")
"0ynd9f4hn2sfwqzbsa0y7phmxq8za7jiblpjwx0ry8b372zhgxaz"))))
(build-system haskell-build-system)
(inputs
- `(("ghc-text" ,ghc-text)
- ("ghc-attoparsec" ,ghc-attoparsec)
+ `(("ghc-attoparsec" ,ghc-attoparsec)
("ghc-hspec" ,ghc-hspec)
("ghc-quickcheck" ,ghc-quickcheck)))
(home-page "http://www.yesodweb.com/")
(define-public ghc-mime-types
(package
(name "ghc-mime-types")
- (version "0.1.0.7")
+ (version "0.1.0.8")
(source (origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
version ".tar.gz"))
(sha256
(base32
- "1fg9cqpp5lswk8ajlq4f41n12c2v2naz179l8dsz6zisjqj4l5l3"))))
+ "14ccl2842ya17zyj0bpc7vzklbyqvvydpbypn69h2fmhgji192x8"))))
(build-system haskell-build-system)
- (inputs
- `(("ghc-text" ,ghc-text)))
(home-page "https://github.com/yesodweb/wai")
(synopsis "Basic MIME type handling types and functions")
(description
documents.")
(license license:bsd-3)))
-(define-public ghc-xhtml
- (package
- (name "ghc-xhtml")
- (version "3000.2.1")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://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 license:bsd-3)))
-
(define-public ghc-blaze-html
(package
(name "ghc-blaze-html")
- (version "0.9.0.1")
+ (version "0.9.1.1")
(source
(origin
(method url-fetch)
version ".tar.gz"))
(sha256
(base32
- "0r0acv47nh75bmf7kjyfvhcwz8f02rn9x0a1l80pzgyczfrsmkmf"))))
+ "06xv8fqhclfjj61z74cgggn4lmx1s7diakxg84mnkgfvk11983pa"))))
(build-system haskell-build-system)
- (arguments
- `(#:configure-flags (list "--allow-newer=QuickCheck")))
(inputs
`(("ghc-blaze-builder" ,ghc-blaze-builder)
- ("ghc-text" ,ghc-text)
("ghc-blaze-markup" ,ghc-blaze-markup)))
(native-inputs
`(("ghc-hunit" ,ghc-hunit)
(define-public ghc-aeson
(package
(name "ghc-aeson")
- (version "1.2.4.0")
+ (version "1.3.1.1")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "16zwpd07cmhs58wwsqbhxy3b58gqw8w5nr7nf6lwi4nvznjdn09l"))))
+ "1i1ig840fvsb1lnklcv32zsc0zscirc301lw1mpfxhc6h4pk0gw4"))))
(build-system haskell-build-system)
(arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
(inputs
("ghc-hashable" ,ghc-hashable)
("ghc-scientific" ,ghc-scientific)
("ghc-tagged" ,ghc-tagged)
- ("ghc-text" ,ghc-text)
("ghc-th-abstraction" ,ghc-th-abstraction)
("ghc-time-locale-compat" ,ghc-time-locale-compat)
("ghc-unordered-containers" ,ghc-unordered-containers)
naming: in Greek mythology, Aeson was the father of Jason.)")
(license license:bsd-3)))
-(define-public ghc-aeson-for-pandoc-1
- (package (inherit ghc-aeson)
- (version "1.1.2.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "https://hackage.haskell.org/package/aeson/aeson-"
- version ".tar.gz"))
- (sha256
- (base32
- "1zy5z8pzvh53qkjm0nm3f4rwqfqg3867ck8ncd6mrxpcyvxqqj1p"))))))
-
(define-public ghc-aeson-pretty
(package
(name "ghc-aeson-pretty")
- (version "0.8.5")
+ (version "0.8.7")
(source (origin
(method url-fetch)
(uri (string-append
version ".tar.gz"))
(sha256
(base32
- "1yd98972srlbkn0f2jhrb3f443j9wnq2fnw5gbxjxzmkcinfh5yx"))))
+ "1m977gs0s9gf3lwzlbs5y7bl6ansc5pywmn2qjk09l5bwg2yrhf1"))))
(build-system haskell-build-system)
(inputs
`(("ghc-aeson" ,ghc-aeson)
("ghc-base-compat" ,ghc-base-compat)
("ghc-scientific" ,ghc-scientific)
("ghc-vector" ,ghc-vector)
- ("ghc-text" ,ghc-text)
("ghc-unordered-containers" ,ghc-unordered-containers)
("ghc-attoparsec" ,ghc-attoparsec)
("ghc-cmdargs" ,ghc-cmdargs)))
(synopsis "JSON pretty-printing library and command-line tool")
(description
"This package provides a JSON pretty-printing library compatible with aeson
-as well as a command-line tool to improve readabilty of streams of JSON data.
+as well as a command-line tool to improve readability of streams of JSON data.
The library provides the function @code{encodePretty}. It is a drop-in
replacement for aeson's @code{encode} function, producing JSON-ByteStrings for
human readers. The command-line tool reads JSON from stdin and writes
(build-system haskell-build-system)
(inputs
`(("ghc-base-compat" ,ghc-base-compat)
- ("ghc-text" ,ghc-text)
("ghc-attoparsec" ,ghc-attoparsec)
("ghc-scientific" ,ghc-scientific)
("ghc-vector" ,ghc-vector)
("ghc-aeson" ,ghc-aeson)
- ("ghc-parsec" ,ghc-parsec)
("ghc-haskell-src-meta" ,ghc-haskell-src-meta)))
(native-inputs
`(("ghc-hspec" ,ghc-hspec)
(define-public ghc-multipart
(package
(name "ghc-multipart")
- (version "0.1.2")
+ (version "0.1.3")
(source
(origin
(method url-fetch)
".tar.gz"))
(sha256
(base32
- "0g04jhyw1ib1s7c9bcldyyn4n90qd9x7dmvic4vgq57bgcqgnhz5"))))
+ "1x4n4yyva22dhfr1pg5ki112qvvzb4hyd7bwpm189iq4gcp52q4z"))))
(build-system haskell-build-system)
- (inputs `(("ghc-parsec" ,ghc-parsec)))
+ (inputs
+ `(("ghc-stringsearch" ,ghc-stringsearch)))
(home-page
"http://www.github.com/silkapp/multipart")
(synopsis
"11miwb5vvnn17m92ykz1pzg9x6s8fbpz3mmsyqs2s4b3mn55haz8"))))
(build-system haskell-build-system)
(inputs
- `(("ghc-text" ,ghc-text)
- ("ghc-utf8-string" ,ghc-utf8-string)
+ `(("ghc-utf8-string" ,ghc-utf8-string)
("ghc-network-uri" ,ghc-network-uri)))
(home-page "https://hackage.haskell.org/package/uri-encode")
(synopsis "Unicode aware uri-encoding")
(base32
"0vx3sivcsld76058925hym2j6hm3g71f0qjr7v59f1g2afgx82q8"))))
(build-system haskell-build-system)
- (inputs `(("ghc-text" ,ghc-text)))
(native-inputs `(("ghc-hunit" ,ghc-hunit)
("ghc-hspec" ,ghc-hspec)
("ghc-quickcheck" ,ghc-quickcheck)))
encryption and Skein-MAC-512-256 authentication. Uses Base64 encoding to
avoid any issues with characters.")
(license license:expat)))
+
+(define-public ghc-yesod-core
+ (package
+ (name "ghc-yesod-core")
+ (version "1.6.6")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "yesod-core-" version "/"
+ "yesod-core-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0xahf6m5c7mkl74p0gimy4wb5w4s3lh92wwxmk517fbq666c92kb"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-wai" ,ghc-wai)
+ ("ghc-extra" ,ghc-extra)
+ ("ghc-shakespeare" ,ghc-shakespeare)
+ ("ghc-blaze-builder" ,ghc-blaze-builder)
+ ("ghc-clientsession" ,ghc-clientsession)
+ ("ghc-random" ,ghc-random)
+ ("ghc-cereal" ,ghc-cereal)
+ ("ghc-old-locale" ,ghc-old-locale)
+ ("ghc-unliftio" ,ghc-unliftio)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-monad-control" ,ghc-monad-control)
+ ("ghc-transformers-base" ,ghc-transformers-base)
+ ("ghc-cookie" ,ghc-cookie)
+ ("ghc-http-types" ,ghc-http-types)
+ ("ghc-case-insensitive" ,ghc-case-insensitive)
+ ("ghc-vector" ,ghc-vector)
+ ("ghc-aeson" ,ghc-aeson)
+ ("ghc-fast-logger" ,ghc-fast-logger)
+ ("ghc-wai-logger" ,ghc-wai-logger)
+ ("ghc-monad-logger" ,ghc-monad-logger)
+ ("ghc-conduit" ,ghc-conduit)
+ ("ghc-resourcet" ,ghc-resourcet)
+ ("ghc-rio" ,ghc-rio)
+ ("ghc-lifted-base" ,ghc-lifted-base)
+ ("ghc-blaze-html" ,ghc-blaze-html)
+ ("ghc-blaze-markup" ,ghc-blaze-markup)
+ ("ghc-data-default" ,ghc-data-default)
+ ("ghc-safe" ,ghc-safe)
+ ("ghc-warp" ,ghc-warp)
+ ("ghc-unix-compat" ,ghc-unix-compat)
+ ("ghc-conduit-extra" ,ghc-conduit-extra)
+ ("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-deepseq-generics" ,ghc-deepseq-generics)
+ ("ghc-mwc-random" ,ghc-mwc-random)
+ ("ghc-primitive" ,ghc-primitive)
+ ("ghc-word8" ,ghc-word8)
+ ("ghc-auto-update" ,ghc-auto-update)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-byteable" ,ghc-byteable)))
+ (native-inputs `(("ghc-hspec" ,ghc-hspec)
+ ("ghc-path-pieces" ,ghc-path-pieces)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-hspec-expectations" ,ghc-hspec-expectations)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-network" ,ghc-network)
+ ("ghc-async" ,ghc-async)
+ ("ghc-streaming-commons" ,ghc-streaming-commons)
+ ("ghc-wai-extra" ,ghc-wai-extra)))
+ (home-page "https://www.yesodweb.com")
+ (synopsis "Core package for the Yesod web framework")
+ (description "This Haskell package provides all core functionality, for
+Yesod, on which other packages can be built. It provides dispatch, handler
+functions, widgets, etc.")
+ (license license:expat)))
+
+(define-public ghc-yesod-persistent
+ (package
+ (name "ghc-yesod-persistent")
+ (version "1.6.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "yesod-persistent-" version "/"
+ "yesod-persistent-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1gd59xf7b6v3cald58mzwnfbdzjr49cz60rm4wc5w9pvfx12pgj2"))))
+ (build-system haskell-build-system)
+ (arguments `(#:tests? #f)) ; FIXME: hspec-discover not available in PATH.
+ (inputs `(("ghc-yesod-core" ,ghc-yesod-core)
+ ("ghc-persistent" ,ghc-persistent)
+ ("ghc-persistent-template" ,ghc-persistent-template)
+ ("ghc-blaze-builder" ,ghc-blaze-builder)
+ ("ghc-conduit" ,ghc-conduit)
+ ("ghc-resourcet" ,ghc-resourcet)
+ ("ghc-resource-pool" ,ghc-resource-pool)))
+ (native-inputs `(("ghc-hspec" ,ghc-hspec)
+ ("ghc-wai-extra" ,ghc-wai-extra)
+ ("ghc-yesod-core" ,ghc-yesod-core)
+ ("ghc-persistent-sqlite" ,ghc-persistent-sqlite)))
+ (home-page "http://www.yesodweb.com/")
+ (synopsis "Helpers for using Persistent from Yesod")
+ (description "This Haskell package provides helpers for using Persistent
+from Yesod.")
+ (license license:expat)))
+
+(define-public ghc-yesod-form
+ (package
+ (name "ghc-yesod-form")
+ (version "1.6.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/yesod-form/yesod-form-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1p1x1hffvarplc82ykdk7rm6p5isqgqf78bvxzpfhncxs4kwx057"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-yesod-core" ,ghc-yesod-core)
+ ("ghc-yesod-persistent" ,ghc-yesod-persistent)
+ ("ghc-shakespeare" ,ghc-shakespeare)
+ ("ghc-persistent" ,ghc-persistent)
+ ("ghc-data-default" ,ghc-data-default)
+ ("ghc-xss-sanitize" ,ghc-xss-sanitize)
+ ("ghc-blaze-builder" ,ghc-blaze-builder)
+ ("ghc-email-validate" ,ghc-email-validate)
+ ("ghc-wai" ,ghc-wai)
+ ("ghc-blaze-html" ,ghc-blaze-html)
+ ("ghc-blaze-markup" ,ghc-blaze-markup)
+ ("ghc-attoparsec" ,ghc-attoparsec)
+ ("ghc-byteable" ,ghc-byteable)
+ ("ghc-aeson" ,ghc-aeson)
+ ("ghc-resourcet" ,ghc-resourcet)
+ ("ghc-semigroups" ,ghc-semigroups)
+ ("ghc-network-uri" ,ghc-network-uri)
+ ("ghc-hspec" ,ghc-hspec)))
+ (home-page "https://www.yesodweb.com")
+ (synopsis "Form handling support for Yesod Web Framework")
+ (description "This Haskell package provies a set of basic form inputs such
+as text, number, time, checkbox, select, textarea, etc through the
+@code{Yesod.Form.Fields} module. Also, there is @code{Yesod.Form.Nic} module
+providing richtext field using Nic editor. ")
+ (license license:expat)))
+
+(define-public ghc-yesod
+ (package
+ (name "ghc-yesod")
+ (version "1.6.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/yesod/yesod-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0wx77nbpzdh40p1bm527kimfj48vs9d2avpvvz2w42zi3pz2y94a"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-yesod-core" ,ghc-yesod-core)
+ ("ghc-yesod-persistent" ,ghc-yesod-persistent)
+ ("ghc-yesod-form" ,ghc-yesod-form)
+ ("ghc-monad-control" ,ghc-monad-control)
+ ("ghc-wai" ,ghc-wai)
+ ("ghc-wai-extra" ,ghc-wai-extra)
+ ("ghc-warp" ,ghc-warp)
+ ("ghc-blaze-html" ,ghc-blaze-html)
+ ("ghc-blaze-markup" ,ghc-blaze-markup)
+ ("ghc-aeson" ,ghc-aeson)
+ ("ghc-data-default-class" ,ghc-data-default-class)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-yaml" ,ghc-yaml)
+ ("ghc-monad-logger" ,ghc-monad-logger)
+ ("ghc-fast-logger" ,ghc-fast-logger)
+ ("ghc-conduit" ,ghc-conduit)
+ ("ghc-conduit-extra" ,ghc-conduit-extra)
+ ("ghc-resourcet" ,ghc-resourcet)
+ ("ghc-shakespeare" ,ghc-shakespeare)
+ ("ghc-streaming-commons" ,ghc-streaming-commons)
+ ("ghc-wai-logger" ,ghc-wai-logger)
+ ("ghc-semigroups" ,ghc-semigroups)))
+ (home-page "https://www.yesodweb.com")
+ (synopsis "Framework for creating type-safe, RESTful web applications")
+ (description "The Haskell package package groups together the various
+Yesod related packages into one cohesive whole. This is the version of Yesod,
+whereas most of the core code lives in @code{ghc-yesod-core}.")
+ (license license:expat)))
+
+(define-public ghc-hxt-charproperties
+ (package
+ (name "ghc-hxt-charproperties")
+ (version "9.2.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "hxt-charproperties/hxt-charproperties-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1mml8wglvagqq891rchgli6r8rnkwrqhgsxfl6kb5403pzb18rp4"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/UweSchmidt/hxt")
+ (synopsis "Character properties and classes for XML and Unicode")
+ (description
+ "The modules provided by this package contain predicates for Unicode
+blocks and char properties and character predicates defined by XML. The
+supported Unicode version is 7.0.0")
+ (license license:expat)))
+
+(define-public ghc-hxt-unicode
+ (package
+ (name "ghc-hxt-unicode")
+ (version "9.0.2.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/hxt-unicode/hxt-unicode-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0rj48cy8z4fl3zpg5bpa458kqr83adav6jnqv4i71dclpprj6n3v"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-hxt-charproperties" ,ghc-hxt-charproperties)))
+ (home-page
+ "http://www.fh-wedel.de/~si/HXmlToolbox/index.html https://github.com/UweSchmidt/hxt")
+ (synopsis
+ "Unicode en-/decoding functions for utf8, iso-latin-* and other encodings")
+ (description
+ "This package provides Unicode encoding and decoding functions for
+encodings used in the Haskell XML Toolbox. ISO Latin 1-16, utf8, utf16, ASCII
+are supported. Decoding is done with lazy functions, errors may be detected or
+ignored.")
+ (license license:expat)))
+
+(define-public ghc-hxt-regex-xmlschema
+ (package
+ (name "ghc-hxt-regex-xmlschema")
+ (version "9.2.0.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "hxt-regex-xmlschema/hxt-regex-xmlschema-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1c4jr0439f5yc05h7iz53fa47g6l2wrvqp6gvwf01mlqajk3nx7l"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-hxt-charproperties" ,ghc-hxt-charproperties)
+ ("ghc-hunit" ,ghc-hunit)))
+ (home-page "http://www.haskell.org/haskellwiki/Regular_expressions_for_XML_Schema")
+ (synopsis "Regular expression library for W3C XML Schema regular expressions")
+ (description
+ "This library supports full W3C XML Schema regular expressions inclusive
+all Unicode character sets and blocks. It is implemented by the technique of
+derivations of regular expressions.")
+ (license license:expat)))
+
+(define-public ghc-hxt
+ (package
+ (name "ghc-hxt")
+ (version "9.3.1.16")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/hxt/hxt-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1qq3ykgn355rx242xjcbqqksgvwr6k2fdj5phw4iv28qqxff6m8d"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-hxt-charproperties" ,ghc-hxt-charproperties)
+ ("ghc-hxt-unicode" ,ghc-hxt-unicode)
+ ("ghc-hxt-regex-xmlschema" ,ghc-hxt-regex-xmlschema)
+ ("ghc-network-uri" ,ghc-network-uri)))
+ (home-page "https://github.com/UweSchmidt/hxt")
+ (synopsis "Collection of tools for processing XML with Haskell")
+ (description
+ "The Haskell XML Toolbox bases on the ideas of HaXml and HXML, but
+introduces a more general approach for processing XML with Haskell.")
+ (license license:expat)))
+
+(define-public ghc-http-common
+ (package
+ (name "ghc-http-common")
+ (version "0.8.2.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "http-common/http-common-" version ".tar.gz"))
+ (sha256
+ (base32
+ "14s5a178sb2vm5k00rs21760mds5dz2gs10k9iyn22h01mxyf599"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-base64-bytestring" ,ghc-base64-bytestring)
+ ("ghc-blaze-builder" ,ghc-blaze-builder)
+ ("ghc-case-insensitive" ,ghc-case-insensitive)
+ ("ghc-network" ,ghc-network)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)))
+ (home-page "https://github.com/afcowie/http-streams/")
+ (synopsis "Common types for HTTP clients and servers")
+ (description "Base types used by a variety of HTTP clients and
+servers. See http-streams @code{Network.Http.Client} or pipes-http
+@code{Pipes.Http.Client} for full documentation. You can import
+@code{Network.Http.Types} if you like, but both http-streams and
+pipes-http re-export this package's types and functions.")
+ (license license:bsd-3)))
+
+(define-public ghc-http-streams
+ (package
+ (name "ghc-http-streams")
+ (version "0.8.6.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "http-streams/http-streams-" version ".tar.gz"))
+ (sha256
+ (base32
+ "18vxd35n7s3z4gjvad94bknc8z1w9d7ccgphnhsxlz5cackizmxq"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-attoparsec" ,ghc-attoparsec)
+ ("ghc-base64-bytestring" ,ghc-base64-bytestring)
+ ("ghc-blaze-builder" ,ghc-blaze-builder)
+ ("ghc-case-insensitive" ,ghc-case-insensitive)
+ ("ghc-io-streams" ,ghc-io-streams)
+ ("ghc-hsopenssl" ,ghc-hsopenssl)
+ ("ghc-openssl-streams" ,ghc-openssl-streams)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-aeson" ,ghc-aeson)
+ ("ghc-http-common" ,ghc-http-common)
+ ("ghc-network-uri" ,ghc-network-uri)
+ ("ghc-network" ,ghc-network)))
+ (arguments
+ `(#:tests? #f)) ; tests rely on an outdated version of snap-server
+ (home-page "https://github.com/afcowie/http-streams/")
+ (synopsis "HTTP client using io-streams")
+ (description "An HTTP client using the Snap Framework's io-streams
+library to handle the streaming IO. The API is optimized for ease of
+use for the rather common case of code needing to query web services and
+deal with the result.")
+ (license license:bsd-3)))
+
+(define-public ghc-snap-core
+ (package
+ (name "ghc-snap-core")
+ (version "1.0.3.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "snap-core/snap-core-" version ".tar.gz"))
+ (sha256
+ (base32
+ "136q7l4hd5yn5hb507q1ziqx124ma1lkzh5dx0n150p8dx3rhhsc"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-old-locale" ,ghc-old-locale)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-attoparsec" ,ghc-attoparsec)
+ ("ghc-bytestring-builder" ,ghc-bytestring-builder)
+ ("ghc-case-insensitive" ,ghc-case-insensitive)
+ ("ghc-lifted-base" ,ghc-lifted-base)
+ ("ghc-io-streams" ,ghc-io-streams)
+ ("ghc-hashable" ,ghc-hashable)
+ ("ghc-monad-control" ,ghc-monad-control)
+ ("ghc-random" ,ghc-random)
+ ("ghc-readable" ,ghc-readable)
+ ("ghc-regex-posix" ,ghc-regex-posix)
+ ("ghc-transformers-base" ,ghc-transformers-base)
+ ("ghc-unix-compat" ,ghc-unix-compat)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-vector" ,ghc-vector)
+ ("ghc-network-uri" ,ghc-network-uri)
+ ("ghc-network" ,ghc-network)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-parallel" ,ghc-parallel)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+ ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
+ ("ghc-zlib" ,ghc-zlib)))
+ (arguments
+ `(#:cabal-revision
+ ("3" "0wlhn33r7c9g7j23y006ddq9d87lkmianvvfrbl8jd8mvjvj2gfa")))
+ (home-page "http://snapframework.com/")
+ (synopsis "Haskell Web Framework (core interfaces and types)")
+ (description "Snap is a simple and fast web development framework
+and server written in Haskell. For more information, you can visit the
+Snap project website at @uref{http://snapframework.com/}. This library
+contains the core definitions and types for the Snap framework.")
+ (license license:bsd-3)))
+
+(define-public ghc-snap-server
+ (package
+ (name "ghc-snap-server")
+ (version "1.1.0.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "snap-server/snap-server-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0vvw9n8xs272qdlrf3dxhnva41zh3awi7pf022rrjj75lj8a77i4"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-attoparsec" ,ghc-attoparsec)
+ ("ghc-blaze-builder" ,ghc-blaze-builder)
+ ("ghc-bytestring-builder" ,ghc-bytestring-builder)
+ ("ghc-case-insensitive" ,ghc-case-insensitive)
+ ("ghc-clock" ,ghc-clock)
+ ("ghc-io-streams" ,ghc-io-streams)
+ ("ghc-io-streams-haproxy" ,ghc-io-streams-haproxy)
+ ("ghc-lifted-base" ,ghc-lifted-base)
+ ("ghc-network" ,ghc-network)
+ ("ghc-old-locale" ,ghc-old-locale)
+ ("ghc-snap-core" ,ghc-snap-core)
+ ("ghc-unix-compat" ,ghc-unix-compat)
+ ("ghc-vector" ,ghc-vector)))
+ (native-inputs
+ `(("ghc-base16-bytestring" ,ghc-base16-bytestring)
+ ("ghc-monad-control" ,ghc-monad-control)
+ ("ghc-random" ,ghc-random)
+ ("ghc-threads" ,ghc-threads)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-http-streams" ,ghc-http-streams)
+ ("ghc-http-common" ,ghc-http-common)
+ ("ghc-parallel" ,ghc-parallel)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+ ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+ (arguments
+ `(#:cabal-revision
+ ("3" "0a9d3nqb5rvgm25nak68lp6yj9m6cwhbgdbg5l7ib5i2czcg7yjh")))
+ (home-page "http://snapframework.com/")
+ (synopsis "Web server for the Snap Framework")
+ (description "Snap is a simple and fast web development framework
+and server written in Haskell. For more information, you can visit the
+Snap project website at @uref{http://snapframework.com/}. The Snap HTTP
+server is a high performance web server library written in Haskell.
+Together with the snap-core library upon which it depends, it provides a
+clean and efficient Haskell programming interface to the HTTP
+protocol.")
+ (license license:bsd-3)))
+
+(define-public ghc-js-jquery
+ (package
+ (name "ghc-js-jquery")
+ (version "3.3.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri
+ (string-append
+ "https://hackage.haskell.org/package/js-jquery/js-jquery-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "16q68jzbs7kp07dnq8cprdcc8fd41rim38039vg0w4x11lgniq70"))))
+ (build-system haskell-build-system)
+ (arguments `(#:tests? #f)) ; tests do network IO
+ (home-page "https://github.com/ndmitchell/js-jquery")
+ (synopsis "Obtain minified jQuery code")
+ (description "This package bundles the minified
+@url{http://jquery.com/, jQuery} code into a Haskell package, so it can
+be depended upon by Cabal packages. The first three components of the
+version number match the upstream jQuery version. The package is
+designed to meet the redistribution requirements of downstream
+users (e.g. Debian).")
+ (license license:expat)))
+
+(define-public ghc-js-flot
+ (package
+ (name "ghc-js-flot")
+ (version "0.8.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri
+ (string-append
+ "https://hackage.haskell.org/package/js-flot/js-flot-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0yjyzqh3qzhy5h3nql1fckw0gcfb0f4wj9pm85nafpfqp2kg58hv"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-http" ,ghc-http)))
+ (home-page "https://github.com/ndmitchell/js-flot")
+ (synopsis "Obtain minified flot code")
+ (description "This package bundles the minified
+@url{http://www.flotcharts.org/, Flot} code (a jQuery plotting library)
+into a Haskell package, so it can be depended upon by Cabal packages.
+The first three components of the version number match the upstream flot
+version. The package is designed to meet the redistribution
+requirements of downstream users (e.g. Debian).")
+ (license license:expat)))