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

build-system: Add 'rebar3-build-system'. 

* guix/build-system/rebar3.scm, guix/build/rebar3-build-system.scm: New files.
* Makefile.am (MODULES): Add them.
This commit is contained in:
Hartmut Goebel 2020-05-28 22:15:32 +02:00
parent d780d0a2bb
commit 1660253c3c
No known key found for this signature in database
GPG Key ID: 634A8DFFD3F631DF
3 changed files with 295 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile.am
View File

@ -163,6 +163,7 @@ 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 \
@ -216,6 +217,7 @@ 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 \

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

@ -0,0 +1,143 @@
;;; 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 Normal file
View File

@ -0,0 +1,150 @@
;;; 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))