GNU bug report logs - #48999
[PATCH] import: hackage: Accept local source for package.

Previous Next

To reply to this bug, email your comments to 48999 AT debbugs.gnu.org.

Toggle the display of automated, internal messages from the tracker.

Message #5 received at submit <at> debbugs.gnu.org (full text, mbox):

From: Xinglu Chen <public <at> yoctocell.xyz>
To: guix-patches <at> gnu.org
Subject: [PATCH] import: hackage: Accept local source for package.
Date: Sun, 13 Jun 2021 11:46:18 +0200

When developing a Haskell package it is often useful to have a Guix package
definition for that package, previously one would have to write that package
definition by hand, and if the .cabal file changed one would manually update
the Guix package definition.

This commit allows one to specify a custom source for their package, meaning
that one could programatically generate a Guix package definition for their
local Haskell package.  If the .cabal file changes, the generated package
definition will also change accordingly.  One could for instance write the
following in a guix.scm file:

  (define-values (ghc-haskeme deps)
    (call-with-input-file "haskeme.cabal"
      (lambda (port)
        (hackage->guix-package
         "haskeme"
         #:port port
         #:source (local-file "." "haskeme-checkout"
                              #:recursive? #t
                              #:select? hg-predicate)))))

  ghc-haskeme

Invoking ‘guix build -f guix.scm’ would then always build an up-to-date
version of the package.

* guix/import/hackage.scm (hackage-module->sexp): Add optional keyword
argument ‘source’
(hackage->guix-package): Likewise.
* tests/hackage.scm (eval-test-with-cabal): Likewise.
("hackage->guix-package local source"): New test.
---
Without this I would have to manually write my Guix package definition,
and manually update the ‘inputs’ field if I added a new dependency in my
.cabal file.  This patch offers something similar to pkgs.callCabal2nix
(I could find any link to the docs, classic Nix) in Nixpkgs where i can
just write the following

--8<---------------cut here---------------start------------->8---
let
  haskellPackages = pkgs.haskell.packages.${compiler}.override {
    overrides = hpNew: hpOld: {
      haskeme = hpNew.callCabal2nix "haskeme" ./. { };
    };
  };
in
{
  haskeme = haskellPackages.haskeme;
}
--8<---------------cut here---------------end--------------->8---

to get a Nix package definition of my Haskell package.

 guix/import/hackage.scm | 43 ++++++++++++++++++++++++++---------------
 tests/hackage.scm       | 28 +++++++++++++++++++++++++--
 2 files changed, 53 insertions(+), 18 deletions(-)

diff --git a/guix/import/hackage.scm b/guix/import/hackage.scm
index f94a1e7087..326ab92365 100644
--- a/guix/import/hackage.scm
+++ b/guix/import/hackage.scm
@@ -227,10 +227,13 @@ package being processed and is used to filter references to itself."
           dependencies))
 
 (define* (hackage-module->sexp cabal cabal-hash
-                               #:key (include-test-dependencies? #t))
+                               #:key
+                               (include-test-dependencies? #t)
+                               (source #f))
   "Return the `package' S-expression for a Cabal package.  CABAL is the
-representation of a Cabal file as produced by 'read-cabal'.  CABAL-HASH is
-the hash of the Cabal file."
+representation of a Cabal file as produced by 'read-cabal'.  CABAL-HASH is the
+hash of the Cabal file.  If SOURCE is specified, it will be used as the source
+for the package."
 
   (define name
     (cabal-package-name cabal))
@@ -294,20 +297,24 @@ the hash of the Cabal file."
       (() '())
       (args `((arguments (,'quasiquote ,args))))))
 
-  (let ((tarball (with-store store
-                   (download-to-store store source-url))))
+  (let ((tarball (if source
+                     #f
+                     (with-store store
+                       (download-to-store store source-url)))))
     (values
      `(package
         (name ,(hackage-name->package-name name))
         (version ,version)
-        (source (origin
-                  (method url-fetch)
-                  (uri (string-append ,@(factorize-uri source-url version)))
-                  (sha256
-                   (base32
-                    ,(if tarball
-                         (bytevector->nix-base32-string (file-sha256 tarball))
-                         "failed to download tar archive")))))
+        (source ,(if source
+                     source
+                     `(origin
+                        (method url-fetch)
+                        (uri (string-append ,@(factorize-uri source-url version)))
+                        (sha256
+                         (base32
+                          ,(if tarball
+                               (bytevector->nix-base32-string (file-sha256 tarball))
+                               "failed to download tar archive"))))))
         (build-system haskell-build-system)
         ,@(maybe-inputs 'inputs dependencies)
         ,@(maybe-inputs 'native-inputs native-dependencies)
@@ -321,10 +328,12 @@ the hash of the Cabal file."
 (define* (hackage->guix-package package-name #:key
                                 (include-test-dependencies? #t)
                                 (port #f)
+                                (source #f)
                                 (cabal-environment '()))
   "Fetch the Cabal file for PACKAGE-NAME from hackage.haskell.org, or, if the
-called with keyword parameter PORT, from PORT.  Return the `package'
-S-expression corresponding to that package, or #f on failure.
+called with keyword parameter PORT, from PORT.  If SOURCE is specified, use it
+as the source for the package instead of trying to fetch a tarball.  Return
+the `package' S-expression corresponding to that package, or #f on failure.
 CABAL-ENVIRONMENT is an alist defining the environment in which the Cabal
 conditionals are evaluated.  The accepted keys are: \"os\", \"arch\", \"impl\"
 and the name of a flag.  The value associated with a flag has to be either the
@@ -338,7 +347,9 @@ respectively."
                     (hackage-fetch-and-hash package-name))))
     (and=> cabal-meta (compose (cut hackage-module->sexp <> cabal-hash
                                     #:include-test-dependencies?
-                                    include-test-dependencies?)
+                                    include-test-dependencies?
+                                    #:source
+                                    source)
                                (cut eval-cabal <> cabal-environment)))))
 
 (define hackage->guix-package/m                   ;memoized variant
diff --git a/tests/hackage.scm b/tests/hackage.scm
index 66a13d9881..54590dcece 100644
--- a/tests/hackage.scm
+++ b/tests/hackage.scm
@@ -22,6 +22,7 @@
   #:use-module (guix import cabal)
   #:use-module (guix import hackage)
   #:use-module (guix tests)
+  #:use-module (guix gexp)
   #:use-module (srfi srfi-64)
   #:use-module (ice-9 match))
 
@@ -186,9 +187,28 @@ library
     ('description (? string?))
     ('license 'license:bsd-3)))
 
-(define* (eval-test-with-cabal test-cabal matcher #:key (cabal-environment '()))
+(define-package-matcher match-ghc-foo-local-source
+  ('package
+    ('name "ghc-foo")
+    ('version "1.0.0")
+    ('source
+     (? file-like?))
+    ('build-system 'haskell-build-system)
+    ('inputs
+     ('quasiquote
+      (("ghc-http" ('unquote 'ghc-http)))))
+    ('home-page "http://test.org")
+    ('synopsis (? string?))
+    ('description (? string?))
+    ('license 'license:bsd-3)))
+
+(define* (eval-test-with-cabal test-cabal matcher
+                               #:key (cabal-environment '()) (source #f))
   (define port (open-input-string test-cabal))
-  (matcher (hackage->guix-package "foo" #:port port #:cabal-environment cabal-environment)))
+  (matcher (hackage->guix-package "foo"
+                                  #:port port
+                                  #:cabal-environment cabal-environment
+                                  #:source source)))
 
 (test-assert "hackage->guix-package test 1"
   (eval-test-with-cabal test-cabal-1 match-ghc-foo))
@@ -208,6 +228,10 @@ library
   (eval-test-with-cabal test-cabal-5 match-ghc-foo
                         #:cabal-environment '(("impl" . "ghc-7.8"))))
 
+(test-assert "hackage->guix-package local source"
+  (eval-test-with-cabal test-cabal-1 match-ghc-foo-local-source
+                        #:source (plain-file "dummy source" "source")))
+
 (define-package-matcher match-ghc-foo-6
   ('package
     ('name "ghc-foo")

base-commit: acb858881901aa28499f83f40d3e04d6e4749453
-- 
2.32.0

Message #8 received at 48999 <at> debbugs.gnu.org (full text, mbox):

From: Ludovic Courtès <ludo <at> gnu.org>
To: Xinglu Chen <public <at> yoctocell.xyz>
Cc: 48999 <at> debbugs.gnu.org
Subject: Re: bug#48999: [PATCH] import: hackage: Accept local source for
 package.
Date: Tue, 29 Jun 2021 11:44:40 +0200

Hi,

Xinglu Chen <public <at> yoctocell.xyz> skribis:

> When developing a Haskell package it is often useful to have a Guix package
> definition for that package, previously one would have to write that package
> definition by hand, and if the .cabal file changed one would manually update
> the Guix package definition.
>
> This commit allows one to specify a custom source for their package, meaning
> that one could programatically generate a Guix package definition for their
> local Haskell package.  If the .cabal file changes, the generated package
> definition will also change accordingly.  One could for instance write the
> following in a guix.scm file:
>
>   (define-values (ghc-haskeme deps)
>     (call-with-input-file "haskeme.cabal"
>       (lambda (port)
>         (hackage->guix-package
>          "haskeme"
>          #:port port
>          #:source (local-file "." "haskeme-checkout"
>                               #:recursive? #t
>                               #:select? hg-predicate)))))
>
>   ghc-haskeme
>
> Invoking ‘guix build -f guix.scm’ would then always build an up-to-date
> version of the package.
>
> * guix/import/hackage.scm (hackage-module->sexp): Add optional keyword
> argument ‘source’
> (hackage->guix-package): Likewise.
> * tests/hackage.scm (eval-test-with-cabal): Likewise.
> ("hackage->guix-package local source"): New test.

Looks like a nice improvement.

What I don’t get is that this functionality doesn’t seem to be available
from the CLI, which the patch doesn’t change.  Or am I missing
something?

Thanks,
Ludo’.

Message #11 received at 48999 <at> debbugs.gnu.org (full text, mbox):

From: Xinglu Chen <public <at> yoctocell.xyz>
To: Ludovic Courtès <ludo <at> gnu.org>
Cc: 48999 <at> debbugs.gnu.org
Subject: Re: [bug#48999] [PATCH] import: hackage: Accept local source for
 package.
Date: Tue, 29 Jun 2021 21:00:07 +0200

[Message part 1 (text/plain, inline)]

On Tue, Jun 29 2021, Ludovic Courtès wrote:

> Hi,
>
> Xinglu Chen <public <at> yoctocell.xyz> skribis:
>
>> When developing a Haskell package it is often useful to have a Guix package
>> definition for that package, previously one would have to write that package
>> definition by hand, and if the .cabal file changed one would manually update
>> the Guix package definition.
>>
>> This commit allows one to specify a custom source for their package, meaning
>> that one could programatically generate a Guix package definition for their
>> local Haskell package.  If the .cabal file changes, the generated package
>> definition will also change accordingly.  One could for instance write the
>> following in a guix.scm file:
>>
>>   (define-values (ghc-haskeme deps)
>>     (call-with-input-file "haskeme.cabal"
>>       (lambda (port)
>>         (hackage->guix-package
>>          "haskeme"
>>          #:port port
>>          #:source (local-file "." "haskeme-checkout"
>>                               #:recursive? #t
>>                               #:select? hg-predicate)))))
>>
>>   ghc-haskeme
>>
>> Invoking ‘guix build -f guix.scm’ would then always build an up-to-date
>> version of the package.
>>
>> * guix/import/hackage.scm (hackage-module->sexp): Add optional keyword
>> argument ‘source’
>> (hackage->guix-package): Likewise.
>> * tests/hackage.scm (eval-test-with-cabal): Likewise.
>> ("hackage->guix-package local source"): New test.
>
> Looks like a nice improvement.
>
> What I don’t get is that this functionality doesn’t seem to be available
> from the CLI, which the patch doesn’t change.  Or am I missing
> something?

No, I don’t think this functionality is available from the CLI since
‘hackage->guix-package’ is not called with the #:source keyword
argument.  Once all the other importers (or those where it makes sense
to do this) get this functionality,  it would be a good idea to add an
option for reading a .cabal/setup.py/whatever file and generating a
package definition from that.

[signature.asc (application/pgp-signature, inline)]

Message #14 received at 48999 <at> debbugs.gnu.org (full text, mbox):

From: Ludovic Courtès <ludo <at> gnu.org>
To: Xinglu Chen <public <at> yoctocell.xyz>
Cc: 48999 <at> debbugs.gnu.org
Subject: Re: [bug#48999] [PATCH] import: hackage: Accept local source for
 package.
Date: Wed, 30 Jun 2021 11:17:11 +0200

Hi,

Xinglu Chen <public <at> yoctocell.xyz> skribis:

> On Tue, Jun 29 2021, Ludovic Courtès wrote:
>
>> Hi,
>>
>> Xinglu Chen <public <at> yoctocell.xyz> skribis:
>>
>>> When developing a Haskell package it is often useful to have a Guix package
>>> definition for that package, previously one would have to write that package
>>> definition by hand, and if the .cabal file changed one would manually update
>>> the Guix package definition.
>>>
>>> This commit allows one to specify a custom source for their package, meaning
>>> that one could programatically generate a Guix package definition for their
>>> local Haskell package.  If the .cabal file changes, the generated package
>>> definition will also change accordingly.  One could for instance write the
>>> following in a guix.scm file:
>>>
>>>   (define-values (ghc-haskeme deps)
>>>     (call-with-input-file "haskeme.cabal"
>>>       (lambda (port)
>>>         (hackage->guix-package
>>>          "haskeme"
>>>          #:port port
>>>          #:source (local-file "." "haskeme-checkout"
>>>                               #:recursive? #t
>>>                               #:select? hg-predicate)))))
>>>
>>>   ghc-haskeme
>>>
>>> Invoking ‘guix build -f guix.scm’ would then always build an up-to-date
>>> version of the package.
>>>
>>> * guix/import/hackage.scm (hackage-module->sexp): Add optional keyword
>>> argument ‘source’
>>> (hackage->guix-package): Likewise.
>>> * tests/hackage.scm (eval-test-with-cabal): Likewise.
>>> ("hackage->guix-package local source"): New test.
>>
>> Looks like a nice improvement.
>>
>> What I don’t get is that this functionality doesn’t seem to be available
>> from the CLI, which the patch doesn’t change.  Or am I missing
>> something?
>
> No, I don’t think this functionality is available from the CLI since
> ‘hackage->guix-package’ is not called with the #:source keyword
> argument.

IOW, this functionality is not accessible, unless you use the Scheme API
as in the example above, right?

> Once all the other importers (or those where it makes sense to do
> this) get this functionality, it would be a good idea to add an option
> for reading a .cabal/setup.py/whatever file and generating a package
> definition from that.

‘guix import hackage’ could support it even if other importers don’t
have equivalent functionality, no?

Thanks,
Ludo’.

Message #17 received at 48999 <at> debbugs.gnu.org (full text, mbox):

From: zimoun <zimon.toutoune <at> gmail.com>
To: Ludovic Courtès <ludo <at> gnu.org>, Xinglu Chen
 <public <at> yoctocell.xyz>
Cc: 48999 <at> debbugs.gnu.org
Subject: Re: [bug#48999] [PATCH] import: hackage: Accept local source for
 package.
Date: Wed, 30 Jun 2021 16:10:51 +0200

Hi,

On Wed, 30 Jun 2021 at 11:17, Ludovic Courtès <ludo <at> gnu.org> wrote:
>>> Xinglu Chen <public <at> yoctocell.xyz> skribis:

>>>>   (define-values (ghc-haskeme deps)
>>>>     (call-with-input-file "haskeme.cabal"
>>>>       (lambda (port)
>>>>         (hackage->guix-package
>>>>          "haskeme"
>>>>          #:port port
>>>>          #:source (local-file "." "haskeme-checkout"
>>>>                               #:recursive? #t
>>>>                               #:select? hg-predicate)))))
>>>>
>>>>   ghc-haskeme
>>>>
>>>> Invoking ‘guix build -f guix.scm’ would then always build an up-to-date
>>>> version of the package.

[...]

>>> What I don’t get is that this functionality doesn’t seem to be available
>>> from the CLI, which the patch doesn’t change.  Or am I missing
>>> something?
>>
>> No, I don’t think this functionality is available from the CLI since
>> ‘hackage->guix-package’ is not called with the #:source keyword
>> argument.
>
> IOW, this functionality is not accessible, unless you use the Scheme API
> as in the example above, right?
>
>> Once all the other importers (or those where it makes sense to do
>> this) get this functionality, it would be a good idea to add an option
>> for reading a .cabal/setup.py/whatever file and generating a package
>> definition from that.
>
> ‘guix import hackage’ could support it even if other importers don’t
> have equivalent functionality, no?

From my understanding, there are 2 levels:

 1. simplify the Scheme snippet for developing local “foreign” package,
 i.e., “guix build -f guix.scm” with a simpler ’guix.scm’ file.

 2. an option to import local package,
 e.g., “guix import hackage --path=.”

and this for (almost) all the importers.


Cheers,
simon

Message #20 received at 48999 <at> debbugs.gnu.org (full text, mbox):

From: Xinglu Chen <public <at> yoctocell.xyz>
To: Ludovic Courtès <ludo <at> gnu.org>
Cc: 48999 <at> debbugs.gnu.org
Subject: Re: [bug#48999] [PATCH] import: hackage: Accept local source for
 package.
Date: Sun, 04 Jul 2021 12:43:11 +0200

[Message part 1 (text/plain, inline)]

On Wed, Jun 30 2021, Ludovic Courtès wrote:

> Hi,
>
> Xinglu Chen <public <at> yoctocell.xyz> skribis:
>
>> On Tue, Jun 29 2021, Ludovic Courtès wrote:
>>
>>> Hi,
>>>
>>> Xinglu Chen <public <at> yoctocell.xyz> skribis:
>>>
>>>> When developing a Haskell package it is often useful to have a Guix package
>>>> definition for that package, previously one would have to write that package
>>>> definition by hand, and if the .cabal file changed one would manually update
>>>> the Guix package definition.
>>>>
>>>> This commit allows one to specify a custom source for their package, meaning
>>>> that one could programatically generate a Guix package definition for their
>>>> local Haskell package.  If the .cabal file changes, the generated package
>>>> definition will also change accordingly.  One could for instance write the
>>>> following in a guix.scm file:
>>>>
>>>>   (define-values (ghc-haskeme deps)
>>>>     (call-with-input-file "haskeme.cabal"
>>>>       (lambda (port)
>>>>         (hackage->guix-package
>>>>          "haskeme"
>>>>          #:port port
>>>>          #:source (local-file "." "haskeme-checkout"
>>>>                               #:recursive? #t
>>>>                               #:select? hg-predicate)))))
>>>>
>>>>   ghc-haskeme
>>>>
>>>> Invoking ‘guix build -f guix.scm’ would then always build an up-to-date
>>>> version of the package.
>>>>
>>>> * guix/import/hackage.scm (hackage-module->sexp): Add optional keyword
>>>> argument ‘source’
>>>> (hackage->guix-package): Likewise.
>>>> * tests/hackage.scm (eval-test-with-cabal): Likewise.
>>>> ("hackage->guix-package local source"): New test.
>>>
>>> Looks like a nice improvement.
>>>
>>> What I don’t get is that this functionality doesn’t seem to be available
>>> from the CLI, which the patch doesn’t change.  Or am I missing
>>> something?
>>
>> No, I don’t think this functionality is available from the CLI since
>> ‘hackage->guix-package’ is not called with the #:source keyword
>> argument.
>
> IOW, this functionality is not accessible, unless you use the Scheme API
> as in the example above, right?

Yes.

>> Once all the other importers (or those where it makes sense to do
>> this) get this functionality, it would be a good idea to add an option
>> for reading a .cabal/setup.py/whatever file and generating a package
>> definition from that.
>
> ‘guix import hackage’ could support it even if other importers don’t
> have equivalent functionality, no?

Sure, that could work too.

[signature.asc (application/pgp-signature, inline)]

Message #23 received at 48999 <at> debbugs.gnu.org (full text, mbox):

From: Xinglu Chen <public <at> yoctocell.xyz>
To: 48999 <at> debbugs.gnu.org
Cc: Ludovic Courtès <ludo <at> gnu.org>,
 zimoun <zimon.toutoune <at> gmail.com>
Subject: [PATCH v2 0/3] Import Haskell packages from the local filesystem
Date: Sun, 04 Jul 2021 13:53:54 +0200

[Message part 1 (text/plain, inline)]

Changes since v1:

* Add ‘--path’ command line option for importing the package from the
  local filesystem.

* Add ‘git-repository?’ and ‘hg-repository?’ procedures for correctly
  setting the #:select? keyword (‘git-predicate’ or ‘hg-predicate’) for
  ‘local-file’.  Other VCS don’t have a ‘-predicate’ procedure, so I
  didn’t bother adding those.

Patch [1/3] hasn’t changed since v1.

Xinglu Chen (3):
  import: hackage: Accept local source for package.
  import: utils: Add predicates for checking VCS repositories.
  scripts: import: hackage: Add option to import package from local
    filesystem.

 guix/import/hackage.scm         | 43 +++++++++++++++++++++------------
 guix/import/utils.scm           | 15 ++++++++++++
 guix/scripts/import/hackage.scm | 43 +++++++++++++++++++++++++++------
 tests/hackage.scm               | 28 +++++++++++++++++++--
 4 files changed, 103 insertions(+), 26 deletions(-)


base-commit: b65af6ed9120234cf655e8e76317558cfbd02477
-- 
2.32.0

[signature.asc (application/pgp-signature, inline)]

Message #26 received at 48999 <at> debbugs.gnu.org (full text, mbox):

From: Xinglu Chen <public <at> yoctocell.xyz>
To: 48999 <at> debbugs.gnu.org
Cc: Ludovic Courtès <ludo <at> gnu.org>,
 zimoun <zimon.toutoune <at> gmail.com>
Subject: [PATCH v2 1/3] import: hackage: Accept local source for package.
Date: Sun, 04 Jul 2021 13:54:02 +0200

When developing a Haskell package it is often useful to have a Guix package
definition for that package, previously one would have to write that package
definition by hand, and if the .cabal file changed one would manually update
the Guix package definition.

This commit allows one to specify a custom source for their package, meaning
that one could programatically generate a Guix package definition for their
local Haskell package.  If the .cabal file changes, the generated package
definition will also change accordingly.  One could for instance write the
following in a guix.scm file:

  (define-values (ghc-haskeme deps)
    (call-with-input-file "haskeme.cabal"
      (lambda (port)
        (hackage->guix-package
         "haskeme"
         #:port port
         #:source (local-file "." "haskeme-checkout"
                              #:recursive? #t
                              #:select? hg-predicate)))))

  ghc-haskeme

Invoking ‘guix build -f guix.scm’ would then always build an up-to-date
version of the package.

* guix/import/hackage.scm (hackage-module->sexp): Add optional keyword
argument ‘source’
(hackage->guix-package): Likewise.
* tests/hackage.scm (eval-test-with-cabal): Likewise.
("hackage->guix-package local source"): New test.
---
 guix/import/hackage.scm | 43 ++++++++++++++++++++++++++---------------
 tests/hackage.scm       | 28 +++++++++++++++++++++++++--
 2 files changed, 53 insertions(+), 18 deletions(-)

diff --git a/guix/import/hackage.scm b/guix/import/hackage.scm
index f94a1e7087..326ab92365 100644
--- a/guix/import/hackage.scm
+++ b/guix/import/hackage.scm
@@ -227,10 +227,13 @@ package being processed and is used to filter references to itself."
           dependencies))
 
 (define* (hackage-module->sexp cabal cabal-hash
-                               #:key (include-test-dependencies? #t))
+                               #:key
+                               (include-test-dependencies? #t)
+                               (source #f))
   "Return the `package' S-expression for a Cabal package.  CABAL is the
-representation of a Cabal file as produced by 'read-cabal'.  CABAL-HASH is
-the hash of the Cabal file."
+representation of a Cabal file as produced by 'read-cabal'.  CABAL-HASH is the
+hash of the Cabal file.  If SOURCE is specified, it will be used as the source
+for the package."
 
   (define name
     (cabal-package-name cabal))
@@ -294,20 +297,24 @@ the hash of the Cabal file."
       (() '())
       (args `((arguments (,'quasiquote ,args))))))
 
-  (let ((tarball (with-store store
-                   (download-to-store store source-url))))
+  (let ((tarball (if source
+                     #f
+                     (with-store store
+                       (download-to-store store source-url)))))
     (values
      `(package
         (name ,(hackage-name->package-name name))
         (version ,version)
-        (source (origin
-                  (method url-fetch)
-                  (uri (string-append ,@(factorize-uri source-url version)))
-                  (sha256
-                   (base32
-                    ,(if tarball
-                         (bytevector->nix-base32-string (file-sha256 tarball))
-                         "failed to download tar archive")))))
+        (source ,(if source
+                     source
+                     `(origin
+                        (method url-fetch)
+                        (uri (string-append ,@(factorize-uri source-url version)))
+                        (sha256
+                         (base32
+                          ,(if tarball
+                               (bytevector->nix-base32-string (file-sha256 tarball))
+                               "failed to download tar archive"))))))
         (build-system haskell-build-system)
         ,@(maybe-inputs 'inputs dependencies)
         ,@(maybe-inputs 'native-inputs native-dependencies)
@@ -321,10 +328,12 @@ the hash of the Cabal file."
 (define* (hackage->guix-package package-name #:key
                                 (include-test-dependencies? #t)
                                 (port #f)
+                                (source #f)
                                 (cabal-environment '()))
   "Fetch the Cabal file for PACKAGE-NAME from hackage.haskell.org, or, if the
-called with keyword parameter PORT, from PORT.  Return the `package'
-S-expression corresponding to that package, or #f on failure.
+called with keyword parameter PORT, from PORT.  If SOURCE is specified, use it
+as the source for the package instead of trying to fetch a tarball.  Return
+the `package' S-expression corresponding to that package, or #f on failure.
 CABAL-ENVIRONMENT is an alist defining the environment in which the Cabal
 conditionals are evaluated.  The accepted keys are: \"os\", \"arch\", \"impl\"
 and the name of a flag.  The value associated with a flag has to be either the
@@ -338,7 +347,9 @@ respectively."
                     (hackage-fetch-and-hash package-name))))
     (and=> cabal-meta (compose (cut hackage-module->sexp <> cabal-hash
                                     #:include-test-dependencies?
-                                    include-test-dependencies?)
+                                    include-test-dependencies?
+                                    #:source
+                                    source)
                                (cut eval-cabal <> cabal-environment)))))
 
 (define hackage->guix-package/m                   ;memoized variant
diff --git a/tests/hackage.scm b/tests/hackage.scm
index 53972fc643..3083a5d4df 100644
--- a/tests/hackage.scm
+++ b/tests/hackage.scm
@@ -22,6 +22,7 @@
   #:use-module (guix import cabal)
   #:use-module (guix import hackage)
   #:use-module (guix tests)
+  #:use-module (guix gexp)
   #:use-module (srfi srfi-64)
   #:use-module (ice-9 match))
 
@@ -186,9 +187,28 @@ library
     ('description (? string?))
     ('license 'license:bsd-3)))
 
-(define* (eval-test-with-cabal test-cabal matcher #:key (cabal-environment '()))
+(define-package-matcher match-ghc-foo-local-source
+  ('package
+    ('name "ghc-foo")
+    ('version "1.0.0")
+    ('source
+     (? file-like?))
+    ('build-system 'haskell-build-system)
+    ('inputs
+     ('quasiquote
+      (("ghc-http" ('unquote 'ghc-http)))))
+    ('home-page "http://test.org")
+    ('synopsis (? string?))
+    ('description (? string?))
+    ('license 'license:bsd-3)))
+
+(define* (eval-test-with-cabal test-cabal matcher
+                               #:key (cabal-environment '()) (source #f))
   (define port (open-input-string test-cabal))
-  (matcher (hackage->guix-package "foo" #:port port #:cabal-environment cabal-environment)))
+  (matcher (hackage->guix-package "foo"
+                                  #:port port
+                                  #:cabal-environment cabal-environment
+                                  #:source source)))
 
 (test-assert "hackage->guix-package test 1"
   (eval-test-with-cabal test-cabal-1 match-ghc-foo))
@@ -208,6 +228,10 @@ library
   (eval-test-with-cabal test-cabal-5 match-ghc-foo
                         #:cabal-environment '(("impl" . "ghc-7.8"))))
 
+(test-assert "hackage->guix-package local source"
+  (eval-test-with-cabal test-cabal-1 match-ghc-foo-local-source
+                        #:source (plain-file "dummy source" "source")))
+
 (define-package-matcher match-ghc-foo-6
   ('package
     ('name "ghc-foo")
-- 
2.32.0

Message #29 received at 48999 <at> debbugs.gnu.org (full text, mbox):

From: Xinglu Chen <public <at> yoctocell.xyz>
To: 48999 <at> debbugs.gnu.org
Cc: Ludovic Courtès <ludo <at> gnu.org>,
 zimoun <zimon.toutoune <at> gmail.com>
Subject: [PATCH v2 2/3] import: utils: Add predicates for checking VCS
 repositories.
Date: Sun, 04 Jul 2021 13:54:18 +0200

* guix/import/utils.scm (git-repository?, hg-repository?): New procedures.
---
 guix/import/utils.scm | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/guix/import/utils.scm b/guix/import/utils.scm
index d817318a91..bcf26ae363 100644
--- a/guix/import/utils.scm
+++ b/guix/import/utils.scm
@@ -8,6 +8,7 @@
 ;;; Copyright © 2020 Helio Machado <0x2b3bfa0+guix <at> googlemail.com>
 ;;; Copyright © 2020 Martin Becze <mjbecze <at> riseup.net>
 ;;; Copyright © 2021 Maxim Cournoyer <maxim.cournoyer <at> gmail.com>
+;;; Copyright © 2021 Xinglu Chen <public <at> yoctocell.xyz>
 ;;;
 ;;; This file is part of GNU Guix.
 ;;;
@@ -43,6 +44,7 @@
   #:use-module (ice-9 rdelim)
   #:use-module (ice-9 receive)
   #:use-module (ice-9 regex)
+  #:use-module (ice-9 ftw)
   #:use-module (srfi srfi-1)
   #:use-module (srfi srfi-9)
   #:use-module (srfi srfi-11)
@@ -74,6 +76,9 @@
 
             guix-name
 
+            git-repository?
+            hg-repository?
+            
             recursive-import))
 
 (define (factorize-uri uri version)
@@ -422,6 +427,16 @@ separated by PRED."
                                       (chr (char-downcase chr)))
                                     name)))
 
+(define (git-repository? directory)
+  "Check whether DIRECTORY is a Git repository."
+  (let ((contents (scandir directory)))
+    (if (member ".git" contents) #t #f)))
+
+(define (hg-repository? directory)
+  "Check whether DIRECTORY is a Hg repository."
+  (let ((contents (scandir directory)))
+    (if (member ".hg" contents) #t #f)))
+
 (define (topological-sort nodes
                           node-dependencies
                           node-name)
-- 
2.32.0

Message #32 received at 48999 <at> debbugs.gnu.org (full text, mbox):

From: Xinglu Chen <public <at> yoctocell.xyz>
To: 48999 <at> debbugs.gnu.org
Cc: Ludovic Courtès <ludo <at> gnu.org>,
 zimoun <zimon.toutoune <at> gmail.com>
Subject: [PATCH v2 3/3] scripts: import: hackage: Add option to import
 package from local filesystem.
Date: Sun, 04 Jul 2021 13:54:20 +0200

This adds a ‘--path’ option for importing a Haskell package from the local
filesystem

* guix/scripts/import/hackage.scm (show-help, %options): Add ‘-p’ and ‘--path’
options.
(guix-import-hackage): Set the #:port and #:source keywords when the ‘--path’
option is used.
---
 guix/scripts/import/hackage.scm | 43 +++++++++++++++++++++++++++------
 1 file changed, 35 insertions(+), 8 deletions(-)

diff --git a/guix/scripts/import/hackage.scm b/guix/scripts/import/hackage.scm
index 906dca24b1..8728791b52 100644
--- a/guix/scripts/import/hackage.scm
+++ b/guix/scripts/import/hackage.scm
@@ -1,6 +1,7 @@
 ;;; GNU Guix --- Functional package management for GNU
 ;;; Copyright © 2015 Federico Beffa <beffa <at> fbengineering.ch>
 ;;; Copyright © 2018 Ricardo Wurmus <rekado <at> elephly.net>
+;;; Copyright © 2021 Xinglu Chen <public <at> yoctocell.xyz>
 ;;;
 ;;; This file is part of GNU Guix.
 ;;;
@@ -22,6 +23,7 @@
   #:use-module (guix utils)
   #:use-module (guix packages)
   #:use-module (guix scripts)
+  #:use-module (guix import utils)
   #:use-module (guix import hackage)
   #:use-module (guix scripts import)
   #:use-module (srfi srfi-1)
@@ -29,6 +31,7 @@
   #:use-module (srfi srfi-37)
   #:use-module (ice-9 match)
   #:use-module (ice-9 format)
+  #:use-module (rnrs io ports)
   #:export (guix-import-hackage))
 
 
@@ -62,6 +65,8 @@ version.\n"))
   (display (G_ "
   -s, --stdin                  read from standard input"))
   (display (G_ "
+  -p, --path=DIR               use local directory as source"))
+  (display (G_ "
   -t, --no-test-dependencies   don't include test-only dependencies"))
   (display (G_ "
   -V, --version                display version information and exit"))
@@ -87,6 +92,11 @@ version.\n"))
                    (alist-cons 'read-from-stdin? #t
                                (alist-delete 'read-from-stdin?
                                              result))))
+         (option '(#\p "path") #t #f
+                 (lambda (opt name arg result)
+                   (alist-cons 'read-path arg
+                                (alist-delete 'read-path
+                                              result))))
          (option '(#\e "cabal-environment") #t #f
                  (lambda (opt name arg result)
                    (alist-cons 'cabal-environment (read/eval arg)
@@ -113,22 +123,39 @@ version.\n"))
                 %default-options))
 
   (define (run-importer package-name opts error-fn)
-    (let* ((arguments (list
+    (let* ((local-directory (assoc-ref opts 'read-path))
+           (arguments (list
                        package-name
                        #:include-test-dependencies?
                        (assoc-ref opts 'include-test-dependencies?)
-                       #:port (if (assoc-ref opts 'read-from-stdin?)
-                                  (current-input-port)
-                                  #f)
+                       #:port
+                       (cond
+                        ((assoc-ref opts 'read-from-stdin?)
+                         (current-input-port))
+                        (local-directory
+                         (open-file-input-port
+                          (string-append local-directory
+                                         "/" package-name ".cabal")))
+                        (else #f))
+                       #:source
+                       `(local-file ,local-directory
+                                    ,package-name
+                                    #:recursive? #t
+                                    #:select? ,(cond
+                                                ((git-repository? local-directory)
+                                                 'git-predicate)
+                                                ((hg-repository? local-directory)
+                                                 'hg-predicate)
+                                                (else '(const #t))))
                        #:cabal-environment
                        (assoc-ref opts 'cabal-environment)))
            (sexp (if (assoc-ref opts 'recursive)
                      ;; Recursive import
                      (map (match-lambda
-                            ((and ('package ('name name) . rest) pkg)
-                             `(define-public ,(string->symbol name)
-                                ,pkg))
-                            (_ #f))
+                           ((and ('package ('name name) . rest) pkg)
+                            `(define-public ,(string->symbol name)
+                               ,pkg))
+                           (_ #f))
                           (apply hackage-recursive-import arguments))
                      ;; Single import
                      (apply hackage->guix-package arguments))))
-- 
2.32.0

Previous Next

GNU bug tracking system
Copyright (C) 1999 Darren O. Benham, 1997,2003 nCipher Corporation Ltd, 1994-97 Ian Jackson.