me
/
guix
Archived
1
0
Fork 0
Code

import: go: Append version to symbol name in the pinned version mode. 

This allows importing packages with complicated version specific dependency
chains without the package symbol names colliding.

* doc/guix.texi (Invoking guix import): Document the --pin-versions option.
Mention that a specific version can be imported.  Remove the experimental
warning.
* guix/import/go.scm (go-module->guix-package-name)[version]: Add optional
argument.  Rewrite the character translation in terms of string-map.
(go-module->guix-package): Conditionally use dependencies whose symbol include
their version, based no the value of the PIN-VERSIONS? argument.
* guix/import/utils.scm (package->definition): Add a new case where the full
version string is appended to the package symbol.
* guix/scripts/import.scm (guix-import): Correctly print forms starting
with '(define-public [...]'.
* guix/scripts/import/go.scm (guix-import-go): Conditionally include the
version in the package symbols defined.
master
Maxim Cournoyer 2021-03-21 00:16:22 -04:00
parent a8b927a562
commit 83f8b6d32c
No known key found for this signature in database
GPG Key ID: 1260E46482E63562
5 changed files with 57 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
doc/guix.texi
View File

@ -11553,13 +11553,13 @@ Select the given repository (a repository name). Possible values include:
Import metadata for a Go module using
@uref{https://proxy.golang.org, proxy.golang.org}.
This importer is highly experimental. See the source code for more info
about the current state.
@example
guix import go gopkg.in/yaml.v2
@end example
It is possible to use a package specification with a @code{@@VERSION}
suffix to import a specific version.
Additional options include:
@table @code
@ -11568,6 +11568,14 @@ Additional options include:
Traverse the dependency graph of the given upstream package recursively
and generate package expressions for all those packages that are not yet
in Guix.
@item --pin-versions
When using this option, the importer preserves the exact versions of the
Go modules dependencies instead of using their latest available
versions. This can be useful when attempting to import packages that
recursively depend on former versions of themselves to build. When
using this mode, the symbol of the package is made by appending the
version to its name, so that multiple versions of the same package can
coexist.
@end table
@end table

38
guix/import/go.scm
View File

@ -428,15 +428,19 @@ hence the need to derive this information."
(vcs-qualified-module-path->root-repo-url module-path)
module-path))
(define (go-module->guix-package-name module-path)
"Converts a module's path to the canonical Guix format for Go packages."
(string-downcase (string-append "go-" (string-replace-substring
(string-replace-substring
(string-replace-substring
module-path
"." "-")
"/" "-")
"_" "-"))))
(define* (go-module->guix-package-name module-path #:optional version)
"Converts a module's path to the canonical Guix format for Go packages.
Optionally include a VERSION string to append to the name."
;; Map dot, slash and underscore characters to hyphens.
(let ((module-path* (string-map (lambda (c)
(if (member c '(#\. #\/ #\_))
#\-
c))
module-path)))
(string-downcase (string-append "go-" module-path*
(if version
(string-append "-" version)
"")))))
(define (strip-.git-suffix/maybe repo-url)
"Strip a repository URL '.git' suffix from REPO-URL if hosted at GitHub."
@ -575,6 +579,8 @@ When VERSION is unspecified, the latest version available is used."
(let* ((available-versions (go-module-available-versions goproxy module-path))
(version* (or version
(go-module-version-string goproxy module-path))) ;latest
;; Elide the "v" prefix Go uses.
(strip-v-prefix (cut string-trim <> #\v))
;; Pseudo-versions do not appear in the versions list; skip the
;; following check.
(_ (unless (or (go-pseudo-version? version*)
@ -584,7 +590,9 @@ hint: use one of the following available versions ~a\n"
version* available-versions))))
(content (fetch-go.mod goproxy module-path version*))
(dependencies+versions (parse-go.mod content))
(dependencies (map car dependencies+versions))
(dependencies (if pin-versions?
dependencies+versions
(map car dependencies+versions)))
(guix-name (go-module->guix-package-name module-path))
(root-module-path (module-path->repository-root module-path))
;; The VCS type and URL are not included in goproxy information. For
@ -598,14 +606,18 @@ hint: use one of the following available versions ~a\n"
(values
`(package
(name ,guix-name)
;; Elide the "v" prefix Go uses
(version ,(string-trim version* #\v))
(version ,(strip-v-prefix version*))
(source
,(vcs->origin vcs-type vcs-repo-url version*))
(build-system go-build-system)
(arguments
'(#:import-path ,root-module-path))
,@(maybe-propagated-inputs (map go-module->guix-package-name
,@(maybe-propagated-inputs
(map (match-lambda
((name version)
(go-module->guix-package-name name (strip-v-prefix version)))
(name
(go-module->guix-package-name name)))
dependencies))
(home-page ,(format #f "https://~a" root-module-path))
(synopsis ,synopsis)

7
guix/import/utils.scm
View File

@ -274,8 +274,9 @@ snippet generated is for regular inputs."
(maybe-inputs package-names output #:type 'propagated))
(define* (package->definition guix-package #:optional append-version?/string)
"If APPEND-VERSION?/STRING is #t, append the package's major+minor
version. If APPEND-VERSION?/string is a string, append this string."
"If APPEND-VERSION?/STRING is #t, append the package's major+minor version.
If it is the symbol 'full, append the package's complete version. If
APPEND-VERSION?/string is a string, append this string."
(match guix-package
((or
('package ('name name) ('version version) . rest)
@ -287,6 +288,8 @@ version. If APPEND-VERSION?/string is a string, append this string."
(string-append name "-" append-version?/string))
((eq? append-version?/string #t)
(string-append name "-" (version-major+minor version)))
((eq? 'full append-version?/string)
(string-append name "-" version))
(else name)))
,guix-package))))

3
guix/scripts/import.scm
View File

@ -119,7 +119,8 @@ Run IMPORTER with ARGS.\n"))
(current-output-port))))))
(match (apply (resolve-importer importer) args)
((and expr (or ('package _ ...)
('let _ ...)))
('let _ ...)
('define-public _ ...)))
(print expr))
((? list? expressions)
(for-each (lambda (expr)

17
guix/scripts/import/go.scm
View File

@ -22,9 +22,11 @@
#:use-module (guix utils)
#:use-module (guix scripts)
#:use-module (guix import go)
#:use-module (guix import utils)
#:use-module (guix scripts import)
#:use-module (srfi srfi-1)
#:use-module (srfi srfi-11)
#:use-module (srfi srfi-26)
#:use-module (srfi srfi-37)
#:use-module (ice-9 match)
#:use-module (ice-9 format)
@ -94,7 +96,12 @@ that are not yet in Guix"))
(('argument . value)
value)
(_ #f))
(reverse opts))))
(reverse opts)))
;; Append the full version to the package symbol name when using
;; pinned versions.
(package->definition* (if (assoc-ref opts 'pin-versions?)
(cut package->definition <> 'full)
package->definition)))
(match args
((spec) ;e.g., github.com/golang/protobuf@v1.3.1
(receive (name version)
@ -106,18 +113,14 @@ that are not yet in Guix"))
(assoc-ref opts 'pin-versions?))))
(if (assoc-ref opts 'recursive)
;; Recursive import.
(map (match-lambda
((and ('package ('name name) . rest) pkg)
`(define-public ,(string->symbol name)
,pkg))
(_ #f))
(map package->definition*
(apply go-module-recursive-import arguments))
;; Single import.
(let ((sexp (apply go-module->guix-package arguments)))
(unless sexp
(leave (G_ "failed to download meta-data for module '~a'~%")
module-name))
sexp)))))
(package->definition* sexp))))))
(()
(leave (G_ "too few arguments~%")))
((many ...)