[bug#48999] [PATCH] import: hackage: Accept local source for package.

[bug#48999] [PATCH] import: hackage: Accept local source for package.

[Xinglu Chen]

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

[bug#48999] [PATCH] import: hackage: Accept local source for package.

[Ludovic Courtès]

Hi,

Xinglu Chen <public@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’.

[bug#48999] [PATCH] import: hackage: Accept local source for package.

[Xinglu Chen]

[-- Attachment #1: Type: text/plain, Size: 2085 bytes --]

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

> Hi,
>
> Xinglu Chen <public@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.

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 861 bytes --]

[bug#48999] [PATCH] import: hackage: Accept local source for package.

[Ludovic Courtès]

Hi,

Xinglu Chen <public@yoctocell.xyz> skribis:

> On Tue, Jun 29 2021, Ludovic Courtès wrote:
>
>> Hi,
>>
>> Xinglu Chen <public@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’.

[bug#48999] [PATCH] import: hackage: Accept local source for package.

[zimoun]

Hi,

On Wed, 30 Jun 2021 at 11:17, Ludovic Courtès <ludo@gnu.org> wrote:
>>> Xinglu Chen <public@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

[bug#48999] [PATCH] import: hackage: Accept local source for package.

[Xinglu Chen]

[-- Attachment #1: Type: text/plain, Size: 2575 bytes --]

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

> Hi,
>
> Xinglu Chen <public@yoctocell.xyz> skribis:
>
>> On Tue, Jun 29 2021, Ludovic Courtès wrote:
>>
>>> Hi,
>>>
>>> Xinglu Chen <public@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.

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 861 bytes --]

[bug#48999] [PATCH v2 0/3] Import Haskell packages from the local filesystem

[Xinglu Chen]

[-- Attachment #1: Type: text/plain, Size: 1048 bytes --]

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



[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 861 bytes --]

[bug#48999] [PATCH v2 1/3] import: hackage: Accept local source for package.

[Xinglu Chen]

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

[bug#48999] [PATCH v2 2/3] import: utils: Add predicates for checking VCS repositories.

[Xinglu Chen]

* 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@googlemail.com>
 ;;; Copyright © 2020 Martin Becze <mjbecze@riseup.net>
 ;;; Copyright © 2021 Maxim Cournoyer <maxim.cournoyer@gmail.com>
+;;; Copyright © 2021 Xinglu Chen <public@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

[bug#48999] [PATCH v2 3/3] scripts: import: hackage: Add option to import package from local filesystem.

[Xinglu Chen]

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@fbengineering.ch>
 ;;; Copyright © 2018 Ricardo Wurmus <rekado@elephly.net>
+;;; Copyright © 2021 Xinglu Chen <public@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))
 
 \f
@@ -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