bug#27284: [PATCH 8/8] DRAFT Add (guix self) and use it when pulling.

[Maxim Cournoyer <maxim.cournoyer@gmail.com>]

Hi Ludovic!

I've read through this draft, and FWIW it looks OK to me! I've proof
read the comments and identified a few typos which you'll find
below. Great work!

Ludovic Courtès <ludo@gnu.org> writes:

> DRAFT: Module reloading doesn't work; needs more testing.
>
> Partly addresses <https://bugs.gnu.org/27284>.
>
> * guix/self.scm: New file.
> * Makefile.am (MODULES): Add it.
> * build-aux/build-self.scm (libgcrypt, zlib, gzip, bzip2, xz)
> (false-if-wrong-guile, package-for-current-guile, guile-json)
> (guile-ssh, guile-git, guile-bytestructures): Remove.
> (build): Rewrite to simply delegate to 'compiled-guix'.
> * gnu/packages.scm (%distro-root-directory): Rewrite to try difference

s/difference/different/ ?

[...]

> +(define* (scheme-node name modules #:optional (dependencies '())
> +                      #:key (extra-modules '()) (extra-files '())
> +                      (extensions '())
> +                      parallel?)
> +  "Return a node that builds the given Scheme MODULES, and depends on
> +DEPENDENCIES (a list of nodes).  EXTRA-MODULES is a list of additional modules
> +added to the source, and EXTRA-FILES is a list of additional files.
> +EXTENSIONS is a set of full-blow Guile packages (e.g., 'guile-json')
> that must

s/full-blow/full-blown/ ?

> +be present in the search path."
> +  (let* ((modules (append extra-modules
> +                          (closure modules
> +                                   (node-modules/recursive dependencies))))
> +         (module-files (map module->import modules))
> +         (source (imported-files (string-append name "-source")
> +                                 (append module-files extra-files))))
> +    (node name modules source dependencies
> +          (compiled-modules name source modules
> +                            (map node-source dependencies)
> +                            (map node-compiled dependencies)
> +                            #:extensions extensions
> +                            #:parallel? parallel?))))
> +
> +(define (file-imports directory sub-directory pred)
> +  "List all the files matching PRED under DIRECTORY/SUB-DIRECTORY.  Return a
> +list of file-name/file-like object suitable as input to
> 'imported-files'."

s/object/objects/, s/input/inputs/

> +  (map (lambda (file)
> +         (list (string-drop file (+ 1 (string-length directory)))
> +               (local-file file #:recursive? #t)))
> +       (find-files (string-append directory "/" sub-directory) pred)))
> +
> +(define (scheme-modules* directory sub-directory)
> +  "Return the list of module names found under SUB-DIRECTORY in DIRECTORY."
> +  (let ((prefix (string-length directory)))
> +    (map (lambda (file)
> +           (file-name->module-name (string-drop file prefix)))
> +         (scheme-files (string-append directory "/" sub-directory)))))
> +
> +(define* (compiled-guix source #:key (version %guix-version)
> +                        (guile-version (effective-version))
> +                        (libgcrypt (specification->package "libgcrypt"))
> +                        (zlib (specification->package "zlib"))
> +                        (gzip (specification->package "gzip"))
> +                        (bzip2 (specification->package "bzip2"))
> +                        (xz (specification->package "xz")))
> +  "Return a file-like objects that contains a compiled Guix."

s/objects/object/ ;)

> +  (define guile-json
> +    (package-for-guile guile-version
> +                       "guile-json"
> +                       "guile2.2-json"
> +                       "guile2.0-json"))
> +
> +  (define guile-ssh
> +    (package-for-guile guile-version
> +                       "guile-ssh"
> +                       "guile2.2-ssh"
> +                       "guile2.0-ssh"))
> +
> +  (define guile-git
> +    (package-for-guile guile-version
> +                       "guile-git"
> +                       "guile2.0-git"))
> +
> +
> +  (define dependencies
> +    (match (append-map (lambda (package)
> +                         (cons (list "x" package)
> +                               (package-transitive-inputs package)))
> +                       (list guile-git guile-json guile-ssh))
> +      (((labels packages _ ...) ...)
> +       packages)))
> +
> +  (define *core-modules*
> +    (scheme-node "guix-core"
> +                 '((guix)
> +                   (guix monad-repl)
> +                   (guix packages)
> +                   (guix download)
> +                   (guix discovery)
> +                   (guix profiles)
> +                   (guix build-system gnu)
> +                   (guix build profiles)
> +                   (guix build gnu-build-system))

Sorting the modules list lexicographically would be neat, here and in
various places. If this seems reasonable, perhaps we could have this
stylistic convention in our guidelines?

> +
> +                 ;; Provide a dummy (guix config) with the default version
> +                 ;; number, storedir, etc.  This is so that "guix-core" is the
> +                 ;; same across all installations and doesn't need to be
> +                 ;; rebuilt when the version changes, which in turns means we
> +                 ;; can have substitutes for it.

s/in turns/in turn/

[...]

> +          (define (regular? file)
> +            (not (member file '("." ".."))))
> +
> +          (define (process-file file output)
> +            (let* ((base   (string-drop-right file 4)) ;.scm
> +                   (output (string-append output "/" base
> +                                          ".go")))
> +              (compile-file file
> +                            #:output-file output
> +                            #:opts (optimization-options file))))
> +
> +          (define (report-load file total completed)
> +            (display #\cr)
> +            (format #t
> +                    "loading...\t~5,1f% of ~d files" ;FIXME: i18n
> +                    (* 100. (/ completed total)) total)
> +            (force-output))
> +
> +          (define (report-compilation file total completed)
> +            (display #\cr)
> +            (format #t "compiling...\t~5,1f% of ~d files" ;FIXME: i18n
> +                    (* 100. (/ completed total)) total)
> +            (force-output))
> +
> +          (define (process-directory directory output)
> +            (let ((files  (find-files directory "\\.scm$"))
> +                  (prefix (+ 1 (string-length directory))))
> +              ;; Hide compilation warnings.

Should this be configurable? Hidden warnings don't have much chance to
get addressed :)

Maxim