ryan77627/guix
1
0
Fork 0
mirror of https://git.in.rschanz.org/ryan77627/guix.git synced 2024-11-07 07:26:13 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

guix: import: Add composer importer.

Browse source 
* guix/import/composer.scm: New file.
* guix/scripts/import/composer.scm: New file.
* guix/tests/composer.scm: New file.
* Makefile.am: Add them.
* guix/scripts/import.scm: Add composer importer.
* doc/guix.texi (Invoking guix import): Mention it.

Change-Id: I44a89b8cc80ef5b4a3cd15e8fbba4a18c1cea0b1

Co-authored-by: Julien Lepiller <julien@lepiller.eu>
Co-authored-by: Ludovic Courtès <ludo@gnu.org>
This commit is contained in:
Nicolas Graves 2023-11-02 16:16:48 +01:00 committed by Ludovic Courtès
parent 32d4f40589
commit b7e3945283
No known key found for this signature in database
GPG key ID: 090B11993D9AEBB5
6 changed files with 487 additions and 1 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
Makefile.am
View file

@ -283,6 +283,7 @@ MODULES = \
guix/search-paths.scm \ guix/search-paths.scm \
guix/packages.scm \ guix/packages.scm \
guix/import/cabal.scm \ guix/import/cabal.scm \
guix/import/composer.scm \
guix/import/cpan.scm \ guix/import/cpan.scm \
guix/import/cran.scm \ guix/import/cran.scm \
guix/import/crate.scm \ guix/import/crate.scm \
@ -341,6 +342,7 @@ MODULES = \
guix/scripts/home/import.scm \ guix/scripts/home/import.scm \
guix/scripts/lint.scm \ guix/scripts/lint.scm \
guix/scripts/challenge.scm \ guix/scripts/challenge.scm \
guix/scripts/import/composer.scm \
guix/scripts/import/crate.scm \ guix/scripts/import/crate.scm \
guix/scripts/import/cpan.scm \ guix/scripts/import/cpan.scm \
guix/scripts/import/cran.scm \ guix/scripts/import/cran.scm \
@ -509,6 +511,7 @@ SCM_TESTS = \
tests/challenge.scm \ tests/challenge.scm \
tests/channels.scm \ tests/channels.scm \
tests/combinators.scm \ tests/combinators.scm \
tests/composer.scm \
tests/containers.scm \ tests/containers.scm \
tests/cpan.scm \ tests/cpan.scm \
tests/cpio.scm \ tests/cpio.scm \

20
doc/guix.texi
View file

