Commit | Line | Data |
---|---|---|
804744b3 | 1 | ;;; GNU Guix --- Functional package management for GNU |
62e42dfa | 2 | ;;; Copyright © 2015 Siniša Biđin <sinisa@bidin.eu> |
804744b3 | 3 | ;;; Copyright © 2015, 2017, 2018 Ricardo Wurmus <rekado@elephly.net> |
3c986a7d | 4 | ;;; Copyright © 2016, 2017, 2018 Nikita <nikita@n0.is> |
62e42dfa RV |
5 | ;;; Copyright © 2017 Danny Milosavljevic <dannym@scratchpost.org> |
6 | ;;; Copyright © 2017, 2018 Alex Vong <alexvong1995@gmail.com> | |
804744b3 LC |
7 | ;;; Copyright © 2017, 2018, 2019 Tobias Geerinckx-Rice <me@tobias.gr> |
8 | ;;; Copyright © 2018 Timothy Sample <samplet@ngyro.com> | |
9 | ;;; Copyright © 2018 Arun Isaac <arunisaac@systemreboot.net> | |
10 | ;;; Copyright © 2016, 2017 Leo Famulari <leo@famulari.name> | |
bfccae4e | 11 | ;;; Copyright © 2015 Paul van der Walt <paul@denknerd.org> |
64fc2293 | 12 | ;;; Copyright © 2019, 2020 Kyle Meyer <kyle@kyleam.com> |
6ec2450f | 13 | ;;; Copyright © 2015 John Soo <jsoo1@asu.edu> |
5de2246f | 14 | ;;; Copyright © 2019, 2020 Efraim Flashner <efraim@flashner.co.il> |
838c8204 | 15 | ;;; Copyright © 2019, 2020 Alex Griffin <a@ajgrf.com> |
eea58169 | 16 | ;;; Copyright © 2020 Alexandru-Sergiu Marton <brown121407@member.fsf.org> |
79617a01 | 17 | ;;; Copyright © 2020 Brian Leung <bkleung89@gmail.com> |
804744b3 LC |
18 | ;;; |
19 | ;;; This file is part of GNU Guix. | |
20 | ;;; | |
21 | ;;; GNU Guix is free software; you can redistribute it and/or modify it | |
22 | ;;; under the terms of the GNU General Public License as published by | |
23 | ;;; the Free Software Foundation; either version 3 of the License, or (at | |
24 | ;;; your option) any later version. | |
25 | ;;; | |
26 | ;;; GNU Guix is distributed in the hope that it will be useful, but | |
27 | ;;; WITHOUT ANY WARRANTY; without even the implied warranty of | |
28 | ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
29 | ;;; GNU General Public License for more details. | |
30 | ;;; | |
31 | ;;; You should have received a copy of the GNU General Public License | |
32 | ;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>. | |
33 | ||
34 | (define-module (gnu packages haskell-apps) | |
35 | #:use-module (guix download) | |
62e42dfa | 36 | #:use-module (guix git-download) |
804744b3 LC |
37 | #:use-module (guix packages) |
38 | #:use-module ((guix licenses) #:prefix license:) | |
39 | #:use-module (guix build-system haskell) | |
40 | #:use-module (gnu packages base) | |
41 | #:use-module (gnu packages curl) | |
bfccae4e | 42 | #:use-module (gnu packages gl) |
804744b3 LC |
43 | #:use-module (gnu packages haskell) |
44 | #:use-module (gnu packages haskell-check) | |
45 | #:use-module (gnu packages haskell-crypto) | |
46 | #:use-module (gnu packages haskell-web) | |
dddbc90c | 47 | #:use-module (gnu packages haskell-xyz) |
804744b3 LC |
48 | #:use-module (gnu packages ncurses) |
49 | #:use-module (gnu packages perl) | |
50 | #:use-module (gnu packages pkg-config) | |
51 | #:use-module (gnu packages rsync) | |
52 | #:use-module (gnu packages version-control)) | |
53 | ||
79617a01 BL |
54 | (define-public apply-refact |
55 | (package | |
56 | (name "apply-refact") | |
57 | (version "0.6.0.0") | |
58 | (source | |
59 | (origin | |
60 | (method url-fetch) | |
61 | (uri (string-append | |
62 | "https://hackage.haskell.org/package/apply-refact/apply-refact-" | |
63 | version ".tar.gz")) | |
64 | (sha256 | |
65 | (base32 | |
66 | "0p2mqgjcqr1zcmk8zgr0yq7g8z1agsa6l493lkj6g3ya9lyhxgig")))) | |
67 | (build-system haskell-build-system) | |
68 | (inputs | |
69 | `(("ghc-refact" ,ghc-refact) | |
70 | ("ghc-exactprint" ,ghc-exactprint) | |
71 | ("ghc-syb" ,ghc-syb) | |
72 | ("ghc-temporary" ,ghc-temporary) | |
73 | ("ghc-filemanip" ,ghc-filemanip) | |
74 | ("ghc-unix-compat" ,ghc-unix-compat) | |
75 | ("ghc-optparse-applicative" | |
76 | ,ghc-optparse-applicative))) | |
77 | (native-inputs | |
78 | `(("ghc-tasty" ,ghc-tasty) | |
79 | ("ghc-tasty-golden" ,ghc-tasty-golden) | |
80 | ("ghc-tasty-expected-failure" | |
81 | ,ghc-tasty-expected-failure) | |
82 | ("ghc-silently" ,ghc-silently))) | |
83 | (home-page "https://hackage.haskell.org/package/apply-refact") | |
84 | (synopsis "Perform refactorings specified by the refact library") | |
85 | (description | |
86 | "This package lets you perform refactorings specified by the refact | |
87 | library. It is primarily used with HLint's @code{--refactor} flag.") | |
88 | (license license:bsd-3))) | |
89 | ||
841f1954 TS |
90 | ;; In Stackage LTS 14, this package is at 2.4.1.0. However, that |
91 | ;; version requires version 2.4.1.0 of the 'Cabal' package, which is | |
92 | ;; provided by GHC 8.6.5 at version 2.4.0.1. Hence, we use an older | |
93 | ;; version to match the compiler's library. | |
62e42dfa RV |
94 | (define-public cabal-install |
95 | (package | |
96 | (name "cabal-install") | |
841f1954 | 97 | (version "2.4.0.0") |
62e42dfa RV |
98 | (source |
99 | (origin | |
100 | (method url-fetch) | |
101 | (uri (string-append | |
102 | "https://hackage.haskell.org/package/cabal-install/cabal-install-" | |
103 | version | |
104 | ".tar.gz")) | |
105 | (sha256 | |
841f1954 | 106 | (base32 "1xmyl0x8wqfrnray6ky5wy0g0samv4264fbdlzxhqsvk9dbfja8k")))) |
62e42dfa | 107 | (build-system haskell-build-system) |
841f1954 TS |
108 | (arguments |
109 | `(#:cabal-revision | |
110 | ("2" "1xil5pim6j1ckqj61zz6l7xpfxxr3rkw2hvpws2f7pr9shk645dl") | |
111 | #:phases | |
112 | (modify-phases %standard-phases | |
113 | (add-before 'configure 'update-constraints | |
114 | (lambda _ | |
115 | (substitute* "cabal-install.cabal" | |
116 | (("zip-archive >= 0\\.3\\.2\\.5 && < 0\\.4,") | |
117 | "zip-archive >= 0.3.2.5 && <= 0.4.1,")) | |
118 | #t))))) | |
62e42dfa RV |
119 | (inputs |
120 | `(("ghc-async" ,ghc-async) | |
121 | ("ghc-base16-bytestring" ,ghc-base16-bytestring) | |
122 | ("ghc-cryptohash-sha256" ,ghc-cryptohash-sha256) | |
123 | ("ghc-echo" ,ghc-echo) | |
124 | ("ghc-edit-distance" ,ghc-edit-distance) | |
125 | ("ghc-hackage-security" ,ghc-hackage-security) | |
126 | ("ghc-hashable" ,ghc-hashable) | |
127 | ("ghc-http" ,ghc-http) | |
128 | ("ghc-network-uri" ,ghc-network-uri) | |
129 | ("ghc-network" ,ghc-network) | |
130 | ("ghc-random" ,ghc-random) | |
131 | ("ghc-resolv" ,ghc-resolv) | |
132 | ("ghc-tar" ,ghc-tar) | |
841f1954 | 133 | ("ghc-zip-archive" ,ghc-zip-archive) |
62e42dfa RV |
134 | ("ghc-zlib" ,ghc-zlib))) |
135 | (home-page "https://www.haskell.org/cabal/") | |
136 | (synopsis "Command-line interface for Cabal and Hackage") | |
137 | (description | |
138 | "The cabal command-line program simplifies the process of managing | |
139 | Haskell software by automating the fetching, configuration, compilation and | |
140 | installation of Haskell libraries and programs.") | |
141 | (license license:bsd-3))) | |
142 | ||
143 | (define-public corrode | |
144 | (let ((commit "b6699fb2fa552a07c6091276285a44133e5c9789")) | |
145 | (package | |
146 | (name "corrode") | |
147 | (version (string-append "0.0.1-" (string-take commit 7))) | |
148 | (source | |
149 | (origin | |
150 | (method git-fetch) | |
151 | (uri (git-reference | |
b0e7b699 | 152 | (url "https://github.com/jameysharp/corrode") |
62e42dfa | 153 | (commit "b6699fb2fa552a07c6091276285a44133e5c9789"))) |
bb90beb5 | 154 | (file-name (git-file-name name version)) |
62e42dfa RV |
155 | (sha256 |
156 | (base32 "02v0yyj6sk4gpg2222wzsdqjxn8w66scbnf6b20x0kbmc69qcz4r")))) | |
157 | (build-system haskell-build-system) | |
158 | (inputs | |
159 | `(("ghc-language-c" ,ghc-language-c) | |
160 | ("ghc-markdown-unlit" ,ghc-markdown-unlit))) | |
161 | (home-page "https://github.com/jameysharp/corrode") | |
162 | (synopsis "Automatic semantics-preserving translation from C to Rust") | |
163 | (description | |
164 | "This program reads a C source file and prints an equivalent module in | |
165 | Rust syntax. It is intended to be useful for two different purposes: | |
166 | ||
167 | @enumerate | |
168 | @item Partial automation for migrating legacy code that was implemented in C. | |
169 | @item A new, complementary approach to static analysis for C programs. | |
170 | @end enumerate\n") | |
171 | (license license:gpl2+)))) | |
172 | ||
173 | (define-public cpphs | |
174 | (package | |
175 | (name "cpphs") | |
176 | (version "1.20.8") | |
177 | (source | |
178 | (origin | |
179 | (method url-fetch) | |
180 | (uri (string-append | |
181 | "https://hackage.haskell.org/package/" name "/" | |
182 | name "-" version ".tar.gz")) | |
183 | (sha256 | |
184 | (base32 | |
185 | "1bh524asqhk9v1s0wvipl0hgn7l63iy3js867yv0z3h5v2kn8vg5")))) | |
186 | (build-system haskell-build-system) | |
187 | (inputs | |
188 | `(("ghc-polyparse" ,ghc-polyparse) | |
189 | ("ghc-old-locale" ,ghc-old-locale) | |
190 | ("ghc-old-time" ,ghc-old-time))) | |
191 | (home-page "http://projects.haskell.org/cpphs/") | |
192 | (synopsis "Liberalised re-implementation of cpp, the C pre-processor") | |
193 | (description "Cpphs is a re-implementation of the C pre-processor that is | |
194 | both more compatible with Haskell, and itself written in Haskell so that it | |
195 | can be distributed with compilers. This version of the C pre-processor is | |
196 | pretty-much feature-complete and compatible with traditional (K&R) | |
197 | pre-processors. Additional features include: a plain-text mode; an option to | |
198 | unlit literate code files; and an option to turn off macro-expansion.") | |
199 | (license (list license:lgpl2.1+ license:gpl3+)))) | |
200 | ||
d93fc75e | 201 | ;; Darcs has no https support: |
804744b3 LC |
202 | ;; http://darcs.net/manual/Configuring_darcs.html#SECTION00440070000000000000 |
203 | ;; and results of search engines will show that if the protocol is http, https | |
204 | ;; is never mentioned. | |
205 | (define-public darcs | |
206 | (package | |
207 | (name "darcs") | |
208 | (version "2.14.2") | |
209 | (source | |
210 | (origin | |
211 | (method url-fetch) | |
212 | (uri (string-append "https://hackage.haskell.org/package/darcs/" | |
213 | "darcs-" version ".tar.gz")) | |
214 | (sha256 | |
215 | (base32 | |
216 | "0zm2486gyhiga1amclbg92cd09bvki6vgh0ll75hv5kl72j61lb5")) | |
217 | (modules '((guix build utils))) | |
218 | ;; Remove time-dependent code for reproducibility. | |
219 | (snippet | |
220 | '(begin | |
221 | (substitute* "darcs/darcs.hs" | |
222 | (("__DATE__") "\"1970-01-01\"") | |
223 | (("__TIME__") "\"00:00:00\"")) | |
224 | #t)))) | |
225 | (build-system haskell-build-system) | |
226 | (arguments | |
0710797d TS |
227 | `(#:cabal-revision |
228 | ("1" "0xl7j5cm704pbl2ms0dkydh7jvrz0ym76d725ifpg4h902m1zkhg") | |
229 | #:configure-flags '("-fpkgconfig" "-fcurl" "-flibiconv" "-fthreaded" | |
804744b3 LC |
230 | "-fnetwork-uri" "-fhttp" "--flag=executable" |
231 | "--flag=library") | |
232 | #:phases | |
233 | (modify-phases %standard-phases | |
234 | (add-after 'patch-source-shebangs 'patch-sh | |
235 | (lambda _ | |
236 | (substitute* "tests/issue538.sh" | |
237 | (("/bin/sh") (which "sh"))) | |
0710797d TS |
238 | #t)) |
239 | (add-before 'configure 'update-constraints | |
240 | (lambda _ | |
241 | (substitute* "darcs.cabal" | |
242 | (("QuickCheck >= 2\\.8\\.2 && < 2\\.13,") | |
243 | "QuickCheck >= 2.8.2 && < 2.14,")) | |
804744b3 LC |
244 | #t))))) |
245 | (inputs | |
246 | `(("ghc-cmdargs" ,ghc-cmdargs) | |
247 | ("ghc-split" ,ghc-split) | |
248 | ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2) | |
249 | ("ghc-test-framework-hunit" ,ghc-test-framework-hunit) | |
250 | ("ghc-test-framework" ,ghc-test-framework) | |
251 | ("ghc-quickcheck" ,ghc-quickcheck) | |
252 | ("ghc-findbin" ,ghc-findbin) | |
253 | ("ghc-hunit" ,ghc-hunit) | |
254 | ("ghc-async" ,ghc-async) | |
255 | ("ghc-attoparsec" ,ghc-attoparsec) | |
256 | ("ghc-base16-bytestring" ,ghc-base16-bytestring) | |
257 | ("ghc-bytestring-builder" ,ghc-bytestring-builder) | |
258 | ("ghc-cryptohash" ,ghc-cryptohash) | |
259 | ("ghc-data-ordlist" ,ghc-data-ordlist) | |
260 | ("ghc-fgl" ,ghc-fgl) | |
261 | ("ghc-system-filepath" ,ghc-system-filepath) | |
262 | ("ghc-graphviz" ,ghc-graphviz) | |
263 | ("ghc-hashable" ,ghc-hashable) | |
264 | ("ghc-html" ,ghc-html) | |
265 | ("ghc-mmap" ,ghc-mmap) | |
266 | ("ghc-old-time" ,ghc-old-time) | |
804744b3 LC |
267 | ("ghc-random" ,ghc-random) |
268 | ("ghc-regex-applicative" ,ghc-regex-applicative) | |
269 | ("ghc-regex-compat-tdfa" ,ghc-regex-compat-tdfa) | |
270 | ("ghc-sandi" ,ghc-sandi) | |
271 | ("ghc-shelly" ,ghc-shelly) | |
272 | ("ghc-tar" ,ghc-tar) | |
273 | ("ghc-transformers-compat" ,ghc-transformers-compat) | |
274 | ("ghc-unix-compat" ,ghc-unix-compat) | |
275 | ("ghc-utf8-string" ,ghc-utf8-string) | |
276 | ("ghc-vector" ,ghc-vector) | |
277 | ("ghc-zip-archive" ,ghc-zip-archive) | |
278 | ("ghc-zlib" ,ghc-zlib) | |
279 | ("ghc-http" ,ghc-http) | |
280 | ("curl" ,curl) | |
281 | ("ghc" ,ghc) | |
282 | ("ncurses" ,ncurses) | |
283 | ("perl" ,perl) | |
284 | ("libiconv" ,libiconv) | |
285 | ("ghc-network" ,ghc-network) | |
286 | ("ghc-network-uri" ,ghc-network-uri))) | |
287 | (native-inputs | |
288 | `(("pkg-config" ,pkg-config))) | |
289 | (home-page "http://darcs.net") | |
290 | (synopsis "Distributed Revision Control System") | |
291 | (description | |
292 | "Darcs is a revision control system. It is: | |
293 | ||
294 | @enumerate | |
295 | @item Distributed: Every user has access to the full command set, removing boundaries | |
296 | between server and client or committer and non-committers. | |
297 | @item Interactive: Darcs is easy to learn and efficient to use because it asks you | |
298 | questions in response to simple commands, giving you choices in your work flow. | |
299 | You can choose to record one change in a file, while ignoring another. As you update | |
300 | from upstream, you can review each patch name, even the full diff for interesting | |
301 | patches. | |
302 | @item Smart: Originally developed by physicist David Roundy, darcs is based on a | |
303 | unique algebra of patches called @url{http://darcs.net/Theory,Patchtheory}. | |
304 | @end enumerate") | |
305 | (license license:gpl2))) | |
306 | ||
eea58169 ASM |
307 | (define-public ghcid |
308 | (package | |
309 | (name "ghcid") | |
10601409 | 310 | (version "0.8.7") |
eea58169 ASM |
311 | (source |
312 | (origin | |
313 | (method url-fetch) | |
314 | (uri (string-append "https://hackage.haskell.org/package/ghcid/" | |
315 | "ghcid-" version ".tar.gz")) | |
316 | (sha256 | |
10601409 | 317 | (base32 "0yqc1pkfajnr56gnh43sbj50r7c3r41b2jfz07ivgl6phi4frjbq")))) |
eea58169 ASM |
318 | (build-system haskell-build-system) |
319 | (inputs | |
320 | `(("ghc-extra" ,ghc-extra) | |
321 | ("ghc-ansi-terminal" ,ghc-ansi-terminal) | |
322 | ("ghc-cmdargs" ,ghc-cmdargs) | |
323 | ("ghc-fsnotify" ,ghc-fsnotify) | |
324 | ("ghc-terminal-size" ,ghc-terminal-size))) | |
325 | (native-inputs | |
326 | `(("ghc-tasty" ,ghc-tasty) | |
327 | ("ghc-tasty-hunit" ,ghc-tasty-hunit))) | |
10601409 | 328 | (home-page "https://github.com/ndmitchell/ghcid#readme") |
eea58169 ASM |
329 | (synopsis "GHCi based bare bones IDE") |
330 | (description | |
331 | "Either \"GHCi as a daemon\" or \"GHC + a bit of an IDE\". A very simple Haskell | |
332 | development tool which shows you the errors in your project and updates them whenever | |
333 | you save. Run @code{ghcid --topmost --command=ghci}, where @code{--topmost} makes the | |
334 | window on top of all others (Windows only) and @code{--command} is the command to start | |
335 | GHCi on your project (defaults to @code{ghci} if you have a @file{.ghci} file, or else | |
336 | to @code{cabal repl}).") | |
337 | (license license:bsd-3))) | |
338 | ||
804744b3 LC |
339 | (define-public git-annex |
340 | (package | |
341 | (name "git-annex") | |
1bf912e5 | 342 | (version "8.20201007") |
804744b3 LC |
343 | (source |
344 | (origin | |
345 | (method url-fetch) | |
346 | (uri (string-append "https://hackage.haskell.org/package/" | |
347 | "git-annex/git-annex-" version ".tar.gz")) | |
348 | (sha256 | |
1bf912e5 | 349 | (base32 "0v11yc4kkxnzvwqry277dpjwlavinrjiagfw0ayhrfwd703j1y8a")))) |
804744b3 LC |
350 | (build-system haskell-build-system) |
351 | (arguments | |
352 | `(#:configure-flags | |
8c944c4c | 353 | '("--flags=-Android -Assistant -Pairing -Webapp") |
804744b3 LC |
354 | #:phases |
355 | (modify-phases %standard-phases | |
3d45d8f1 | 356 | (add-before 'configure 'patch-shell-for-tests |
804744b3 | 357 | (lambda _ |
3d45d8f1 KM |
358 | ;; Shell.hs defines "/bin/sh" that is used in Git hooks. We |
359 | ;; shouldn't patch hooks with Guix's current bash because the | |
360 | ;; hooks can exist after that bash is garbage collected, but | |
361 | ;; let's temporarily patch it so that we can run the tests. | |
362 | (copy-file "Utility/Shell.hs" "/tmp/Shell.hs") | |
804744b3 LC |
363 | (substitute* "Utility/Shell.hs" |
364 | (("/bin/sh") (which "sh"))) | |
365 | #t)) | |
366 | (add-before 'configure 'factor-setup | |
367 | (lambda _ | |
368 | ;; Factor out necessary build logic from the provided | |
369 | ;; `Setup.hs' script. The script as-is does not work because | |
370 | ;; it cannot find its dependencies, and there is no obvious way | |
64fc2293 | 371 | ;; to tell it where to look. |
804744b3 LC |
372 | (call-with-output-file "PreConf.hs" |
373 | (lambda (out) | |
374 | (format out "import qualified Build.Configure as Configure~%") | |
375 | (format out "main = Configure.run Configure.tests~%"))) | |
376 | (call-with-output-file "Setup.hs" | |
377 | (lambda (out) | |
378 | (format out "import Distribution.Simple~%") | |
379 | (format out "main = defaultMain~%"))) | |
380 | #t)) | |
381 | (add-before 'configure 'pre-configure | |
382 | (lambda _ | |
383 | (invoke "runhaskell" "PreConf.hs") | |
384 | #t)) | |
64fc2293 KM |
385 | (add-after 'build 'build-manpages |
386 | (lambda _ | |
387 | ;; The Setup.hs rewrite above removed custom code for building | |
388 | ;; the man pages. In addition to that code, git-annex's source | |
389 | ;; tree has a file that's not included in the tarball but is used | |
390 | ;; by the Makefile to build man pages. Copy the core bits here. | |
391 | (call-with-output-file "Build/MakeMans.hs" | |
392 | (lambda (out) | |
393 | (format out "module Main where~%") | |
394 | (format out "import Build.Mans~%") | |
395 | (format out "main = buildMansOrWarn~%"))) | |
396 | (invoke "runhaskell" "Build/MakeMans.hs"))) | |
804744b3 LC |
397 | (replace 'check |
398 | (lambda _ | |
399 | ;; We need to set the path so that Git recognizes | |
400 | ;; `git annex' as a custom command. | |
401 | (setenv "PATH" (string-append (getenv "PATH") ":" | |
402 | (getcwd) "/dist/build/git-annex")) | |
403 | (with-directory-excursion "dist/build/git-annex" | |
404 | (symlink "git-annex" "git-annex-shell")) | |
405 | (invoke "git-annex" "test") | |
406 | #t)) | |
3d45d8f1 KM |
407 | (add-after 'check 'unpatch-shell-and-rebuild |
408 | (lambda args | |
409 | ;; Undo `patch-shell-for-tests'. | |
410 | (copy-file "/tmp/Shell.hs" "Utility/Shell.hs") | |
411 | (apply (assoc-ref %standard-phases 'build) args))) | |
64fc2293 KM |
412 | (add-after 'install 'install-manpages |
413 | (lambda* (#:key outputs #:allow-other-keys) | |
414 | (let ((man (string-append (assoc-ref outputs "out") | |
415 | "/man/man1/"))) | |
416 | (mkdir-p man) | |
417 | (for-each (lambda (file) (install-file file man)) | |
418 | (find-files "man"))) | |
419 | #t)) | |
804744b3 LC |
420 | (add-after 'install 'install-symlinks |
421 | (lambda* (#:key outputs #:allow-other-keys) | |
422 | (let* ((out (assoc-ref outputs "out")) | |
423 | (bin (string-append out "/bin"))) | |
424 | (symlink (string-append bin "/git-annex") | |
425 | (string-append bin "/git-annex-shell")) | |
426 | (symlink (string-append bin "/git-annex") | |
427 | (string-append bin "/git-remote-tor-annex")) | |
e13fefbc TS |
428 | #t))) |
429 | (add-after 'install 'touch-static-output | |
430 | (lambda* (#:key outputs #:allow-other-keys) | |
431 | ;; The Haskell build system adds a "static" output by | |
432 | ;; default, and there is no way to override this until | |
433 | ;; <https://issues.guix.gnu.org/41569> is fixed. Without | |
434 | ;; this phase, the daemon complains because we do not | |
435 | ;; create the "static" output. | |
436 | (with-output-to-file (assoc-ref outputs "static") | |
437 | (lambda () | |
438 | (display "static output not used\n")))))))) | |
804744b3 LC |
439 | (inputs |
440 | `(("curl" ,curl) | |
441 | ("ghc-aeson" ,ghc-aeson) | |
442 | ("ghc-async" ,ghc-async) | |
ac1b0801 | 443 | ("ghc-aws" ,ghc-aws) |
804744b3 LC |
444 | ("ghc-bloomfilter" ,ghc-bloomfilter) |
445 | ("ghc-byteable" ,ghc-byteable) | |
446 | ("ghc-case-insensitive" ,ghc-case-insensitive) | |
a4a41a7b | 447 | ("ghc-concurrent-output" ,ghc-concurrent-output) |
804744b3 LC |
448 | ("ghc-crypto-api" ,ghc-crypto-api) |
449 | ("ghc-cryptonite" ,ghc-cryptonite) | |
450 | ("ghc-data-default" ,ghc-data-default) | |
8c944c4c | 451 | ("ghc-dav" ,ghc-dav) |
804744b3 LC |
452 | ("ghc-disk-free-space" ,ghc-disk-free-space) |
453 | ("ghc-dlist" ,ghc-dlist) | |
454 | ("ghc-edit-distance" ,ghc-edit-distance) | |
455 | ("ghc-esqueleto" ,ghc-esqueleto) | |
456 | ("ghc-exceptions" ,ghc-exceptions) | |
457 | ("ghc-feed" ,ghc-feed) | |
0e5c0e46 | 458 | ("ghc-filepath-bytestring" ,ghc-filepath-bytestring) |
804744b3 LC |
459 | ("ghc-free" ,ghc-free) |
460 | ("ghc-hslogger" ,ghc-hslogger) | |
461 | ("ghc-http-client" ,ghc-http-client) | |
462 | ("ghc-http-conduit" ,ghc-http-conduit) | |
463 | ("ghc-http-types" ,ghc-http-types) | |
464 | ("ghc-ifelse" ,ghc-ifelse) | |
f2a3ff85 | 465 | ("ghc-magic" ,ghc-magic) |
804744b3 LC |
466 | ("ghc-memory" ,ghc-memory) |
467 | ("ghc-monad-control" ,ghc-monad-control) | |
468 | ("ghc-monad-logger" ,ghc-monad-logger) | |
469 | ("ghc-network" ,ghc-network) | |
470 | ("ghc-old-locale" ,ghc-old-locale) | |
471 | ("ghc-optparse-applicative" ,ghc-optparse-applicative) | |
472 | ("ghc-persistent" ,ghc-persistent) | |
473 | ("ghc-persistent-sqlite" ,ghc-persistent-sqlite) | |
474 | ("ghc-persistent-template" ,ghc-persistent-template) | |
475 | ("ghc-quickcheck" ,ghc-quickcheck) | |
476 | ("ghc-random" ,ghc-random) | |
477 | ("ghc-regex-tdfa" ,ghc-regex-tdfa) | |
478 | ("ghc-resourcet" ,ghc-resourcet) | |
479 | ("ghc-safesemaphore" ,ghc-safesemaphore) | |
480 | ("ghc-sandi" ,ghc-sandi) | |
481 | ("ghc-securemem" ,ghc-securemem) | |
482 | ("ghc-socks" ,ghc-socks) | |
483 | ("ghc-split" ,ghc-split) | |
804744b3 LC |
484 | ("ghc-stm-chans" ,ghc-stm-chans) |
485 | ("ghc-tagsoup" ,ghc-tagsoup) | |
804744b3 LC |
486 | ("ghc-unix-compat" ,ghc-unix-compat) |
487 | ("ghc-unordered-containers" ,ghc-unordered-containers) | |
488 | ("ghc-utf8-string" ,ghc-utf8-string) | |
489 | ("ghc-uuid" ,ghc-uuid) | |
490 | ("git" ,git) | |
491 | ("rsync" ,rsync))) | |
492 | (native-inputs | |
493 | `(("ghc-tasty" ,ghc-tasty) | |
494 | ("ghc-tasty-hunit" ,ghc-tasty-hunit) | |
495 | ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck) | |
64fc2293 KM |
496 | ("ghc-tasty-rerun" ,ghc-tasty-rerun) |
497 | ("perl" ,perl))) | |
804744b3 LC |
498 | (home-page "https://git-annex.branchable.com/") |
499 | (synopsis "Manage files with Git, without checking in their contents") | |
500 | (description "This package allows managing files with Git, without | |
501 | checking the file contents into Git. It can store files in many places, | |
502 | such as local hard drives and cloud storage services. It can also be | |
503 | used to keep a folder in sync between computers.") | |
7e772cb6 KM |
504 | ;; The main author has released all his changes under AGPLv3+ as of March |
505 | ;; 2019 (7.20190219-187-g40ecf58d4). These are also licensed under the | |
506 | ;; original GPLv3+ license, but going forward new changes will be under | |
507 | ;; only AGPLv3+. The other licenses below cover code written by others. | |
508 | ;; See git-annex's COPYRIGHT file for details on each file. | |
509 | (license (list license:agpl3+ | |
510 | license:gpl3+ | |
511 | license:bsd-2 | |
512 | license:expat | |
513 | license:gpl2)))) | |
bfccae4e | 514 | |
62e42dfa RV |
515 | (define-public hlint |
516 | (package | |
517 | (name "hlint") | |
cfbb0a95 | 518 | (version "2.1.26") |
62e42dfa RV |
519 | (source |
520 | (origin | |
521 | (method url-fetch) | |
522 | (uri (string-append | |
523 | "https://hackage.haskell.org/package/" name | |
524 | "/" name "-" version ".tar.gz")) | |
525 | (sha256 | |
526 | (base32 | |
cfbb0a95 | 527 | "16zkkpbfrd69853cdqf597fva969lirfc86b039i9zd7ghlrcayc")))) |
62e42dfa RV |
528 | (build-system haskell-build-system) |
529 | (inputs | |
530 | `(("cpphs" ,cpphs) | |
531 | ("ghc-unordered-containers" ,ghc-unordered-containers) | |
532 | ("ghc-yaml" ,ghc-yaml) | |
533 | ("ghc-vector" ,ghc-vector) | |
534 | ("ghc-data-default" ,ghc-data-default) | |
535 | ("ghc-cmdargs" ,ghc-cmdargs) | |
536 | ("ghc-haskell-src-exts" ,ghc-haskell-src-exts) | |
537 | ("ghc-haskell-src-exts-util" ,ghc-haskell-src-exts-util) | |
538 | ("ghc-uniplate" ,ghc-uniplate) | |
539 | ("ghc-ansi-terminal" ,ghc-ansi-terminal) | |
540 | ("ghc-extra" ,ghc-extra) | |
541 | ("ghc-refact" ,ghc-refact) | |
542 | ("ghc-aeson" ,ghc-aeson) | |
cfbb0a95 | 543 | ("ghc-lib-parser" ,ghc-lib-parser) |
62e42dfa | 544 | ("hscolour" ,hscolour))) |
19115138 | 545 | (home-page "https://github.com/ndmitchell/hlint") |
62e42dfa RV |
546 | (synopsis "Suggest improvements for Haskell source code") |
547 | (description "HLint reads Haskell programs and suggests changes that | |
548 | hopefully make them easier to read. HLint also makes it easy to disable | |
549 | unwanted suggestions, and to add your own custom suggestions.") | |
550 | (license license:bsd-3))) | |
551 | ||
6ec2450f JS |
552 | (define-public hoogle |
553 | (package | |
554 | (name "hoogle") | |
12ee2d5d | 555 | (version "5.0.17.11") |
6ec2450f JS |
556 | (source |
557 | (origin | |
558 | (method url-fetch) | |
559 | (uri | |
560 | (string-append | |
561 | "https://hackage.haskell.org/package/hoogle/hoogle-" | |
562 | version ".tar.gz")) | |
563 | (sha256 | |
564 | (base32 | |
12ee2d5d | 565 | "1svp8z9pad8z2j386pr0dda0ds8ddxab0salnz4gm51q877w93p1")))) |
6ec2450f JS |
566 | (build-system haskell-build-system) |
567 | (inputs | |
12ee2d5d | 568 | `(("ghc-quickcheck" ,ghc-quickcheck) |
6ec2450f | 569 | ("ghc-aeson" ,ghc-aeson) |
12ee2d5d TS |
570 | ("ghc-blaze-html" ,ghc-blaze-html) |
571 | ("ghc-blaze-markup" ,ghc-blaze-markup) | |
6ec2450f JS |
572 | ("ghc-cmdargs" ,ghc-cmdargs) |
573 | ("ghc-conduit" ,ghc-conduit) | |
574 | ("ghc-conduit-extra" ,ghc-conduit-extra) | |
575 | ("ghc-connection" ,ghc-connection) | |
576 | ("ghc-extra" ,ghc-extra) | |
12ee2d5d | 577 | ("ghc-foundation" ,ghc-foundation) |
6ec2450f JS |
578 | ("ghc-old-locale" ,ghc-old-locale) |
579 | ("ghc-haskell-src-exts" ,ghc-haskell-src-exts) | |
580 | ("ghc-http-conduit" ,ghc-http-conduit) | |
581 | ("ghc-http-types" ,ghc-http-types) | |
582 | ("ghc-js-flot" ,ghc-js-flot) | |
583 | ("ghc-js-jquery" ,ghc-js-jquery) | |
584 | ("ghc-mmap" ,ghc-mmap) | |
585 | ("ghc-process-extras" ,ghc-process-extras) | |
586 | ("ghc-resourcet" ,ghc-resourcet) | |
587 | ("ghc-storable-tuple" ,ghc-storable-tuple) | |
588 | ("ghc-tar" ,ghc-tar) | |
589 | ("ghc-uniplate" ,ghc-uniplate) | |
590 | ("ghc-utf8-string" ,ghc-utf8-string) | |
591 | ("ghc-vector" ,ghc-vector) | |
592 | ("ghc-wai" ,ghc-wai) | |
593 | ("ghc-wai-logger" ,ghc-wai-logger) | |
594 | ("ghc-warp" ,ghc-warp) | |
595 | ("ghc-warp-tls" ,ghc-warp-tls) | |
596 | ("ghc-zlib" ,ghc-zlib))) | |
597 | (home-page "https://hoogle.haskell.org/") | |
598 | (synopsis "Haskell API Search") | |
599 | (description "Hoogle is a Haskell API search engine, which allows | |
600 | you to search many standard Haskell libraries by either function name, | |
601 | or by approximate type signature.") | |
602 | (license license:bsd-3))) | |
603 | ||
62e42dfa RV |
604 | (define-public hscolour |
605 | (package | |
606 | (name "hscolour") | |
607 | (version "1.24.4") | |
608 | (source | |
609 | (origin | |
610 | (method url-fetch) | |
611 | (uri (string-append | |
612 | "https://hackage.haskell.org/package/hscolour/hscolour-" | |
613 | version | |
614 | ".tar.gz")) | |
615 | (sha256 | |
616 | (base32 | |
617 | "079jwph4bwllfp03yfr26s5zc6m6kw3nhb1cggrifh99haq34cr4")))) | |
618 | (build-system haskell-build-system) | |
619 | (home-page "https://hackage.haskell.org/package/hscolour") | |
620 | (synopsis "Script to colourise Haskell code") | |
621 | (description "HSColour is a small Haskell script to colourise Haskell | |
622 | code. It currently has six output formats: ANSI terminal codes (optionally | |
623 | XTerm-256colour codes), HTML 3.2 with font tags, HTML 4.01 with CSS, HTML 4.01 | |
624 | with CSS and mouseover annotations, XHTML 1.0 with inline CSS styling, LaTeX, | |
625 | and mIRC chat codes.") | |
626 | (license license:bsd-3))) | |
627 | ||
51add2a9 AG |
628 | (define-public kmonad |
629 | (package | |
630 | (name "kmonad") | |
838c8204 | 631 | (version "0.4.0") |
51add2a9 AG |
632 | (source |
633 | (origin | |
634 | (method git-fetch) | |
635 | (uri (git-reference | |
b0e7b699 | 636 | (url "https://github.com/david-janssen/kmonad") |
15c06ad0 | 637 | (commit version))) |
51add2a9 AG |
638 | (file-name (git-file-name name version)) |
639 | (sha256 | |
838c8204 | 640 | (base32 "064gnzzcm6fnxfiildbjmgbdxkhqvp61zrl6qhkl1pgbn27j1mll")))) |
51add2a9 AG |
641 | (build-system haskell-build-system) |
642 | (arguments | |
643 | `(#:phases | |
644 | (modify-phases %standard-phases | |
645 | (delete 'haddock) ; Haddock fails to generate docs | |
646 | (add-after 'install 'install-udev-rules | |
647 | (lambda* (#:key outputs #:allow-other-keys) | |
648 | (let* ((out (assoc-ref outputs "out")) | |
649 | (rules (string-append out "/lib/udev/rules.d"))) | |
650 | (mkdir-p rules) | |
651 | (call-with-output-file (string-append rules "/70-kmonad.rules") | |
652 | (lambda (port) | |
653 | (display | |
654 | (string-append | |
655 | "KERNEL==\"uinput\", MODE=\"0660\", " | |
656 | "GROUP=\"input\", OPTIONS+=\"static_node=uinput\"\n") | |
657 | port))) | |
658 | #t))) | |
659 | (add-after 'install-udev-rules 'install-documentation | |
660 | (lambda* (#:key outputs #:allow-other-keys) | |
661 | (let* ((out (assoc-ref outputs "out")) | |
662 | (doc (string-append out "/share/doc/kmonad-" ,version))) | |
663 | (install-file "README.md" doc) | |
664 | (copy-recursively "doc" doc) | |
838c8204 | 665 | (copy-recursively "keymap" (string-append doc "/keymap")) |
51add2a9 AG |
666 | #t)))))) |
667 | (inputs | |
668 | `(("ghc-cereal" ,ghc-cereal) | |
669 | ("ghc-exceptions" ,ghc-exceptions) | |
670 | ("ghc-hashable" ,ghc-hashable) | |
671 | ("ghc-lens" ,ghc-lens) | |
03b0c92e | 672 | ("ghc-megaparsec" ,ghc-megaparsec) |
51add2a9 | 673 | ("ghc-optparse-applicative" ,ghc-optparse-applicative) |
838c8204 AG |
674 | ("ghc-resourcet" ,ghc-resourcet) |
675 | ("ghc-rio" ,ghc-rio) | |
51add2a9 AG |
676 | ("ghc-unagi-chan" ,ghc-unagi-chan) |
677 | ("ghc-unliftio" ,ghc-unliftio) | |
678 | ("ghc-unordered-containers" ,ghc-unordered-containers))) | |
679 | (home-page "https://github.com/david-janssen/kmonad") | |
680 | (synopsis "Advanced keyboard manager") | |
681 | (description "KMonad is a keyboard remapping utility that supports | |
682 | advanced functionality, such as custom keymap layers and modifiers, macros, | |
683 | and conditional mappings that send a different keycode when tapped or held. | |
684 | By operating at a lower level than most similar tools, it supports X11, | |
685 | Wayland, and Linux console environments alike.") | |
686 | (license license:expat))) | |
687 | ||
bfccae4e LC |
688 | (define-public raincat |
689 | (package | |
690 | (name "raincat") | |
691 | (version "1.2.1") | |
692 | (source | |
693 | (origin | |
694 | (method url-fetch) | |
1e5c274e | 695 | (uri (string-append "mirror://hackage/package/Raincat/" |
bfccae4e LC |
696 | "Raincat-" version ".tar.gz")) |
697 | (sha256 | |
698 | (base32 | |
699 | "10y9zi22m6hf13c9h8zd9vg7mljpwbw0r3djb6r80bna701fdf6c")))) | |
700 | (build-system haskell-build-system) | |
701 | (arguments | |
702 | `(#:phases | |
703 | (modify-phases %standard-phases | |
704 | (add-after 'install 'wrap-executable | |
705 | (lambda* (#:key inputs outputs #:allow-other-keys) | |
706 | (let ((out (assoc-ref outputs "out"))) | |
707 | (wrap-program (string-append out "/bin/raincat") | |
708 | `("LD_LIBRARY_PATH" ":" = | |
709 | (,(string-append (assoc-ref inputs "freeglut") | |
710 | "/lib")))) | |
711 | #t)))))) | |
712 | (inputs | |
713 | `(("ghc-extensible-exceptions" ,ghc-extensible-exceptions) | |
714 | ("ghc-random" ,ghc-random) | |
715 | ("ghc-glut" ,ghc-glut) | |
716 | ("freeglut" ,freeglut) | |
717 | ("ghc-opengl" ,ghc-opengl) | |
718 | ("ghc-sdl2" ,ghc-sdl2) | |
719 | ("ghc-sdl2-image" ,ghc-sdl2-image) | |
720 | ("ghc-sdl2-mixer" ,ghc-sdl2-mixer))) | |
a15b4529 | 721 | (home-page "https://www.gamecreation.org/games/raincat") |
bfccae4e LC |
722 | (synopsis "Puzzle game with a cat in lead role") |
723 | (description "Project Raincat is a game developed by Carnegie Mellon | |
724 | students through GCS during the Fall 2008 semester. Raincat features game | |
725 | play inspired from classics Lemmings and The Incredible Machine. The project | |
726 | proved to be an excellent learning experience for the programmers. Everything | |
727 | is programmed in Haskell.") | |
728 | (license license:bsd-3))) | |
62e42dfa | 729 | |
6e241750 EF |
730 | (define-public scroll |
731 | (package | |
732 | (name "scroll") | |
733 | (version "1.20180421") | |
734 | (source | |
735 | (origin | |
736 | (method url-fetch) | |
737 | (uri (string-append | |
738 | "https://hackage.haskell.org/package/scroll/scroll-" | |
739 | version ".tar.gz")) | |
740 | (sha256 | |
741 | (base32 | |
742 | "0apzrvf99rskj4dbmn57jjxrsf19j436s8a09m950df5aws3a0wj")))) | |
743 | (build-system haskell-build-system) | |
7bcc8004 EF |
744 | (arguments |
745 | '(#:phases | |
746 | (modify-phases %standard-phases | |
747 | (add-after 'install 'touch-static-output | |
748 | (lambda* (#:key outputs #:allow-other-keys) | |
749 | ;; The Haskell build system adds a "static" output by | |
750 | ;; default, and there is no way to override this until | |
751 | ;; <https://issues.guix.gnu.org/41569> is fixed. Without | |
752 | ;; this phase, the daemon complains because we do not | |
753 | ;; create the "static" output. | |
754 | (with-output-to-file (assoc-ref outputs "static") | |
755 | (lambda () | |
756 | (display "static output not used\n"))) | |
757 | #t))))) | |
6e241750 EF |
758 | (inputs |
759 | `(("ghc-case-insensitive" ,ghc-case-insensitive) | |
760 | ("ghc-data-default" ,ghc-data-default) | |
761 | ("ghc-ifelse" ,ghc-ifelse) | |
762 | ("ghc-monad-loops" ,ghc-monad-loops) | |
763 | ("ghc-ncurses" ,ghc-ncurses) | |
764 | ("ghc-optparse-applicative" ,ghc-optparse-applicative) | |
765 | ("ghc-random" ,ghc-random) | |
766 | ("ghc-vector" ,ghc-vector))) | |
767 | (home-page "https://joeyh.name/code/scroll/") | |
768 | (synopsis "scroll(6), a roguelike game") | |
769 | (description | |
770 | "You're a bookworm that's stuck on a scroll. You have to dodge between | |
771 | words and use spells to make your way down the page as the scroll is read. Go | |
772 | too slow and you'll get wound up in the scroll and crushed.") | |
773 | (license license:gpl2))) | |
774 | ||
62e42dfa RV |
775 | (define-public shellcheck |
776 | (package | |
777 | (name "shellcheck") | |
ce4a497b | 778 | (version "0.7.1") |
62e42dfa RV |
779 | (source |
780 | (origin | |
781 | (method url-fetch) | |
782 | (uri (string-append | |
783 | "https://hackage.haskell.org/package/ShellCheck/ShellCheck-" | |
784 | version ".tar.gz")) | |
785 | (sha256 | |
ce4a497b | 786 | (base32 "06m4wh891nah3y0br4wh3adpsb16zawkb2ijgf1vcz61fznj6ps1")) |
62e42dfa RV |
787 | (file-name (string-append name "-" version ".tar.gz")))) |
788 | (build-system haskell-build-system) | |
789 | (inputs | |
790 | `(("ghc-aeson" ,ghc-aeson) | |
791 | ("ghc-diff" ,ghc-diff) | |
792 | ("ghc-quickcheck" ,ghc-quickcheck) | |
793 | ("ghc-regex-tdfa" ,ghc-regex-tdfa))) | |
1ee45e62 | 794 | (home-page "https://www.shellcheck.net/") |
62e42dfa RV |
795 | (synopsis "Static analysis for shell scripts") |
796 | (description "@code{shellcheck} provides static analysis for | |
797 | @command{bash} and @command{sh} shell scripts. | |
798 | It gives warnings and suggestions in order to: | |
799 | ||
800 | @enumerate | |
801 | @item Point out and clarify typical beginner's syntax issues that cause | |
802 | a shell to give cryptic error messages. | |
803 | @item Point out and clarify typical intermediate level semantic problems | |
804 | that cause a shell to behave strangely and counter-intuitively. | |
805 | @item Point out subtle caveats, corner cases and pitfalls that may cause an | |
806 | advanced user's otherwise working script to fail under future circumstances. | |
807 | @end enumerate") | |
808 | (license license:gpl3+))) | |
83f9448e | 809 | |
dcfd1d2c MB |
810 | (define-public shelltestrunner |
811 | (package | |
812 | (name "shelltestrunner") | |
813 | (version "1.9") | |
814 | (source (origin | |
815 | (method url-fetch) | |
816 | (uri (string-append "mirror://hackage/package/shelltestrunner-" | |
817 | version "/shelltestrunner-" version ".tar.gz")) | |
818 | (sha256 | |
819 | (base32 | |
820 | "1a5kzqbwg6990249ypw0cx6cqj6663as1kbj8nzblcky8j6kbi6b")))) | |
821 | (build-system haskell-build-system) | |
822 | (arguments | |
823 | '(#:phases | |
824 | (modify-phases %standard-phases | |
825 | (delete 'check) | |
826 | (add-after 'install 'check | |
827 | (lambda* (#:key outputs tests? parallel-tests? #:allow-other-keys) | |
828 | ;; This test is inspired by the Makefile in the upstream | |
829 | ;; repository, which is missing in the Hackage release tarball | |
830 | ;; along with some of the tests. The Makefile would not work | |
831 | ;; anyway as it ties into the 'stack' build tool. | |
832 | (let* ((out (assoc-ref outputs "out")) | |
833 | (shelltest (string-append out "/bin/shelltest")) | |
834 | (numjobs (if parallel-tests? | |
835 | (number->string (parallel-job-count)) | |
836 | "1"))) | |
837 | (if tests? | |
838 | (invoke shelltest (string-append "-j" numjobs) | |
839 | "tests/examples") | |
840 | (format #t "test suite not run~%")) | |
841 | #t)))))) | |
842 | (inputs | |
843 | `(("ghc-diff" ,ghc-diff) | |
844 | ("ghc-cmdargs" ,ghc-cmdargs) | |
845 | ("ghc-filemanip" ,ghc-filemanip) | |
846 | ("ghc-hunit" ,ghc-hunit) | |
847 | ("ghc-pretty-show" ,ghc-pretty-show) | |
848 | ("ghc-regex-tdfa" ,ghc-regex-tdfa) | |
849 | ("ghc-safe" ,ghc-safe) | |
850 | ("ghc-utf8-string" ,ghc-utf8-string) | |
851 | ("ghc-test-framework" ,ghc-test-framework) | |
852 | ("ghc-test-framework-hunit" ,ghc-test-framework-hunit))) | |
853 | (home-page "https://github.com/simonmichael/shelltestrunner") | |
854 | (synopsis "Test CLI programs") | |
855 | (description | |
856 | "shelltestrunner (executable: @command{shelltest}) is a command-line tool | |
857 | for testing command-line programs, or general shell commands. It reads simple | |
858 | test specifications defining a command to run, some input, and the expected | |
859 | output, stderr, and exit status.") | |
860 | (license license:gpl3+))) | |
861 | ||
83f9448e JS |
862 | (define-public stylish-haskell |
863 | (package | |
864 | (name "stylish-haskell") | |
865 | (version "0.9.2.2") | |
866 | (source | |
867 | (origin | |
868 | (method url-fetch) | |
869 | (uri | |
870 | (string-append | |
871 | "mirror://hackage/package/stylish-haskell/" | |
872 | "stylish-haskell-" version ".tar.gz")) | |
873 | (sha256 | |
874 | (base32 | |
875 | "1zs624xqp6j8vrl6pfv18dm8vz8hvz25grri65ximxhcizgwhnax")))) | |
876 | (build-system haskell-build-system) | |
877 | (inputs | |
878 | `(("ghc-aeson" ,ghc-aeson) | |
879 | ("ghc-file-embed" ,ghc-file-embed) | |
880 | ("ghc-haskell-src-exts" ,ghc-haskell-src-exts) | |
881 | ("ghc-semigroups" ,ghc-semigroups) | |
882 | ("ghc-syb" ,ghc-syb) | |
883 | ("ghc-yaml" ,ghc-yaml) | |
884 | ("ghc-strict" ,ghc-strict) | |
885 | ("ghc-optparse-applicative" ,ghc-optparse-applicative) | |
886 | ("ghc-hunit" ,ghc-hunit) | |
887 | ("ghc-test-framework" ,ghc-test-framework) | |
888 | ("ghc-test-framework-hunit" ,ghc-test-framework-hunit))) | |
889 | (home-page "https://github.com/jaspervdj/stylish-haskell") | |
890 | (synopsis "Haskell code prettifier") | |
156b08bd JS |
891 | (description "Stylish-haskell is a Haskell code prettifier. The goal is |
892 | not to format all of the code in a file, to avoid \"getting in the way\". | |
893 | However, this tool can e.g. clean up import statements and help doing various | |
894 | tasks that get tedious very quickly. It can | |
895 | @itemize | |
896 | @item | |
897 | Align and sort @code{import} statements | |
898 | @item | |
899 | Group and wrap @code{{-# LANGUAGE #-}} pragmas, remove (some) redundant | |
900 | pragmas | |
901 | @item | |
902 | Remove trailing whitespaces | |
903 | @item | |
904 | Align branches in @code{case} and fields in records | |
905 | @item | |
906 | Convert line endings (customisable) | |
907 | @item | |
908 | Replace tabs by four spaces (turned off by default) | |
909 | @item | |
910 | Replace some ASCII sequences by their Unicode equivalent (turned off by | |
911 | default) | |
912 | @end itemize") | |
83f9448e | 913 | (license license:bsd-3))) |
1e19569b MB |
914 | |
915 | (define-public ghc-stylish-haskell | |
916 | (deprecated-package "ghc-stylish-haskell" stylish-haskell)) |