TakeV
/
guix
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Revert the #51061 patch series for now. 

This reverts commits f63c79bf76
..f86f7e24b39928247729020df0134e2e1c4cde62 for more chillax reviewing.

See <https://issues.guix.gnu.org/51061#32>.
This commit is contained in:
Tobias Geerinckx-Rice 2021-10-08 23:26:24 +02:00
parent ea3d456a5a
commit a1679b74c9
No known key found for this signature in database
GPG Key ID: 0DB0FF884F556D79
10 changed files with 2 additions and 1291 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
Makefile.am
View File

@ -99,7 +99,6 @@ MODULES = \
guix/extracting-download.scm \
guix/git-download.scm \
guix/hg-download.scm \
guix/hexpm-download.scm \
guix/swh.scm \
guix/monads.scm \
guix/monad-repl.scm \
@ -163,7 +162,6 @@ MODULES = \
guix/build-system/waf.scm \
guix/build-system/r.scm \
guix/build-system/rakudo.scm \
guix/build-system/rebar3.scm \
guix/build-system/ruby.scm \
guix/build-system/scons.scm \
guix/build-system/texlive.scm \
@ -217,7 +215,6 @@ MODULES = \
guix/build/r-build-system.scm \
guix/build/renpy-build-system.scm \
guix/build/rakudo-build-system.scm \
guix/build/rebar3-build-system.scm \
guix/build/ruby-build-system.scm \
guix/build/scons-build-system.scm \
guix/build/texlive-build-system.scm \
@ -265,7 +262,6 @@ MODULES = \
guix/import/gnu.scm \
guix/import/go.scm \
guix/import/hackage.scm \
guix/import/hexpm.scm \
guix/import/json.scm \
guix/import/kde.scm \
guix/import/launchpad.scm \
@ -313,7 +309,6 @@ MODULES = \
guix/scripts/import/gnu.scm \
guix/scripts/import/go.scm \
guix/scripts/import/hackage.scm \
guix/scripts/import/hexpm.scm \
guix/scripts/import/json.scm \
guix/scripts/import/minetest.scm \
guix/scripts/import/opam.scm \

492
gnu/packages/erlang.scm
View File