@ -14533,6 +14533,26 @@ repository used by the OCaml community.
Additional options include: Additional options include:
@table @code
@item --recursive
@itemx -r
Traverse the dependency graph of the given upstream package recursively
and generate package expressions for all those packages that are not yet
in Guix.
@end table
@item composer
@cindex Composer
@cindex PHP
Import metadata from the @uref{https://getcomposer.org/, Composer} package
archive used by the PHP community, as in this example:
@example
guix import composer phpunit/phpunit
@end example
Additional options include:
@table @code @table @code
@item --recursive @item --recursive
@itemx -r @itemx -r

268
guix/import/composer.scm Normal file
View file

@ -0,0 +1,268 @@
;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2019 Julien Lepiller <julien@lepiller.eu>
;;;
;;; 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 composer)
#:use-module (ice-9 match)
#:use-module (json)
#:use-module (guix hash)
#:use-module (guix base32)
#:use-module (guix build git)
#:use-module (guix build utils)
#:use-module (guix build-system)
#:use-module (guix build-system composer)
#:use-module (guix import json)
#:use-module (guix import utils)
#:use-module ((guix licenses) #:prefix license:)
#:use-module (guix memoization)
#:use-module (guix packages)
#:use-module (guix serialization)
#:use-module (guix upstream)
#:use-module (guix utils)
#:use-module (srfi srfi-1)
#:use-module (srfi srfi-11)
#:use-module (srfi srfi-26)
#:export (composer->guix-package
%composer-updater
composer-recursive-import
%composer-base-url))
(define %composer-base-url
(make-parameter "https://repo.packagist.org"))
(define (fix-version version)
"Return a fixed version from a version string. For instance, v10.1 -> 10.1"
(cond
((string-prefix? "version" version)
(if (char-set-contains? char-set:digit (string-ref version 7))
(substring version 7)
(substring version 8)))
((string-prefix? "v" version)
(substring version 1))
(else version)))
(define (latest-version versions)
(fold (lambda (a b) (if (version>? (fix-version a) (fix-version b)) a b))
(car versions) versions))
(define (json->require dict)
(if dict
(let loop ((result '()) (require dict))
(match require
(() result)
((((? (cut string-contains <> "/") name) . _)
require ...)
(loop (cons name result) require))
((_ require ...) (loop result require))
(_ result)))
'()))
(define-json-mapping <composer-source> make-composer-source composer-source?
json->composer-source
(type composer-source-type)
(url composer-source-url)
(reference composer-source-reference))
(define-json-mapping <composer-package> make-composer-package composer-package?
json->composer-package
(description composer-package-description)
(homepage composer-package-homepage)
(source composer-package-source "source" json->composer-source)
(name composer-package-name "name" php-package-name)
(version composer-package-version "version" fix-version)
(require composer-package-require "require" json->require)
(dev-require composer-package-dev-require "require-dev" json->require)
(license composer-package-license "license"
(lambda (vector)
(let ((l (map string->license (vector->list vector))))
(if (eq? (length l) 1)
(car l)
`(list ,@l))))))
(define (valid-version? v)
(let ((d (string-downcase v)))
(and (not (string-contains d "dev"))
(not (string-contains d "beta"))
(not (string-contains d "rc")))))
(define* (composer-fetch name #:key (version #f))
"Return a composer-package representation of the Composer metadata for the
package NAME with optional VERSION, or #f on failure."
(let* ((url (string-append (%composer-base-url) "/p/" name ".json"))
(packages (and=> (json-fetch url)
(lambda (pkg)
(let ((pkgs (assoc-ref pkg "packages")))
(or (assoc-ref pkgs name) pkg))))))
(if packages
(json->composer-package
(if version
(assoc-ref packages version)
(cdr
(reduce
(lambda (new cur-max)
(match new
(((? valid-version? version) . tail)
(if (version>? (fix-version version)
(fix-version (car cur-max)))
(cons* version tail)
cur-max))
(_ cur-max)))
(cons* "0.0.0" #f)
packages))))
#f)))
(define (php-package-name name)
"Given the NAME of a package on Packagist, return a Guix-compliant name for
the package."
(let ((name (string-join (string-split name #\/) "-")))
(if (string-prefix? "php-" name)
(snake-case name)
(string-append "php-" (snake-case name)))))
(define (make-php-sexp composer-package)
"Return the `package' s-expression for a PHP package for the given
COMPOSER-PACKAGE."
(let* ((source (composer-package-source composer-package))
(dependencies (map php-package-name
(composer-package-require composer-package)))
(dev-dependencies (map php-package-name
(composer-package-dev-require composer-package)))
(git? (equal? (composer-source-type source) "git")))
((if git? call-with-temporary-directory call-with-temporary-output-file)
(lambda* (temp #:optional port)
(and (if git?
(begin
(mkdir-p temp)
(git-fetch (composer-source-url source)
(composer-source-reference source)
temp))
(url-fetch (composer-source-url source) temp))
`(package
(name ,(composer-package-name composer-package))
(version ,(composer-package-version composer-package))
(source
(origin
,@(if git?
`((method git-fetch)
(uri (git-reference
(url ,(if (string-suffix?
".git"
(composer-source-url source))
(string-drop-right
(composer-source-url source)
(string-length ".git"))
(composer-source-url source)))
(commit ,(composer-source-reference source))))
(file-name (git-file-name name version))
(sha256
(base32
,(bytevector->nix-base32-string
(file-hash* temp)))))
`((method url-fetch)
(uri ,(composer-source-url source))
(sha256 (base32 ,(guix-hash-url temp)))))))
(build-system composer-build-system)
,@(if (null? dependencies)
'()
`((inputs
(list ,@(map string->symbol dependencies)))))
,@(if (null? dev-dependencies)
'()
`((native-inputs
(list ,@(map string->symbol dev-dependencies)))))
(synopsis "")
(description ,(composer-package-description composer-package))
(home-page ,(composer-package-homepage composer-package))
(license ,(or (composer-package-license composer-package)
'unknown-license!))))))))
(define composer->guix-package
(memoize
(lambda* (package-name #:key (version #f) #:allow-other-keys)
"Fetch the metadata for PACKAGE-NAME from packagist.org, and return the
`package' s-expression corresponding to that package and its list of
dependencies, or #f and the empty list on failure."
(let ((package (composer-fetch package-name #:version version)))
(if package
(let* ((dependencies-names (composer-package-require package))
(dev-dependencies-names (composer-package-dev-require package)))
(values (make-php-sexp package)
(append dependencies-names dev-dependencies-names)))
(values #f '()))))))
(define (guix-name->composer-name name)
"Given a guix package name, return the name of the package in Packagist."
(if (string-prefix? "php-" name)
(let ((components (string-split (substring name 4) #\-)))
(match components
((namespace name ...)
(string-append namespace "/" (string-join name "-")))))
name))
(define (guix-package->composer-name package)
"Given a Composer PACKAGE built from Packagist, return the name of the
package in Packagist."
(let ((upstream-name (assoc-ref
(package-properties package)
'upstream-name))
(name (package-name package)))
(if upstream-name
upstream-name
(guix-name->composer-name name))))
(define (string->license str)
"Convert the string STR into a license object."
(or (spdx-string->license str)
(match str
("GNU LGPL" 'license:lgpl2.0)
("GPL" 'license:gpl3)
((or "BSD" "BSD License") 'license:bsd-3)
((or "MIT" "MIT license" "Expat license") 'license:expat)
("Public domain" 'license:public-domain)
((or "Apache License, Version 2.0" "Apache 2.0") 'license:asl2.0)
(_ 'unknown-license!))))
(define (php-package? package)
"Return true if PACKAGE is a PHP package from Packagist."
(and
(eq? (package-build-system package) composer-build-system)
(string-prefix? "php-" (package-name package))))
(define (latest-release package)
"Return an <upstream-source> for the latest release of PACKAGE."
(let* ((php-name (guix-package->composer-name package))
(package (composer-fetch php-name))
(version (composer-package-version package))
(url (composer-source-url (composer-package-source package))))
(upstream-source
(package (package-name package))
(version version)
(urls (list url)))))
(define %composer-updater
(upstream-updater
(name 'composer)
(description "Updater for Composer packages")
(pred php-package?)
(import latest-release)))
(define* (composer-recursive-import package-name #:optional version)
(recursive-import package-name
#:version version
#:repo->guix-package composer->guix-package
#:guix-name php-package-name))

2
guix/scripts/import.scm
View file

@ -47,7 +47,7 @@ (define %standard-import-options '())
(define importers '("gnu" "pypi" "cpan" "hackage" "stackage" "egg" "elpa" (define importers '("gnu" "pypi" "cpan" "hackage" "stackage" "egg" "elpa"
"gem" "go" "cran" "crate" "texlive" "json" "opam" "gem" "go" "cran" "crate" "texlive" "json" "opam"
"minetest" "elm" "hexpm")) "minetest" "elm" "hexpm" "composer"))
(define (resolve-importer name) (define (resolve-importer name)
(let ((module (resolve-interface (let ((module (resolve-interface

107
guix/scripts/import/composer.scm Normal file
View file

@ -0,0 +1,107 @@
;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2015 David Thompson <davet@gnu.org>
;;; Copyright © 2018 Oleg Pykhalov <go.wigust@gmail.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 composer)
#:use-module (guix ui)
#:use-module (guix utils)
#:use-module (guix scripts)
#:use-module (guix import composer)
#:use-module (guix scripts import)
#:use-module (srfi srfi-1)
#:use-module (srfi srfi-11)
#:use-module (srfi srfi-37)
#:use-module (srfi srfi-41)
#:use-module (ice-9 match)
#:use-module (ice-9 format)
#:export (guix-import-composer))
;;;
;;; Command-line options.
;;;
(define %default-options
'())
(define (show-help)
(display (G_ "Usage: guix import composer PACKAGE-NAME
Import and convert the Composer package for PACKAGE-NAME.\n"))
(display (G_ "
-h, --help display this help and exit"))
(display (G_ "
-V, --version display version information and exit"))
(display (G_ "
-r, --recursive generate package expressions for all Composer packages\
that are not yet in Guix"))
(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 composer")))
(option '(#\r "recursive") #f #f
(lambda (opt name arg result)
(alist-cons 'recursive #t result)))
%standard-import-options))
;;;
;;; Entry point.
;;;
(define (guix-import-composer . 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
((package-name)
(if (assoc-ref opts 'recursive)
(map (match-lambda
((and ('package ('name name) . rest) pkg)
`(define-public ,(string->symbol name)
,pkg))
(_ #f))
(composer-recursive-import package-name))
(let ((sexp (composer->guix-package package-name)))
(unless sexp
(leave (G_ "failed to download meta-data for package '~a'~%")
package-name))
sexp)))
(()
(leave (G_ "too few arguments~%")))
((many ...)
(leave (G_ "too many arguments~%"))))))

88
tests/composer.scm Normal file
View file

@ -0,0 +1,88 @@
;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2020 Julien Lepiller <julien@lepiller.eu>
;;; Copyright © 2023 Nicolas Graves <ngraves@ngraves.fr>
;;;
;;; 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-composer)
#:use-module (guix import composer)
#:use-module (guix base32)
#:use-module (gcrypt hash)
#:use-module (guix tests http)
#:use-module (guix grafts)
#:use-module (srfi srfi-64)
#:use-module (web client)
#:use-module (ice-9 match))
;; Globally disable grafts because they can trigger early builds.
(%graft? #f)
(define test-json
"{
\"packages\": {
\"foo/bar\": {
\"0.1\": {
\"name\": \"foo/bar\",
\"description\": \"description\",
\"keywords\": [\"testing\"],
\"homepage\": \"http://example.com\",
\"version\": \"0.1\",
\"license\": [\"BSD-3-Clause\"],
\"source\": {
\"type\": \"url\",
\"url\": \"http://example.com/Bar-0.1.tar.gz\"
},
\"require\": {},
\"require-dev\": {\"phpunit/phpunit\": \"1.0.0\"}
}
}
}
}")
(define test-source
"foobar")
(test-begin "composer")
(test-assert "composer->guix-package"
;; Replace network resources with sample data.
(with-http-server `((200 ,test-json)
(200 ,test-source))
(parameterize ((%composer-base-url (%local-url))
(current-http-proxy (%local-url)))
(match (composer->guix-package "foo/bar")
(`(package
(name "php-foo-bar")
(version "0.1")
(source (origin
(method url-fetch)
(uri "http://example.com/Bar-0.1.tar.gz")
(sha256
(base32
,(? string? hash)))))
(build-system composer-build-system)
(native-inputs (list php-phpunit-phpunit))
(synopsis "")
(description "description")
(home-page "http://example.com")
(license license:bsd-3))
(string=? (bytevector->nix-base32-string
(call-with-input-string test-source port-sha256))
hash))
(x
(pk 'fail x #f))))))
(test-end "composer")