nixo
/
guix-devel
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

import: Add 'cran' importer. 

* guix/import/cran.scm: New file.
* guix/scripts/import.scm: Add "cran" to 'importers'.
* guix/scripts/import/cran.scm: New file.
* tests/cran.scm: New file.
* Makefile.am (MODULES): Add 'guix/import/cran.scm' and
  'guix/scripts/import/cran.scm'.
  (SCM_TESTS): Add 'tests/cran.scm'.
* doc/guix.texi (Invoking guix import): Document it.
* po/guix/POTFILES.in: Add 'guix/scripts/import/cran.scm'.
This commit is contained in:
Ricardo Wurmus 2015-07-24 16:49:57 +02:00
parent 9a479bc383
commit e1248602f9
6 changed files with 477 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Makefile.am
View File

@ -97,6 +97,7 @@ MODULES = \
guix/import/gnu.scm \
guix/import/snix.scm \
guix/import/cabal.scm \
guix/import/cran.scm \
guix/import/hackage.scm \
guix/import/elpa.scm \
guix/scripts/download.scm \
@ -112,6 +113,7 @@ MODULES = \
guix/scripts/refresh.scm \
guix/scripts/system.scm \
guix/scripts/lint.scm \
guix/scripts/import/cran.scm \
guix/scripts/import/gnu.scm \
guix/scripts/import/nix.scm \
guix/scripts/import/hackage.scm \
@ -198,6 +200,7 @@ SCM_TESTS = \
tests/packages.scm \
tests/snix.scm \
tests/hackage.scm \
tests/cran.scm \
tests/elpa.scm \
tests/store.scm \
tests/monads.scm \

15
doc/guix.texi
View File