@ -4,7 +4,6 @@
;;; Copyright © 2016, 2017 Pjotr Prins <pjotr.guix@thebird.nl>
;;; Copyright © 2018 Tobias Geerinckx-Rice <me@tobias.gr>
;;; Copyright © 2018 Nikita <nikita@n0.is>
;;; Copyright © 2020, 2021 Hartmut Goebel <h.goebel@crazy-compilers.com>
;;; Copyright © 2021 Oskar Köök <oskar@maatriks.ee>
;;; Copyright © 2021 Cees de Groot <cg@evrl.com>
;;;
@ -27,10 +26,8 @@
#:use-module ((guix licenses) #:prefix license:)
#:use-module (guix build-system gnu)
#:use-module (guix build-system emacs)
#:use-module (guix build-system rebar3)
#:use-module (guix download)
#:use-module (guix git-download)
#:use-module (guix hexpm-download)
#:use-module (guix packages)
#:use-module (guix utils)
#:use-module (gnu packages)
@ -38,7 +35,6 @@
#:use-module (gnu packages gl)
#:use-module (gnu packages ncurses)
#:use-module (gnu packages perl)
#:use-module (gnu packages version-control)
#:use-module (gnu packages tls)
#:use-module (gnu packages wxwidgets))
@ -225,491 +221,3 @@ built-in support for concurrency, distribution and fault tolerance.")
"This package provides an Emacs major mode for editing Erlang source
files.")
(license license:asl2.0)))
(define-public erlang-bbmustache
(package
(name "erlang-bbmustache")
(version "1.12.1")
(source
(origin
(method hexpm-fetch)
(uri (hexpm-uri "bbmustache" version))
(sha256
(base32 "0wbfayx6940zf57bpwg1m9sk3cpgam2q8n0w74alkrc4gc7hn47w"))))
(build-system rebar3-build-system)
(inputs
`(("erlang-edown" ,erlang-edown)
("erlang-getopt" ,erlang-getopt)
("erlang-rebar3-git-vsn" ,erlang-rebar3-git-vsn)))
(arguments
`(#:tests? #f ;; requires mustache specification file
#:phases
(modify-phases %standard-phases
(add-after 'build 'build-escript
(lambda _
(invoke "rebar3" "as" "dev" "escriptize")))
(add-after 'install 'install-escript
(lambda* (#:key outputs #:allow-other-keys)
(let* ((out (assoc-ref outputs "out")))
(install-file "_build/dev/bin/bbmustache"
(string-append out "/bin")))
#t)))))
(home-page "https://github.com/soranoba/bbmustache/")
(synopsis "Binary pattern match Based Mustache template engine for Erlang")
(description "This Erlang library provides a Binary pattern match Based
Mustache template engine")
(license license:expat)))
(define-public erlang-certifi
(package
(name "erlang-certifi")
(version "2.7.0")
(source
(origin
(method hexpm-fetch)
(uri (hexpm-uri "certifi" version))
(sha256
(base32 "1ssiajvll5nilrnsg23ja3qz2fmvnbhy176c8i0gqj0h1alismn9"))))
(build-system rebar3-build-system)
(inputs
`(("parse-trans" ,erlang-parse-trans)))
(home-page "https://github.com/certifi/erlang-certifi/")
(synopsis "CA bundle adapted from Mozilla for Erlang")
(description "This Erlang library contains a CA bundle that you can
reference in your Erlang application. This is useful for systems that do not
have CA bundles that Erlang can find itself, or where a uniform set of CAs is
valuable.
This an Erlang specific port of certifi. The CA bundle is derived from
Mozilla's canonical set.")
(license license:bsd-3)))
(define-public erlang-cf
(package
(name "erlang-cf")
(version "0.3.1")
(source
(origin
(method hexpm-fetch)
(uri (hexpm-uri "cf" version))
(sha256
(base32 "0vnmbb1n899xw2p4x6c3clpzxcqqdsfbfhh1dfy530i3201vr2h4"))))
(build-system rebar3-build-system)
(home-page "https://github.com/project-fifo/cf")
(synopsis "Terminal colour helper for Erlang io and io_lib")
(description "This package provides a helper library for termial colour
printing extending the io:format syntax to add colours.")
(license license:expat)))
(define-public erlang-covertool
(package
(name "erlang-covertool")
(version "2.0.4")
(source
(origin
(method hexpm-fetch)
(uri (hexpm-uri "covertool" version))
(sha256
(base32 "10krv66nabzrgkz4k3gfp7zx1x9030vnkhc0n1f1chwzwf4sa6nx"))))
(build-system rebar3-build-system)
(home-page "https://github.com/covertool/covertool")
(synopsis "Convert Erlang cover data into Cobertura XML reports")
(description "This package provides a build tool and plugin to convert
exported Erlang cover data sets into Cobertura XML reports, which can then be
feed to the Jenkins Cobertura plug-in.
On @emph{hex.pm}, this plugin was previously called @code{rebar_covertool}.")
(license license:bsd-2)))
(define-public erlang-cth-readable
(package
(name "erlang-cth-readable")
(version "1.5.1")
(source
(origin
(method hexpm-fetch)
(uri (hexpm-uri "cth_readable" version))
(sha256
(base32 "0hqzgd8fvs4d1bhpm6dkm3bm2jik4qbl78s514r5ivwjxw1dzrds"))))
(build-system rebar3-build-system)
(propagated-inputs
`(("erlang-cf" ,erlang-cf)))
(arguments
`(#:tests? #f)) ;; no test-suite
(home-page "https://github.com/ferd/cth_readable")
(synopsis "Common Test hooks for more readable logs for Erlang")
(description "This package provides an OTP library to be used for CT log
outputs you want to be readable around all that noise they contain.")
(license license:bsd-3)))
(define-public erlang-edown
(package
(name "erlang-edown")
(version "0.8.4")
(source
(origin
(method hexpm-fetch)
(uri (hexpm-uri "edown" version))
(sha256
(base32 "1khk5yxqjix2irsr02i0zpkv52myakpw4ahsr4fcy81l3xlk58dx"))))
(build-system rebar3-build-system)
(home-page "https://github.com/uwiger/edown")
(synopsis "Markdown extension for EDoc")
(description "This package provides an extension for EDoc for generating
Markdown.")
(license license:asl2.0)))
(define-public erlang-erlware-commons
(package
(name "erlang-erlware-commons")
(version "1.6.0")
(source
(origin
(method hexpm-fetch)
(uri (hexpm-uri "erlware_commons" version))
(sha256
(base32 "0xc3kiylingqrrnzhxm2j2n5gr3hxqgpibhi9nva9bwjs4n155fm"))))
(build-system rebar3-build-system)
(propagated-inputs
`(("erlang-cf" ,erlang-cf)))
(native-inputs
`(("git" ,git))) ;; Required for tests
(arguments
`(#:tests? #f)) ;; TODO: 1/219 tests fail - very simple one, though
(home-page "http://erlware.github.io/erlware_commons/")
(synopsis "Additional standard library for Erlang")
(description "Erlware Commons is an Erlware project focused on all aspects
of reusable Erlang components.")
(license license:expat)))
(define-public erlang-eunit-formatters
(package
(name "erlang-eunit-formatters")
(version "0.5.0")
(source
(origin
(method hexpm-fetch)
(uri (hexpm-uri "eunit_formatters" version))
(sha256
(base32 "18q3vb12799584kdb998298b6bfh686mzi5s7pkb7djrf93vgf5f"))))
(build-system rebar3-build-system)
(home-page "https://github.com/seancribbs/eunit_formatters")
(synopsis "Better output for eunit suites")
(description "This package provides a better output for Erlang eunits.")
(license license:asl2.0)))
(define-public erlang-getopt
(package
(name "erlang-getopt")
(version "1.0.2")
(source
(origin
(method hexpm-fetch)
(uri (hexpm-uri "getopt" version))
(sha256
(base32 "1yxs36l1ll56zrxn81kw5qd8fv1q14myhjylk7dk31palg7jl725"))))
(build-system rebar3-build-system)
(home-page "https://github.com/jcomellas/getopt")
(synopsis "Command-line options parser for Erlang")
(description "This package provides an Erlang module to parse command line
arguments using the GNU getopt syntax.")
(license license:bsd-3)))
(define-public erlang-hex-core
(package
(name "erlang-hex-core")
(version "0.8.2")
(source
(origin
(method hexpm-fetch)
(uri (hexpm-uri "hex_core" version))
(sha256
(base32 "15fybnqxl5lzkpd8fjj1fxmj8cxcdpkxn0cvwc41cv0vxv3pw797"))))
(build-system rebar3-build-system)
(arguments
`(#:phases
(modify-phases %standard-phases
(replace 'check
(lambda* (#:key tests? #:allow-other-keys)
(when tests?
(invoke "rebar3" "as" "test" "proper")))))))
(inputs
`(("erlang-proper" ,erlang-proper)
("erlang-rebar3-proper" ,erlang-rebar3-proper)))
(propagated-inputs
`(("erlang-getopt" ,erlang-getopt)))
(home-page "https://github.com/hexpm/hex_core")
(synopsis "Reference implementation of Hex specifications")
(description "This package provides the reference implementation of Hex
specifications.")
(license license:asl2.0)))
(define-public erlang-jsone
(package
(name "erlang-jsone")
(version "1.6.1")
(source
(origin
(method hexpm-fetch)
(uri (hexpm-uri "jsone" version))
(sha256
(base32 "1wdbj4a736bg2fh4qk7y3h6lsdi84ivvypgbkphzy0mfz7nkc97p"))))
(build-system rebar3-build-system)
(arguments
`(#:phases
(modify-phases %standard-phases
(add-after 'unpack 'disable-covertool
(lambda _
(substitute* "rebar.config"
(("\\{project_plugins, \\[covertool\\]\\}\\." _) "")))))))
(home-page "https://github.com/sile/jsone/")
(synopsis "Erlang JSON Library")
(description "An Erlang library for encoding and decoding JSON data.")
(license license:expat)))
(define-public erlang-parse-trans
(package
(name "erlang-parse-trans")
(version "3.4.1")
(source
(origin
(method hexpm-fetch)
(uri (hexpm-uri "parse_trans" version))
(sha256
(base32 "1g3ablipihi8z64j9195pmrlf7gymyi21j2da9y509igs3q1sxfc"))))
(build-system rebar3-build-system)
(inputs
`(("erlang-getopt" ,erlang-getopt)))
(home-page "https://github.com/uwiger/parse_trans")
(synopsis "Parse transform utilities for Erlang")
(description "This package provides parse transform utilities for
Erlang.")
(license license:asl2.0)))
(define-public erlang-proper
(package
(name "erlang-proper")
(version "1.4.0")
(source
(origin
(method hexpm-fetch)
(uri (hexpm-uri "proper" version))
(sha256
(base32 "1b0srk0swbns6807vxwhj1hfrql7r14arysaax99kvl12f4q3qci"))))
(build-system rebar3-build-system)
(arguments
`(#:phases
(modify-phases %standard-phases
(add-after 'unpack 'disable-covertool
(lambda _
(substitute* "rebar.config"
(("\\{plugins, \\[covertool\\]\\}\\." _) "")))))))
(home-page "https://proper-testing.github.io/")
(synopsis "QuickCheck-inspired property-based testing tool for Erlang")
(description "PropEr is a tool for the automated, semi-random,
property-based testing of Erlang programs. It is fully integrated with
Erlang's type language, and can also be used for the model-based random
testing of stateful systems.")
(license license:gpl3+)))
(define-public erlang-providers
(package
(name "erlang-providers")
(version "1.9.0")
(source
(origin
(method hexpm-fetch)
(uri (hexpm-uri "providers" version))
(sha256
(base32 "0rq5zrqrsv2zgg84yfgh1faahnl4hkn92lja43iqihyiy181813z"))))
(propagated-inputs
`(("erlang-cf" ,erlang-cf)
("erlang-erlware-commons" ,erlang-erlware-commons)
("erlang-getopt" ,erlang-getopt)))
(build-system rebar3-build-system)
(home-page "https://github.com/tsloughter/providers")
(synopsis "Erlang providers library")
(description "This package provides an Erlang providers library.")
(license license:asl2.0)))
(define-public erlang-rebar3-git-vsn
(package
(name "erlang-rebar3-git-vsn")
(version "1.1.1")
(source
(origin
(method hexpm-fetch)
(uri (hexpm-uri "rebar3_git_vsn" version))
(sha256
(base32 "1ra4xjyc40r97aqb8aq2rll1v8wkf9jyisnbk34xdqcgv9s9iw7d"))))
(build-system rebar3-build-system)
(inputs
`(("git" ,git)))
(arguments
`(;; Running the tests require binary artifact (tar-file containing
;; samples git repos)
#:tests? #f
#:phases
(modify-phases %standard-phases
(add-after 'unpack 'patch-path
(lambda* (#:key inputs #:allow-other-keys)
(let ((git (assoc-ref inputs "git")))
(substitute* "src/rebar3_git_vsn.erl"
(("rebar_utils:sh\\(\"git " _)
(string-append "rebar_utils:sh(\"" git "/bin/git ")))))))))
(home-page "https://github.com/soranoba/rebar3_git_vsn")
(synopsis "Rebar3 plugin for generating the version from git")
(description "This plugin adds support for generating the version from
a git checkout.")
(license license:expat)))
(define-public erlang-rebar3-proper
(package
(name "erlang-rebar3-proper")
(version "0.12.1")
(source
(origin
(method hexpm-fetch)
(uri (hexpm-uri "rebar3_proper" version))
(sha256
(base32 "0j3a9byxbdrfinynq2xdz5mz7s4vpdlsmv7lln80lpqxswnafpfv"))))
(build-system rebar3-build-system)
(home-page "https://github.com/ferd/rebar3_proper")
(synopsis "Rebar3 PropEr plugin")
(description "This plugin allows running PropEr test suites from within
rebar3.")
(license license:bsd-3)))
(define-public erlang-rebar3-raw-deps
(package
(name "erlang-rebar3-raw-deps")
(version "2.0.0")
(source
(origin
(method hexpm-fetch)
(uri (hexpm-uri "rebar3_raw_deps" version))
(sha256
(base32 "1w8whb86yl2mpv67biqnwaam8xpm4pq8yyidifzj1svjyd37hxv7"))))
(build-system rebar3-build-system)
(home-page "https://github.com/soranoba/rebar3_raw_deps")
(synopsis "Rebar3 plugin for supporting \"raw\" dependencies")
(description "This plugin adds support for \"raw\" dependencies to
rebar3.")
(license license:expat)))
(define-public erlang-relx
(package
(name "erlang-relx")
(version "4.5.0")
(source
(origin
(method hexpm-fetch)
(uri (hexpm-uri "relx" version))
(sha256
(base32 "12fjcb5b992ixxkc7v7v55ln1i5qak7dzmzqvf6hx50l1ip3hh58"))))
(build-system rebar3-build-system)
(propagated-inputs
`(("erlang-bbmustache" ,erlang-bbmustache)
("erlang-cf" ,erlang-cf)
("erlang-erlware-commons" ,erlang-erlware-commons)
("erlang-getopt" ,erlang-getopt)
("erlang-providers" ,erlang-providers)))
(home-page "https://erlware.github.io/relx/")
(synopsis "Release assembler for Erlang/OTP Releases")
(description "Relx assembles releases for an Erlang/OTP release. Given a
release specification and a list of directories in which to search for OTP
applications it will generate a release output. That output depends heavily on
what plugins available and what options are defined, but usually it is simply
a well configured release directory.")
(license license:asl2.0)))
(define-public erlang-ssl-verify-fun
(package
(name "erlang-ssl-verify-fun")
(version "1.1.6")
(source
(origin
(method hexpm-fetch)
(uri (hexpm-uri "ssl_verify_fun" version))
(sha256
(base32 "0bwdqhnmlv0jfs5mrws2a75zngiihnvcni2hj4l65r5abnw050vx"))))
(build-system rebar3-build-system)
(home-page "https://github.com/deadtrickster/ssl_verify_fun.erl")
(synopsis "SSL verification functions for Erlang")
(description "This package provides SSL verification functions for
Erlang.")
(license license:expat)))
(define-public rebar3
(package
(name "rebar3")
(version "3.17.0")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/erlang/rebar3.git")
(commit version)))
(file-name (git-file-name name version))
(sha256
(base32 "02sk3whrbprzlih4pgcsd6ngmassfjfmkz21gwvb7mq64pib40k6"))))
(build-system gnu-build-system)
(arguments
`(#:phases
(modify-phases %standard-phases
(delete 'bootstrap)
(add-after 'unpack 'unpack-dependency-sources
(lambda* (#:key inputs #:allow-other-keys)
(for-each
(lambda (pkgname)
(let* ((src (string-append pkgname "-source"))
(input (assoc-ref inputs src))
(checkouts-dir (string-append "_checkouts/" pkgname))
(lib-dir (string-append "_build/default/lib/" pkgname)))
(mkdir-p checkouts-dir)
(invoke "tar" "-xzf" input "-C" checkouts-dir)
(mkdir-p lib-dir)
(copy-recursively checkouts-dir lib-dir)))
(list "bbmustache" "certifi" "cf" "cth_readable"
"eunit_formatters" "getopt" "hex_core" "erlware_commons"
"parse_trans" "relx" "ssl_verify_fun" "providers"))
#t))
(delete 'configure)
(replace 'build
(lambda _
(setenv "HOME" (getcwd))
(invoke "./bootstrap")))
(replace 'install
(lambda* (#:key outputs #:allow-other-keys)
(let* ((out (assoc-ref outputs "out")))
(install-file "rebar3" (string-append out "/bin")))
#t))
(delete 'check))))
(native-inputs
`(("erlang" ,erlang)))
(inputs
`(("bbmustache-source" ,(package-source erlang-bbmustache))
("certifi-source" ,(package-source erlang-certifi))
("cf-source" ,(package-source erlang-cf))
("cth_readable-source" ,(package-source erlang-cth-readable))
("erlware_commons-source" ,(package-source erlang-erlware-commons))
("eunit_formatters-source" ,(package-source erlang-eunit-formatters))
("getopt-source" ,(package-source erlang-getopt))
("hex_core-source" ,(package-source erlang-hex-core))
("parse_trans-source" ,(package-source erlang-parse-trans))
("relx-source" ,(package-source erlang-relx))
("ssl_verify_fun-source" ,(package-source erlang-ssl-verify-fun))
("providers-source" ,(package-source erlang-providers))))
(home-page "https://www.rebar3.org/")
(synopsis "Sophisticated build-tool for Erlang projects that follows OTP
principles")
(description "@code{rebar3} is an Erlang build tool that makes it easy to
compile and test Erlang applications, port drivers and releases.
@code{rebar3} is a self-contained Erlang script, so it's easy to distribute or
even embed directly in a project. Where possible, rebar uses standard
Erlang/OTP conventions for project structures, thus minimizing the amount of
build configuration work. @code{rebar3} also provides dependency management,
enabling application writers to easily re-use common libraries from a variety
of locations (git, hg, etc).")
(license license:asl2.0)))

143
guix/build-system/rebar3.scm
View File

@ -1,143 +0,0 @@
;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2016 Ricardo Wurmus <rekado@elephly.net>
;;; Copyright © 2020 Hartmut Goebel <h.goebel@crazy-compilers.com>
;;;
;;; This file is part of GNU Guix.
;;;
;;; GNU Guix is free software; you can redistribute it and/or modify it
;;; under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 3 of the License, or (at
;;; your option) any later version.
;;;
;;; GNU Guix is distributed in the hope that it will be useful, but
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>.
(define-module (guix build-system rebar3)
#:use-module (guix store)
#:use-module (guix utils)
#:use-module (guix packages)
#:use-module (guix derivations)
#:use-module (guix search-paths)
#:use-module (guix build-system)
#:use-module (guix build-system gnu)
#:use-module (ice-9 match)
#:use-module (srfi srfi-26)
#:export (%rebar3-build-system-modules
rebar3-build
rebar3-build-system))
;;
;; Standard build procedure for Erlang packages using Rebar3.
;;
(define %rebar3-build-system-modules
;; Build-side modules imported by default.
`((guix build rebar3-build-system)
,@%gnu-build-system-modules))
(define (default-rebar3)
"Return the default Rebar3 package."
;; Lazily resolve the binding to avoid a circular dependency.
(let ((erlang-mod (resolve-interface '(gnu packages erlang))))
(module-ref erlang-mod 'rebar3)))
(define (default-erlang)
"Return the default Erlang package."
;; Lazily resolve the binding to avoid a circular dependency.
(let ((erlang-mod (resolve-interface '(gnu packages erlang))))
(module-ref erlang-mod 'erlang)))
(define* (lower name
#:key source inputs native-inputs outputs system target
(rebar (default-rebar3))
(erlang (default-erlang))
#:allow-other-keys
#:rest arguments)
"Return a bag for NAME."
(define private-keywords
'(#:source #:target #:rebar #:inputs #:native-inputs))
(and (not target) ;XXX: no cross-compilation
(bag
(name name)
(system system)
(host-inputs `(,@(if source
`(("source" ,source))
'())
,@inputs))
(build-inputs `(("rebar" ,rebar)
("erlang" ,erlang) ;; for escriptize
,@native-inputs
;; Keep the standard inputs of 'gnu-build-system'.
,@(standard-packages)))
(outputs outputs)
(build rebar3-build)
(arguments (strip-keyword-arguments private-keywords arguments)))))
(define* (rebar3-build store name inputs
#:key
(tests? #t)
(test-target "eunit")
(configure-flags ''())
(make-flags ''("skip_deps=true" "-vv"))
(build-target "compile")
;; TODO: pkg-name
(phases '(@ (guix build rebar3-build-system)
%standard-phases))
(outputs '("out"))
(search-paths '())
(system (%current-system))
(guile #f)
(imported-modules %rebar3-build-system-modules)
(modules '((guix build rebar3-build-system)
(guix build utils))))
"Build SOURCE with INPUTS."
(define builder
`(begin
(use-modules ,@modules)
(rebar3-build #:name ,name
#:source ,(match (assoc-ref inputs "source")
(((? derivation? source))
(derivation->output-path source))
((source)
source)
(source
source))
#:make-flags ,make-flags
#:configure-flags ,configure-flags
#:system ,system
#:tests? ,tests?
#:test-target ,test-target
#:build-target ,build-target
#:phases ,phases
#:outputs %outputs
#:search-paths ',(map search-path-specification->sexp
search-paths)
#:inputs %build-inputs)))
(define guile-for-build
(match guile
((? package?)
(package-derivation store guile system #:graft? #f))
(#f ; the default
(let* ((distro (resolve-interface '(gnu packages commencement)))
(guile (module-ref distro 'guile-final)))
(package-derivation store guile system #:graft? #f)))))
(build-expression->derivation store name builder
#:inputs inputs
#:system system
#:modules imported-modules
#:outputs outputs
#:guile-for-build guile-for-build))
(define rebar3-build-system
(build-system
(name 'rebar3)
(description "The standard Rebar3 build system")
(lower lower)))

150
guix/build/rebar3-build-system.scm
View File

@ -1,150 +0,0 @@
;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2016, 2018 Ricardo Wurmus <rekado@elephly.net>
;;; Copyright © 2019 Björn Höfling <bjoern.hoefling@bjoernhoefling.de>
;;; Copyright © 2020 Hartmut Goebel <h.goebel@crazy-compilers.com>
;;;
;;; This file is part of GNU Guix.
;;;
;;; GNU Guix is free software; you can redistribute it and/or modify it
;;; under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 3 of the License, or (at
;;; your option) any later version.
;;;
;;; GNU Guix is distributed in the hope that it will be useful, but
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>.
(define-module (guix build rebar3-build-system)
#:use-module ((guix build gnu-build-system) #:prefix gnu:)
#:use-module ((guix build utils) #:hide (delete))
#:use-module (ice-9 match)
#:use-module (ice-9 ftw)
#:use-module (srfi srfi-1)
#:use-module (srfi srfi-26)
#:export (%standard-phases
rebar3-build))
;;
;; Builder-side code of the standard build procedure for Erlang packages using
;; rebar3.
;;
;; TODO: Think about whether bindir ("ebin"), libdir ("priv") and includedir
;; "(include") need to be configurable
(define %erlang-libdir "/lib/erlang/lib")
(define* (erlang-depends #:key inputs #:allow-other-keys)
(define input-directories
(match inputs
(((_ . dir) ...)
dir)))
(mkdir-p "_checkouts")
(for-each
(lambda (input-dir)
(let ((elibdir (string-append input-dir %erlang-libdir)))
(when (directory-exists? elibdir)
(for-each
(lambda (dirname)
(symlink (string-append elibdir "/" dirname)
(string-append "_checkouts/" dirname)))
(list-directories elibdir)))))
input-directories)
#t)
(define* (unpack #:key source #:allow-other-keys)
"Unpack SOURCE in the working directory, and change directory within the
source. When SOURCE is a directory, copy it in a sub-directory of the current
working directory."
;; archives from hexpm typicalls do not contain a directory level
;; TODO: Check if archive contains a directory level
(mkdir "source")
(chdir "source")
(if (file-is-directory? source)
(begin
;; Preserve timestamps (set to the Epoch) on the copied tree so that
;; things work deterministically.
(copy-recursively source "."
#:keep-mtime? #t))
(begin
(if (string-suffix? ".zip" source)
(invoke "unzip" source)
(invoke "tar" "xvf" source))))
#t)
(define* (build #:key (make-flags '()) (build-target "compile")
#:allow-other-keys)
(apply invoke `("rebar3" ,build-target ,@make-flags)))
(define* (check #:key target (make-flags '()) (tests? (not target))
(test-target "eunit")
#:allow-other-keys)
(if tests?
(apply invoke `("rebar3" ,test-target ,@make-flags))
(format #t "test suite not run~%"))
#t)
(define (erlang-package? name)
"Check if NAME correspond to the name of an Erlang package."
(string-prefix? "erlang-" name))
(define (package-name-version->erlang-name name+ver)
"Convert the Guix package NAME-VER to the corresponding Erlang name-version
format. Essentially drop the prefix used in Guix and replace dashes by
underscores."
(let* ((name- (package-name->name+version name+ver)))
(string-join
(string-split
(if (erlang-package? name-) ; checks for "erlang-" prefix
(string-drop name- (string-length "erlang-"))
name-)
#\-)
"_")))
(define (list-directories directory)
"Return file names of the sub-directory of DIRECTORY."
(scandir directory
(lambda (file)
(and (not (member file '("." "..")))
(file-is-directory? (string-append directory "/" file))))))
(define* (install #:key name outputs
(pkg-name (package-name-version->erlang-name name))
#:allow-other-keys)
(let* ((out (assoc-ref outputs "out"))
(build-dir "_build/default/lib")
(pkg-dir (string-append out %erlang-libdir "/" pkg-name)))
(for-each
(lambda (pkg)
(for-each
(lambda (dirname)
(let ((src-dir (string-append build-dir "/" pkg "/" dirname))
(dst-dir (string-append pkg-dir "/" dirname)))
(when (file-exists? src-dir)
(copy-recursively src-dir dst-dir #:follow-symlinks? #t))
(false-if-exception
(delete-file (string-append dst-dir "/.gitignore")))))
'("ebin" "include" "priv")))
(list-directories build-dir))
(false-if-exception
(delete-file (string-append pkg-dir "/priv/Run-eunit-loop.expect")))
#t))
(define %standard-phases
(modify-phases gnu:%standard-phases
(replace 'unpack unpack)
(delete 'bootstrap)
(delete 'configure)
(add-before 'build 'erlang-depends erlang-depends)
(replace 'build build)
(replace 'check check)
(replace 'install install)))
(define* (rebar3-build #:key inputs (phases %standard-phases)
#:allow-other-keys #:rest args)
"Build the given Erlang package, applying all of PHASES in order."
(apply gnu:gnu-build #:inputs inputs #:phases phases args))

76
guix/hexpm-download.scm
View File

@ -1,76 +0,0 @@
;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2014, 2015, 2016, 2017, 2018, 2019 Ludovic Courtès <ludo@gnu.org>
;;; Copyright © 2017 Mathieu Lirzin <mthl@gnu.org>
;;; Copyright © 2017 Christopher Baines <mail@cbaines.net>
;;; Copyright © 2020 Jakub Kądziołka <kuba@kadziolka.net>
;;; Copyright © 2020 Hartmut Goebel <h.goebel@crazy-compilers.com>
;;;
;;; This file is part of GNU Guix.
;;;
;;; GNU Guix is free software; you can redistribute it and/or modify it
;;; under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 3 of the License, or (at
;;; your option) any later version.
;;;
;;; GNU Guix is distributed in the hope that it will be useful, but
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>.
(define-module (guix hexpm-download)
#:use-module (ice-9 match)
#:use-module (guix extracting-download)
#:use-module (guix packages) ;; for %current-system
#:use-module (srfi srfi-26)
#:export (hexpm-fetch
%hexpm-repo-url
hexpm-url
hexpm-url?
hexpm-uri))
;;;
;;; An <origin> method that fetches a package from the hex.pm repository,
;;; unwrapping the actual content from the download tarball.
;;;
;; URL and paths from
;; https://github.com/hexpm/specifications/blob/master/endpoints.md
(define %hexpm-repo-url
(make-parameter "https://repo.hex.pm"))
(define hexpm-url
(string-append (%hexpm-repo-url) "/tarballs/"))
(define hexpm-url?
(cut string-prefix? hexpm-url <>))
(define (hexpm-uri name version)
"Return a URI string for the package hosted at hex.pm corresponding to NAME
and VERSION."
(string-append hexpm-url name "-" version ".tar"))
(define* (hexpm-fetch url hash-algo hash
#:optional name
#:key
(filename-to-extract "contents.tar.gz")
(system (%current-system))
(guile (default-guile)))
"Return a fixed-output derivation that fetches URL and extracts
\"contents.tar.gz\". The output is expected to have hash HASH of type
HASH-ALGO (a symbol). By default, the file name is the base name of URL;
optionally, NAME can specify a different file name. By default, the file name
is the base name of URL with \".gz\" appended; optionally, NAME can specify a
different file name."
(define file-name
(match url
((head _ ...)
(basename head))
(_
(basename url))))
(http-fetch/extract url "contents.tar.gz" hash-algo hash
;; urls typically end with .tar, but contents is .tar.gz
(or name (string-append file-name ".gz"))
#:system system #:guile guile))

290
guix/import/hexpm.scm
View File

@ -1,290 +0,0 @@
;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2015 Cyril Roelandt <tipecaml@gmail.com>
;;; Copyright © 2016 David Craven <david@craven.ch>
;;; Copyright © 2017, 2019, 2020 Ludovic Courtès <ludo@gnu.org>
;;; Copyright © 2019 Martin Becze <mjbecze@riseup.net>
;;; Copyright © 2020, 2021 Hartmut Goebel <h.goebel@crazy-compilers.com>
;;;
;;; This file is part of GNU Guix.
;;;
;;; GNU Guix is free software; you can redistribute it and/or modify it
;;; under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 3 of the License, or (at
;;; your option) any later version.
;;;
;;; GNU Guix is distributed in the hope that it will be useful, but
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>.
(define-module (guix import hexpm)
#:use-module (guix base32)
#:use-module ((guix download) #:prefix download:)
#:use-module (guix hexpm-download)
#:use-module (gcrypt hash)
#:use-module (guix http-client)
#:use-module (json)
#:use-module (guix import utils)
#:use-module ((guix import json) #:select (json-fetch))
#:use-module ((guix build utils)
#:select ((package-name->name+version
. hyphen-package-name->name+version)
dump-port))
#:use-module ((guix licenses) #:prefix license:)
#:use-module (guix monads)
#:use-module (guix packages)
#:use-module (guix upstream)
#:use-module (guix utils)
#:use-module (ice-9 match)
#:use-module (ice-9 regex)
#:use-module (ice-9 popen)
#:use-module (srfi srfi-1)
#:use-module (srfi srfi-2)
#:use-module (srfi srfi-26)
#:export (hexpm->guix-package
guix-package->hexpm-name
strings->licenses
hexpm-recursive-import
%hexpm-updater))
;;;
;;; Interface to https://hex.pm/api, version 2.
;;; https://github.com/hexpm/specifications/blob/master/apiary.apib
;;; https://github.com/hexpm/specifications/blob/master/endpoints.md
;;;
(define %hexpm-api-url
(make-parameter "https://hex.pm/api"))
(define (package-url name)
(string-append (%hexpm-api-url) "/packages/" name))
;; Hexpm Package. /api/packages/${name}
;; It can have several "releases", each of which has its own set of
;; requirements, buildtool, etc. - see <hexpm-release> below.
(define-json-mapping <hexpm-pkgdef> make-hexpm-pkgdef hexpm-pkgdef?
json->hexpm
(name hexpm-name) ;string
(html-url hexpm-html-url "html_url") ;string
(docs-html-url hexpm-docs-html-url "docs_html_url") ;string | #nil
(meta hexpm-meta "meta" json->hexpm-meta)
(versions hexpm-versions "releases" ;list of <hexpm-version>
(lambda (vector)
(map json->hexpm-version
(vector->list vector)))))
;; Hexpm meta.
(define-json-mapping <hexpm-meta> make-hexpm-meta hexpm-meta?
json->hexpm-meta
(description hexpm-meta-description) ;string
(licenses hexpm-meta-licenses "licenses" ;list of strings
(lambda (vector)
(or (and vector (vector->list vector))
#f))))
;; Hexpm version.
(define-json-mapping <hexpm-version> make-hexpm-version hexpm-version?
json->hexpm-version
(number hexpm-version-number "version") ;string
(url hexpm-version-url)) ;string
(define (lookup-hexpm name)
"Look up NAME on https://hex.pm and return the corresopnding <hexpm>
record or #f if it was not found."
(let ((json (json-fetch (package-url name))))
(and json
(json->hexpm json))))
;; Hexpm release. /api/packages/${name}/releases/${version}
(define-json-mapping <hexpm-release> make-hexpm-release hexpm-release?
json->hexpm-release
(number hexpm-release-number "version") ;string
(url hexpm-release-url) ;string
(requirements hexpm-requirements "requirements")) ;list of <hexpm-dependency>
;; meta:build_tools -> alist
;; Hexpm dependency. Each dependency (each edge in the graph) is annotated as
;; being a "normal" dependency or a development dependency. There also
;; information about the minimum required version, such as "^0.0.41".
(define-json-mapping <hexpm-dependency> make-hexpm-dependency
hexpm-dependency?
json->hexpm-dependency
(app hexpm-dependency-app "app") ;string
(optional hexpm-dependency-optional) ;bool
(requirement hexpm-dependency-requirement)) ;string
(define (hexpm-release-dependencies release)
"Return the list of dependency names of RELEASE, a <hexpm-release>."
(let ((reqs (or (hexpm-requirements release) '#())))
(map first reqs))) ;; TODO: also return required version
(define (lookup-hexpm-release version*)
"Look up RELEASE on hexpm-version-url and return the corresopnding
<hexpm-release> record or #f if it was not found."
(let* ((url (hexpm-version-url version*))
(json (json-fetch url)))
(json->hexpm-release json)))
;;;
;;; Converting hex.pm packages to Guix packages.
;;;
(define* (make-hexpm-sexp #:key name version tarball-url
home-page synopsis description license
#:allow-other-keys)
"Return the `package' s-expression for a rust package with the given NAME,
VERSION, tarball-url, HOME-PAGE, SYNOPSIS, DESCRIPTION, and LICENSE."
(call-with-temporary-directory
(lambda (directory)
(let ((port (http-fetch tarball-url))
(tar (open-pipe* OPEN_WRITE "tar" "-C" directory
"-xf" "-" "contents.tar.gz")))
(dump-port port tar)
(close-port port)
(let ((status (close-pipe tar)))
(unless (zero? status)
(error "tar extraction failure" status))))
(let ((guix-name (hexpm-name->package-name name))
(sha256 (bytevector->nix-base32-string
(call-with-input-file
(string-append directory "/contents.tar.gz")
port-sha256))))
`(package
(name ,guix-name)
(version ,version)
(source (origin
(method hexpm-fetch)
(uri (hexpm-uri ,name version))
(sha256 (base32 ,sha256))))
(build-system ,'rebar3-build-system)
(home-page ,(match home-page
(() "")
(_ home-page)))
(synopsis ,synopsis)
(description ,(beautify-description description))
(license ,(match license
(() #f)
((license) license)
(_ `(list ,@license)))))))))
(define (strings->licenses strings)
(filter-map (lambda (license)
(and (not (string-null? license))
(not (any (lambda (elem) (string=? elem license))
'("AND" "OR" "WITH")))
(or (spdx-string->license license)
license)))
strings))
(define (hexpm-latest-version package)
(let ((versions (map hexpm-version-number (hexpm-versions package))))
(fold (lambda (a b)
(if (version>? a b) a b)) (car versions) versions)))
(define* (hexpm->guix-package package-name #:key repo version)
"Fetch the metadata for PACKAGE-NAME from hexpms.io, and return the
`package' s-expression corresponding to that package, or #f on failure.
When VERSION is specified, attempt to fetch that version; otherwise fetch the
latest version of PACKAGE-NAME."
(define package
(lookup-hexpm package-name))
(define version-number
(and package
(or version
(hexpm-latest-version package))))
(define version*
(and package
(find (lambda (version)
(string=? (hexpm-version-number version)
version-number))
(hexpm-versions package))))
(define release
(and package version*
(lookup-hexpm-release version*)))
(and package version*
(let ((dependencies (hexpm-release-dependencies release))
(pkg-meta (hexpm-meta package)))
(values
(make-hexpm-sexp
#:name package-name
#:version version-number
#:home-page (or (hexpm-docs-html-url package)
;; TODO: Homepage?
(hexpm-html-url package))
#:synopsis (hexpm-meta-description pkg-meta)
#:description (hexpm-meta-description pkg-meta)
#:license (or (and=> (hexpm-meta-licenses pkg-meta)
strings->licenses))
#:tarball-url (hexpm-uri package-name version-number))
dependencies))))
(define* (hexpm-recursive-import pkg-name #:optional version)
(recursive-import pkg-name
#:version version
#:repo->guix-package hexpm->guix-package
#:guix-name hexpm-name->package-name))
(define (guix-package->hexpm-name package)
"Return the hex.pm name of PACKAGE."
(define (url->hexpm-name url)
(hyphen-package-name->name+version
(basename (file-sans-extension url))))
(match (and=> (package-source package) origin-uri)
((? string? url)
(url->hexpm-name url))
((lst ...)
(any url->hexpm-name lst))
(#f #f)))
(define (hexpm-name->package-name name)
(string-append "erlang-" (string-join (string-split name #\_) "-")))
;;;
;;; Updater
;;;
(define (hexpm-package? package)
"Return true if PACKAGE is a package from hex.pm."
(let ((source-url (and=> (package-source package) origin-uri))
(fetch-method (and=> (package-source package) origin-method)))
(and (eq? fetch-method hexpm-fetch)
(match source-url
((? string?)
(hexpm-url? source-url))
((source-url ...)
(any hexpm-url? source-url))))))
(define (latest-release package)
"Return an <upstream-source> for the latest release of PACKAGE."
(let* ((hexpm-name (guix-package->hexpm-name package))
(hexpm (lookup-hexpm hexpm-name))
(version (hexpm-latest-version hexpm))
(url (hexpm-uri hexpm-name version)))
(upstream-source
(package (package-name package))
(version version)
(urls (list url)))))
(define %hexpm-updater
(upstream-updater
(name 'hexpm)
(description "Updater for hex.pm packages")
(pred hexpm-package?)
(latest latest-release)))

1
guix/import/utils.scm
View File

@ -359,7 +359,6 @@ the expected fields of an <origin> object."
("git-fetch" (@ (guix git-download) git-fetch))
("svn-fetch" (@ (guix svn-download) svn-fetch))
("hg-fetch" (@ (guix hg-download) hg-fetch))
("hexpm-fetch" (@ (guix hexpm-download) hexpm-fetch))
(_ #f)))
(uri (assoc-ref orig "uri"))
(sha256 sha))))))

2
guix/scripts/import.scm
View File

@ -79,7 +79,7 @@ rather than \\n."
;;;
(define importers '("gnu" "pypi" "cpan" "hackage" "stackage" "egg" "elpa"
"gem" "go" "cran" "crate" "texlive" "json" "opam" "hexpm"
"gem" "go" "cran" "crate" "texlive" "json" "opam"
"minetest"))
(define (resolve-importer name)

114
guix/scripts/import/hexpm.scm
View File

@ -1,114 +0,0 @@
;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2014 David Thompson <davet@gnu.org>
;;; Copyright © 2016 David Craven <david@craven.ch>
;;; Copyright © 2019 Martin Becze <mjbecze@riseup.net>
;;; Copyright © 2020 Hartmut Goebel <h.goebel@crazy-compilers.com>
;;;
;;; This file is part of GNU Guix.
;;;
;;; GNU Guix is free software; you can redistribute it and/or modify it
;;; under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 3 of the License, or (at
;;; your option) any later version.
;;;
;;; GNU Guix is distributed in the hope that it will be useful, but
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>.
(define-module (guix scripts import hexpm)
#:use-module (guix ui)
#:use-module (guix utils)
#:use-module (guix scripts)
#:use-module (guix import hexpm)
#:use-module (guix scripts import)
#:use-module (srfi srfi-1)
#:use-module (srfi srfi-11)
#:use-module (srfi srfi-37)
#:use-module (ice-9 match)
#:use-module (ice-9 format)
#:export (guix-import-hexpm))
;;;
;;; Command-line options.
;;;
(define %default-options
'())
(define (show-help)
(display (G_ "Usage: guix import hexpm PACKAGE-NAME
Import and convert the hex.pm package for PACKAGE-NAME.\n"))
(display (G_ "
-r, --recursive import packages recursively"))
(newline)
(display (G_ "
-h, --help display this help and exit"))
(display (G_ "
-V, --version display version information and exit"))
(newline)
(show-bug-report-information))
(define %options
;; Specification of the command-line options.
(cons* (option '(#\h "help") #f #f
(lambda args
(show-help)
(exit 0)))
(option '(#\V "version") #f #f
(lambda args
(show-version-and-exit "guix import hexpm")))
(option '(#\r "recursive") #f #f
(lambda (opt name arg result)
(alist-cons 'recursive #t result)))
%standard-import-options))
;;;
;;; Entry point.
;;;
(define (guix-import-hexpm . args)
(define (parse-options)
;; Return the alist of option values.
(args-fold* args %options
(lambda (opt name arg result)
(leave (G_ "~A: unrecognized option~%") name))
(lambda (arg result)
(alist-cons 'argument arg result))
%default-options))
(let* ((opts (parse-options))
(args (filter-map (match-lambda
(('argument . value)
value)
(_ #f))
(reverse opts))))
(match args
((spec)
(define-values (name version)
(package-name->name+version spec))
(if (assoc-ref opts 'recursive)
(map (match-lambda
((and ('package ('name name) . rest) pkg)
`(define-public ,(string->symbol name)
,pkg))
(_ #f))
(hexpm-recursive-import name version))
(let ((sexp (hexpm->guix-package name #:version version)))
(unless sexp
(leave (G_ "failed to download meta-data for package '~a'~%")
(if version
(string-append name "@" version)
name)))
sexp)))
(()
(leave (G_ "too few arguments~%")))
((many ...)
(leave (G_ "too many arguments~%"))))))

20
guix/upstream.scm
View File

@ -24,10 +24,6 @@
#:use-module (guix discovery)
#:use-module ((guix download)
#:select (download-to-store url-fetch))
#:use-module ((guix hexpm-download)
#:select (hexpm-fetch))
#:use-module ((guix extracting-download)
#:select (download-to-store/extract))
#:use-module (guix gnupg)
#:use-module (guix packages)
#:use-module (guix diagnostics)
@ -434,23 +430,9 @@ SOURCE, an <upstream-source>."
#:key-download key-download)))
(values version tarball source))))))
(define* (package-update/hexpm-fetch store package source
#:key key-download)
"Return the version, tarball, and SOURCE, to update PACKAGE to
SOURCE, an <upstream-source>."
(match source
(($ <upstream-source> _ version urls signature-urls)
(let* ((url (first urls))
(name (or (origin-file-name (package-source package))
(string-append (basename url) ".gz")))
(tarball (download-to-store/extract
store url "contents.tar.gz" name)))
(values version tarball source)))))
(define %method-updates
;; Mapping of origin methods to source update procedures.
`((,url-fetch . ,package-update/url-fetch)
(,hexpm-fetch . ,package-update/hexpm-fetch)))
`((,url-fetch . ,package-update/url-fetch)))
(define* (package-update store package
#:optional (updaters (force %updaters))