@ -3939,6 +3939,21 @@ Perl module:
guix import cpan Acme::Boolean
@end example
@item cran
@cindex CRAN
Import meta-data from @uref{http://cran.r-project.org/, CRAN}, the
central repository for the @uref{http://r-project.org, GNU@tie{}R
statistical and graphical environment}.
Information is extracted from the HTML package description.
The command command below imports meta-data for the @code{Cairo}
R package:
@example
guix import cran Cairo
@end example
@item nix
Import meta-data from a local copy of the source of the
@uref{http://nixos.org/nixpkgs/, Nixpkgs distribution}@footnote{This

188
guix/import/cran.scm Normal file
View File

@ -0,0 +1,188 @@
;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2015 Ricardo Wurmus <rekado@elephly.net>
;;;
;;; 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 cran)
#:use-module (ice-9 match)
#:use-module (ice-9 regex)
#:use-module (srfi srfi-1)
#:use-module (sxml simple)
#:use-module (sxml match)
#:use-module (sxml xpath)
#:use-module (guix http-client)
#:use-module (guix hash)
#:use-module (guix store)
#:use-module (guix base32)
#:use-module ((guix download) #:select (download-to-store))
#:use-module (guix import utils)
#:export (cran->guix-package))
;;; Commentary:
;;;
;;; Generate a package declaration template for the latest version of an R
;;; package on CRAN, using the HTML description downloaded from
;;; cran.r-project.org.
;;;
;;; Code:
(define string->license
(match-lambda
("AGPL-3" 'agpl3+)
("Artistic-2.0" 'artistic2.0)
("Apache License 2.0" 'asl2.0)
("BSD_2_clause" 'bsd-2)
("BSD_3_clause" 'bsd-3)
("GPL-2" 'gpl2+)
("GPL-3" 'gpl3+)
("LGPL-2" 'lgpl2.0+)
("LGPL-2.1" 'lgpl2.1+)
("LGPL-3" 'lgpl3+)
("MIT" 'x11)
((x) (string->license x))
((lst ...) `(list ,@(map string->license lst)))
(_ #f)))
(define (format-inputs names)
"Generate a sorted list of package inputs from a list of package NAMES."
(map (lambda (name)
(list name (list 'unquote (string->symbol name))))
(sort names string-ci<?)))
(define* (maybe-inputs package-inputs #:optional (type 'inputs))
"Given a list of PACKAGE-INPUTS, tries to generate the TYPE field of a
package definition."
(match package-inputs
(()
'())
((package-inputs ...)
`((,type (,'quasiquote ,(format-inputs package-inputs)))))))
(define (table-datum tree label)
"Extract the datum node following a LABEL in the sxml table TREE. Only the
first cell of a table row is considered a label cell."
((node-pos 1)
((sxpath `(xhtml:tr
(xhtml:td 1) ; only first cell can contain label
(equal? ,label)
,(node-parent tree) ; go up to label cell
,(node-parent tree) ; go up to matching row
(xhtml:td 2))) ; select second cell
tree)))
(define %cran-url "http://cran.r-project.org/web/packages/")
(define (cran-fetch name)
"Return an sxml representation of the CRAN page for the R package NAME,
or #f on failure. NAME is case-sensitive."
;; This API always returns the latest release of the module.
(let ((cran-url (string-append %cran-url name)))
(false-if-exception
(xml->sxml (http-fetch cran-url)
#:trim-whitespace? #t
#:namespaces '((xhtml . "http://www.w3.org/1999/xhtml"))
#:default-entity-handler
(lambda (port name)
(case name
((nbsp) " ")
((ge) ">=")
((gt) ">")
((lt) "<")
(else
(format (current-warning-port)
"~a:~a:~a: undefined entitity: ~a\n"
cran-url (port-line port) (port-column port)
name)
(symbol->string name))))))))
(define (cran-sxml->sexp sxml)
"Return the `package' s-expression for a CRAN package from the SXML
representation of the package page."
(define (nodes->text nodeset)
(string-join ((sxpath '(// *text*)) nodeset) " "))
(define (guix-name name)
(if (string-prefix? "r-" name)
(string-downcase name)
(string-append "r-" (string-downcase name))))
(sxml-match-let*
(((*TOP* (xhtml:html
,head
(xhtml:body
(xhtml:h2 ,name-and-synopsis)
(xhtml:p ,description)
,summary
(xhtml:h4 "Downloads:") ,downloads
. ,rest)))
sxml))
(let* ((name (match:prefix (string-match ": " name-and-synopsis)))
(synopsis (match:suffix (string-match ": " name-and-synopsis)))
(version (nodes->text (table-datum summary "Version:")))
(license ((compose string->license nodes->text)
(table-datum summary "License:")))
(home-page (nodes->text ((sxpath '((xhtml:a 1)))
(table-datum summary "URL:"))))
(source-url (string-append "mirror://cran/"
;; Remove double dots, because we want an
;; absolute path.
(regexp-substitute/global
#f "\\.\\./"
(string-join
((sxpath '((xhtml:a 1) @ href *text*))
(table-datum downloads
" Package source: ")))
'pre 'post)))
(tarball (with-store store (download-to-store store source-url)))
(sysdepends (map match:substring
(list-matches
"[^ ]+"
;; Strip off comma and parenthetical
;; expressions.
(regexp-substitute/global
#f "(,|\\([^\\)]+\\))"
(nodes->text (table-datum summary
"SystemRequirements:"))
'pre 'post))))
(imports (map guix-name
((sxpath '(// xhtml:a *text*))
(table-datum summary "Imports:")))))
`(package
(name ,(guix-name name))
(version ,version)
(source (origin
(method url-fetch)
(uri (string-append ,@(factorize-uri source-url version)))
(sha256
(base32
,(bytevector->nix-base32-string (file-sha256 tarball))))))
(build-system r-build-system)
,@(maybe-inputs sysdepends)
,@(maybe-inputs imports 'propagated-inputs)
(home-page ,(if (string-null? home-page)
(string-append %cran-url name)
home-page))
(synopsis ,synopsis)
;; Use double spacing
(description ,(regexp-substitute/global #f "\\. \\b" description
'pre ". " 'post))
(license ,license)))))
(define (cran->guix-package package-name)
"Fetch the metadata for PACKAGE-NAME from cran.r-project.org, and return the
`package' s-expression corresponding to that package, or #f on failure."
(let ((module-meta (cran-fetch package-name)))
(and=> module-meta cran-sxml->sexp)))

2
guix/scripts/import.scm
View File

@ -73,7 +73,7 @@ rather than \\n."
;;; Entry point.
;;;
(define importers '("gnu" "nix" "pypi" "cpan" "hackage" "elpa" "gem"))
(define importers '("gnu" "nix" "pypi" "cpan" "hackage" "elpa" "gem" "cran"))
(define (resolve-importer name)
(let ((module (resolve-interface

92
guix/scripts/import/cran.scm Normal file
View File

@ -0,0 +1,92 @@
;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2014 Eric Bavier <bavier@member.fsf.org>
;;; Copyright © 2015 Ricardo Wurmus <rekado@elephly.net>
;;;
;;; 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 cran)
#:use-module (guix ui)
#:use-module (guix utils)
#:use-module (guix import cran)
#: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-cran))
;;;
;;; Command-line options.
;;;
(define %default-options
'())
(define (show-help)
(display (_ "Usage: guix import cran PACKAGE-NAME
Import and convert the CRAN package for PACKAGE-NAME.\n"))
(display (_ "
-h, --help display this help and exit"))
(display (_ "
-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 cran")))
%standard-import-options))
;;;
;;; Entry point.
;;;
(define (guix-import-cran . args)
(define (parse-options)
;; Return the alist of option values.
(args-fold* args %options
(lambda (opt name arg result)
(leave (_ "~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
((package-name)
(let ((sexp (cran->guix-package package-name)))
(unless sexp
(leave (_ "failed to download description for package '~a'~%")
package-name))
sexp))
(()
(leave (_ "too few arguments~%")))
((many ...)
(leave (_ "too many arguments~%"))))))

178
tests/cran.scm Normal file
View File

@ -0,0 +1,178 @@
;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2015 Ricardo Wurmus <rekado@elephly.net>
;;;
;;; 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 (test-cran)
#:use-module (guix import cran)
#:use-module (guix tests)
#:use-module (srfi srfi-64)
#:use-module (ice-9 match))
(define sxml
'(*TOP* (xhtml:html
(xhtml:head
(xhtml:title "CRAN - Package my-example-sxml"))
(xhtml:body
(xhtml:h2 "my-example-sxml: Short description")
(xhtml:p "Long description")
(xhtml:table
(@ (summary "Package my-example-sxml summary"))
(xhtml:tr
(xhtml:td "Version:")
(xhtml:td "1.2.3"))
(xhtml:tr
(xhtml:td "Depends:")
(xhtml:td "R (>= 3.1.0)"))
(xhtml:tr
(xhtml:td "SystemRequirements:")
(xhtml:td "cairo (>= 1.2 http://www.cairographics.org/)"))
(xhtml:tr
(xhtml:td "Imports:")
(xhtml:td
(xhtml:a (@ (href "../scales/index.html"))
"scales")
" (>= 0.2.3), "
(xhtml:a (@ (href "../proto/index.html"))
"proto")
", "
(xhtml:a (@ (href "../Rcpp/index.html")) "Rcpp")
" (>= 0.11.0)"))
(xhtml:tr
(xhtml:td "Suggests:")
(xhtml:td
(xhtml:a (@ (href "../some/index.html"))
"some")
", "
(xhtml:a (@ (href "../suggestions/index.html"))
"suggestions")))
(xhtml:tr
(xhtml:td "License:")
(xhtml:td
(xhtml:a (@ (href "../../licenses/MIT")) "MIT")))
(xhtml:tr
(xhtml:td "URL:")
(xhtml:td
(xhtml:a (@ (href "http://gnu.org/s/my-example-sxml"))
"http://gnu.org/s/my-example-sxml")
", "
(xhtml:a (@ (href "http://alternative/home/page"))
"http://alternative/home/page"))))
(xhtml:h4 "Downloads:")
(xhtml:table
(@ (summary "Package my-example-sxml downloads"))
(xhtml:tr
(xhtml:td " Reference manual: ")
(xhtml:td
(xhtml:a (@ (href "my-example-sxml.pdf"))
" my-example-sxml.pdf ")))
(xhtml:tr
(xhtml:td " Package source: ")
(xhtml:td
(xhtml:a
(@ (href "../../../src/contrib/my-example-sxml_1.2.3.tar.gz"))
" my-example-sxml_1.2.3.tar.gz "))))
(xhtml:h4 "Reverse dependencies:")
(xhtml:table
(@ (summary "Package my-example-sxml reverse dependencies"))
(xhtml:tr
(xhtml:td "Reverse depends:")
(xhtml:td "Too many."))
(xhtml:tr
(xhtml:td "Reverse imports:")
(xhtml:td "Likewise."))
(xhtml:tr
(xhtml:td "Reverse suggests:")
(xhtml:td "Uncountable.")))))))
(define simple-table
'(xhtml:table
(xhtml:tr
(xhtml:td "Numbers")
(xhtml:td "123"))
(xhtml:tr
(@ (class "whatever"))
(xhtml:td (@ (class "unimportant")) "Letters")
(xhtml:td "abc"))
(xhtml:tr
(xhtml:td "Letters")
(xhtml:td "xyz"))
(xhtml:tr
(xhtml:td "Single"))
(xhtml:tr
(xhtml:td "not a value")
(xhtml:td "not a label")
(xhtml:td "also not a label"))))
(test-begin "cran")
(test-equal "table-datum: return list of first table cell matching label"
'((xhtml:td "abc"))
((@@ (guix import cran) table-datum) simple-table "Letters"))
(test-equal "table-datum: return empty list if no match"
'()
((@@ (guix import cran) table-datum) simple-table "Astronauts"))
(test-equal "table-datum: only consider the first cell as a label cell"
'()
((@@ (guix import cran) table-datum) simple-table "not a label"))
(test-assert "cran-sxml->sexp"
;; Replace network resources with sample data.
(mock ((guix build download) url-fetch
(lambda* (url file-name #:key (mirrors '()))
(with-output-to-file file-name
(lambda ()
(display
(match url
("mirror://cran/src/contrib/my-example-sxml_1.2.3.tar.gz"
"source")
(_ (error "Unexpected URL: " url))))))))
(match ((@@ (guix import cran) cran-sxml->sexp) sxml)
(('package
('name "r-my-example-sxml")
('version "1.2.3")
('source ('origin
('method 'url-fetch)
('uri ('string-append "mirror://cran/src/contrib/my-example-sxml_"
'version ".tar.gz"))
('sha256
('base32
(? string? hash)))))
('build-system 'r-build-system)
('inputs
('quasiquote
(("cairo" ('unquote 'cairo)))))
('propagated-inputs
('quasiquote
(("r-proto" ('unquote 'r-proto))
("r-rcpp" ('unquote 'r-rcpp))
("r-scales" ('unquote 'r-scales)))))
('home-page "http://gnu.org/s/my-example-sxml")
('synopsis "Short description")
('description "Long description")
('license 'x11)))
(x
(begin
(format #t "~s\n" x)
(pk 'fail x #f))))))
(test-end "cran")
(exit (= (test-runner-fail-count (test-runner-current)) 0))