Merge branch 'master' into core-updates

16 files changed, 450 insertions, 58 deletions

diff --git a/guix/build-system/copy.scm b/guix/build-system/copy.scm
new file mode 100644
index 0000000000..d1bf8fb654
--- /dev/null
+++ b/guix/build-system/copy.scm
@@ -0,0 +1,143 @@
+;;; GNU Guix --- Functional package management for GNU
+;;; Copyright © 2019 Julien Lepiller <julien@lepiller.eu>
+;;; Copyright © 2020 Pierre Neidhardt <mail@ambrevar.xyz>
+;;;
+;;; 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 build-system copy)
+  #:use-module (guix store)
+  #:use-module (guix utils)
+  #:use-module (guix derivations)
+  #:use-module (guix search-paths)
+  #:use-module (guix build-system)
+  #:use-module (guix build-system gnu)
+  #:use-module (guix packages)
+  #:use-module (ice-9 match)
+  #:use-module (srfi srfi-1)
+  #:export (%copy-build-system-modules
+            default-glibc
+            lower
+            copy-build
+            copy-build-system))
+
+;; Commentary:
+;;
+;; Standard build procedure for simple packages that don't require much
+;; compilation, mostly just copying files around.  This is implemented as an
+;; extension of `gnu-build-system'.
+;;
+;; Code:
+
+(define %copy-build-system-modules
+  ;; Build-side modules imported by default.
+  `((guix build copy-build-system)
+    ,@%gnu-build-system-modules))
+
+(define (default-glibc)
+  "Return the default glibc package."
+  ;; Do not use `@' to avoid introducing circular dependencies.
+  (let ((module (resolve-interface '(gnu packages base))))
+    (module-ref module 'glibc)))
+
+(define* (lower name
+                #:key source inputs native-inputs outputs system target
+                (glibc (default-glibc))
+                #:allow-other-keys
+                #:rest arguments)
+  "Return a bag for NAME from the given arguments."
+  (define private-keywords
+    '(#:source #:target #:inputs #:native-inputs))
+
+  (bag
+    (name name)
+    (system system)
+    (host-inputs `(,@(if source
+                         `(("source" ,source))
+                         '())
+                   ,@inputs
+                   ;; Keep the standard inputs of 'gnu-build-system'.
+                   ,@(standard-packages)))
+    (build-inputs native-inputs)
+    (outputs outputs)
+    (build copy-build)
+    (arguments (strip-keyword-arguments private-keywords arguments))))
+
+(define* (copy-build store name inputs
+                     #:key (guile #f)
+                     (outputs '("out"))
+                     (install-plan ''(("." "./")))
+                     (search-paths '())
+                     (out-of-source? #t)
+                     (validate-runpath? #t)
+                     (patch-shebangs? #t)
+                     (strip-binaries? #t)
+                     (strip-flags ''("--strip-debug"))
+                     (strip-directories ''("lib" "lib64" "libexec"
+                                           "bin" "sbin"))
+                     (phases '(@ (guix build copy-build-system)
+                                 %standard-phases))
+                     (system (%current-system))
+                     (imported-modules %copy-build-system-modules)
+                     (modules '((guix build copy-build-system)
+                                (guix build utils))))
+  "Build SOURCE using INSTALL-PLAN, and with INPUTS."
+  (define builder
+    `(begin
+       (use-modules ,@modules)
+       (copy-build #:source ,(match (assoc-ref inputs "source")
+                               (((?  derivation? source))
+                                (derivation->output-path source))
+                               ((source)
+                                source)
+                               (source
+                                source))
+                   #:system ,system
+                   #:outputs %outputs
+                   #:inputs %build-inputs
+                   #:install-plan ,install-plan
+                   #:search-paths ',(map search-path-specification->sexp
+                                         search-paths)
+                   #:phases ,phases
+                   #:out-of-source? ,out-of-source?
+                   #:validate-runpath? ,validate-runpath?
+                   #:patch-shebangs? ,patch-shebangs?
+                   #:strip-binaries? ,strip-binaries?
+                   #:strip-flags ,strip-flags
+                   #:strip-directories ,strip-directories)))
+
+  (define guile-for-build
+    (match guile
+      ((? package?)
+       (package-derivation store guile system #:graft? #f))
+      (#f                                         ; the default
+       (let* ((distro (resolve-interface '(gnu packages commencement)))
+              (guile  (module-ref distro 'guile-final)))
+         (package-derivation store guile system #:graft? #f)))))
+
+  (build-expression->derivation store name builder
+                                #:system system
+                                #:inputs inputs
+                                #:modules imported-modules
+                                #:outputs outputs
+                                #:guile-for-build guile-for-build))
+
+(define copy-build-system
+  (build-system
+    (name 'copy)
+    (description "The standard copy build system")
+    (lower lower)))
+
+;;; copy.scm ends here
diff --git a/guix/build/copy-build-system.scm b/guix/build/copy-build-system.scm
new file mode 100644
index 0000000000..a86f0cde29
--- /dev/null
+++ b/guix/build/copy-build-system.scm
@@ -0,0 +1,171 @@
+;;; GNU Guix --- Functional package management for GNU
+;;; Copyright © 2019 Julien Lepiller <julien@lepiller.eu>
+;;; Copyright © 2020 Pierre Neidhardt <mail@ambrevar.xyz>
+;;;
+;;; 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 build copy-build-system)
+  #:use-module ((guix build gnu-build-system) #:prefix gnu:)
+  #:use-module (guix build utils)
+  #:use-module (ice-9 match)
+  #:use-module (ice-9 ftw)
+  #:use-module (srfi srfi-1)
+  #:use-module (srfi srfi-26)
+  #:export (%standard-phases
+            copy-build))
+
+;; Commentary:
+;;
+;; System for building packages that don't require much compilation, mostly
+;; only to copy files around.
+;;
+;; Code:
+
+(define* (install #:key install-plan outputs #:allow-other-keys)
+  "Copy files from the \"source\" build input to the \"out\" output according to INSTALL-PLAN.
+
+An install plan is a list of plans in the form:
+
+  (SOURCE TARGET [FILTERS])
+
+In the above, FILTERS are optional.
+
+- When SOURCE matches a file or directory without trailing slash, install it to
+  TARGET.
+  - If TARGET has a trailing slash, install SOURCE basename beneath TARGET.
+  - Otherwise install SOURCE as TARGET.
+
+- When SOURCE is a directory with a trailing slash, or when FILTERS are used,
+  the trailing slash of TARGET is implied.
+  - Without FILTERS, install the full SOURCE _content_ to TARGET.
+    The paths relative to SOURCE are preserved within TARGET.
+  - With FILTERS among `#:include`, `#:include-regexp`, `#:exclude`,
+    `#:exclude-regexp`:
+    - With `#:include`, install only the paths which suffix exactly matches
+      one of the elements in the list.
+    - With `#:include-regexp`, install subpaths matching the regexps in the list.
+    - The `#:exclude*` FILTERS work similarly.  Without `#:include*` flags,
+      install every subpath but the files matching the `#:exlude*` filters.
+      If both `#:include*` and `#:exclude*` are specified, the exclusion is done
+      on the inclusion list.
+
+Examples:
+
+- `(\"foo/bar\" \"share/my-app/\")`: Install bar to \"share/my-app/bar\".
+- `(\"foo/bar\" \"share/my-app/baz\")`: Install bar to \"share/my-app/baz\".
+- `(\"foo/\" \"share/my-app\")`: Install the content of foo inside \"share/my-app\",
+  e.g. install \"foo/sub/file\" to \"share/my-app/sub/file\".
+- `(\"foo/\" \"share/my-app\" #:include (\"sub/file\"))`: Install only \"foo/sub/file\" to
+\"share/my-app/sub/file\".
+- `(\"foo/sub\" \"share/my-app\" #:include (\"file\"))`: Install \"foo/sub/file\" to
+\"share/my-app/file\"."
+  (define (install-simple source target)
+    "Install SOURCE to TARGET.
+TARGET must point to a store location.
+SOURCE may be a file or a directory.
+If a directory, the directory itself is installed, not its content.
+if TARGET ends with a '/', the source is installed underneath."
+    (let ((target (if (string-suffix? "/" target)
+                      (string-append target (basename source))
+                      target)))
+      (mkdir-p (dirname target))
+      (copy-recursively source target)))
+
+  (define (install-file file target)
+    (let ((dest (string-append target
+                               (if (string-suffix? "/" target)
+                                   (string-append "/" file)
+                                   file))))
+      (format (current-output-port) "`~a' -> `~a'~%" file dest)
+      (mkdir-p (dirname dest))
+      (let ((stat (lstat file)))
+        (case (stat:type stat)
+          ((symlink)
+           (let ((target (readlink file)))
+             (symlink target dest)))
+          (else
+           (copy-file file dest))))))
+
+  (define* (make-file-predicate suffixes matches-regexp #:optional (default-value #t))
+    "Return a predicate that returns #t if its file argument matches the
+SUFFIXES or the MATCHES-REGEXP.  If neither SUFFIXES nor MATCHES-REGEXP is
+given, then the predicate always returns DEFAULT-VALUE."
+    (if (or suffixes matches-regexp)
+        (let* ((suffixes (or suffixes '()))
+               (regexps (map make-regexp (or matches-regexp '())))
+               (predicates (append
+                            (map (lambda (str)
+                                   (cut string-suffix? str <>))
+                                 suffixes)
+                            (map (lambda (regexp)
+                                   (cut regexp-exec regexp <>))
+                                 regexps))))
+          (lambda (file)
+            (any (cut <> file) predicates)))
+        (const default-value)))
+
+  (define* (install-file-list source target #:key include exclude include-regexp exclude-regexp)
+    ;; We must use switch current directory to source so that `find-files'
+    ;; returns file paths relative to source.
+    (with-directory-excursion source
+      (let* ((exclusion-pred (negate (make-file-predicate exclude exclude-regexp #f)))
+             (inclusion-pred (make-file-predicate include include-regexp))
+             (file-list
+              (filter! exclusion-pred
+                       (find-files "." (lambda (file _stat)
+                                         (inclusion-pred file))))))
+        (map (cut install-file <> (if (string-suffix? "/" target)
+                                      target
+                                      (string-append target "/")))
+             file-list))))
+
+  (define* (install source target #:key include exclude include-regexp exclude-regexp)
+    (set! target (string-append (assoc-ref outputs "out") "/" target))
+    (let ((filters? (or include exclude include-regexp exclude-regexp)))
+      (when (and (not (file-is-directory? source))
+                 filters?)
+        (error "Cannot use filters when SOURCE is a file."))
+      (let ((multi-files-in-source?
+             (or (string-suffix? "/" source)
+                 (and (file-is-directory? source)
+                      filters?))))
+        (if multi-files-in-source?
+            (install-file-list source target
+                               #:include include
+                               #:exclude exclude
+                               #:include-regexp include-regexp
+                               #:exclude-regexp exclude-regexp)
+            (install-simple source target)))))
+
+  (for-each (lambda (plan) (apply install plan)) install-plan)
+  #t)
+
+(define %standard-phases
+  ;; Everything is as with the GNU Build System except for the `configure'
+  ;; , `build', `check' and `install' phases.
+  (modify-phases gnu:%standard-phases
+    (delete 'bootstrap)
+    (delete 'configure)
+    (delete 'build)
+    (delete 'check)
+    (replace 'install install)))
+
+(define* (copy-build #:key inputs (phases %standard-phases)
+                     #:allow-other-keys #:rest args)
+  "Build the given package, applying all of PHASES in order."
+  (apply gnu:gnu-build #:inputs inputs #:phases phases args))
+
+;;; copy-build-system.scm ends here
diff --git a/guix/build/emacs-build-system.scm b/guix/build/emacs-build-system.scm
index 09de244993..219310cf08 100644
--- a/guix/build/emacs-build-system.scm
+++ b/guix/build/emacs-build-system.scm
@@ -225,6 +225,21 @@ parallel. PARALLEL-TESTS? is ignored when using a non-make TEST-COMMAND."
     (parameterize ((%emacs emacs))
       (emacs-generate-autoloads elpa-name site-lisp))))
 
+(define* (enable-autoloads-compilation #:key outputs #:allow-other-keys)
+  "Remove the NO-BYTE-COMPILATION local variable embedded in the generated
+autoload files."
+  (let* ((out (assoc-ref outputs "out"))
+         (autoloads (find-files out "-autoloads.el$")))
+    (substitute* autoloads
+      ((";; no-byte-compile.*") ""))
+    #t))
+
+(define* (validate-compiled-autoloads #:key outputs #:allow-other-keys)
+  "Verify whether the byte compiled autoloads load fine."
+  (let* ((out (assoc-ref outputs "out"))
+         (autoloads (find-files out "-autoloads.elc$")))
+    (emacs-batch-eval (format #f "(mapc #'load '~s)" autoloads))))
+
 (define (emacs-package? name)
   "Check if NAME correspond to the name of an Emacs package."
   (string-prefix? "emacs-" name))
@@ -253,10 +268,13 @@ second hyphen.  This corresponds to 'name-version' as used in ELPA packages."
     (replace 'check check)
     (replace 'install install)
     (add-after 'install 'make-autoloads make-autoloads)
-    (add-after 'make-autoloads 'patch-el-files patch-el-files)
+    (add-after 'make-autoloads 'enable-autoloads-compilation
+      enable-autoloads-compilation)
+    (add-after 'enable-autoloads-compilation 'patch-el-files patch-el-files)
     ;; The .el files are byte compiled directly in the store.
     (add-after 'patch-el-files 'build build)
-    (add-after 'build 'move-doc move-doc)))
+    (add-after 'build 'validate-compiled-autoloads validate-compiled-autoloads)
+    (add-after 'validate-compiled-autoloads 'move-doc move-doc)))
 
 (define* (emacs-build #:key inputs (phases %standard-phases)
                       #:allow-other-keys #:rest args)
diff --git a/guix/build/emacs-utils.scm b/guix/build/emacs-utils.scm
index 885fd0a217..ab64e3714c 100644
--- a/guix/build/emacs-utils.scm
+++ b/guix/build/emacs-utils.scm
@@ -41,16 +41,22 @@
   ;; The `emacs' command.
   (make-parameter "emacs"))
 
+(define (expr->string expr)
+  "Converts EXPR, an expression, into a string."
+  (if (string? expr)
+      expr
+      (format #f "~s" expr)))
+
 (define (emacs-batch-eval expr)
   "Run Emacs in batch mode, and execute the elisp code EXPR."
   (invoke (%emacs) "--quick" "--batch"
-          (format #f "--eval=~S" expr)))
+          (string-append "--eval=" (expr->string expr))))
 
 (define (emacs-batch-edit-file file expr)
   "Load FILE in Emacs using batch mode, and execute the elisp code EXPR."
   (invoke (%emacs) "--quick" "--batch"
           (string-append "--visit=" file)
-          (format #f "--eval=~S" expr)))
+          (string-append "--eval=" (expr->string expr))))
 
 (define (emacs-batch-disable-compilation file)
   (emacs-batch-edit-file file
diff --git a/guix/build/linux-module-build-system.scm b/guix/build/linux-module-build-system.scm
index cd76df2de7..8145d5a724 100644
--- a/guix/build/linux-module-build-system.scm
+++ b/guix/build/linux-module-build-system.scm
@@ -60,15 +60,18 @@
 ;; part.
 (define* (install #:key inputs native-inputs outputs #:allow-other-keys)
   (let* ((out (assoc-ref outputs "out"))
-         (moddir (string-append out "/lib/modules"))
-         (kmod (assoc-ref (or native-inputs inputs) "kmod")))
+         (moddir (string-append out "/lib/modules")))
     ;; Install kernel modules
     (mkdir-p moddir)
     (invoke "make" "-C"
             (string-append (assoc-ref inputs "linux-module-builder")
                            "/lib/modules/build")
             (string-append "M=" (getcwd))
-            (string-append "DEPMOD=" kmod "/bin/depmod")
+            ;; Disable depmod because the Guix system's module directory
+            ;; is an union of potentially multiple packages.  It is not
+            ;; possible to use depmod to usefully calculate a dependency
+            ;; graph while building only one of those packages.
+            "DEPMOD=true"
             (string-append "MODULE_DIR=" moddir)
             (string-append "INSTALL_PATH=" out)
             (string-append "INSTALL_MOD_PATH=" out)
diff --git a/guix/build/node-build-system.scm b/guix/build/node-build-system.scm
index 3c0ac2a12b..7799f03595 100644
--- a/guix/build/node-build-system.scm
+++ b/guix/build/node-build-system.scm
@@ -133,10 +133,7 @@ the @file{bin} directory."
                 (symlink (string-append target "/node_modules/" modulename "/"
 					value)
                          (string-append binaries "/" key))))))
-         binary-configuration))
-      (else
-        (symlink (string-append target "/node_modules/" modulename "/bin")
-		 binaries)))
+         binary-configuration)))
     (when dependencies
       (mkdir-p
         (string-append target "/node_modules/" modulename "/node_modules"))
diff --git a/guix/colors.scm b/guix/colors.scm
index b63ac37027..3031f54799 100644
--- a/guix/colors.scm
+++ b/guix/colors.scm
@@ -131,8 +131,7 @@ that subsequent output will not have any colors in effect."
 
 (define (color-output? port)
   "Return true if we should write colored output to PORT."
-  (and (not (getenv "INSIDE_EMACS"))
-       (not (getenv "NO_COLOR"))
+  (and (not (getenv "NO_COLOR"))
        (isatty?* port)))
 
 (define (coloring-procedure color)
diff --git a/guix/import/github.scm b/guix/import/github.scm
index df5f6ff32f..7136e7a34f 100644
--- a/guix/import/github.scm
+++ b/guix/import/github.scm
@@ -154,18 +154,16 @@ empty list."
     ;; Ask for version 3 of the API as suggested at
     ;; <https://developer.github.com/v3/>.
     `((Accept . "application/vnd.github.v3+json")
-      (user-agent . "GNU Guile")))
+      (user-agent . "GNU Guile")
+      ,@(if (%github-token)
+            `((Authorization . ,(string-append "token " (%github-token))))
+            '())))
 
-  (define (decorate url)
-    (if (%github-token)
-        (string-append url "?access_token=" (%github-token))
-        url))
-
-  (match (json-fetch (decorate release-url) #:headers headers)
+  (match (json-fetch release-url #:headers headers)
     (#()
      ;; We got the empty list, presumably because the user didn't use GitHub's
      ;; "release" mechanism, but hopefully they did use Git tags.
-     (json-fetch (decorate tag-url) #:headers headers))
+     (json-fetch tag-url #:headers headers))
     (x x)))
 
 (define (latest-released-version url package-name)
diff --git a/guix/import/pypi.scm b/guix/import/pypi.scm
index 6897f42be3..10450155a0 100644
--- a/guix/import/pypi.scm
+++ b/guix/import/pypi.scm
@@ -6,6 +6,7 @@
 ;;; Copyright © 2018 Ricardo Wurmus <rekado@elephly.net>
 ;;; Copyright © 2019 Maxim Cournoyer <maxim.cournoyer@gmail.com>
 ;;; Copyright © 2020 Jakub Kądziołka <kuba@kadziolka.net>
+;;; Copyright © 2020 Lars-Dominik Braun <ldb@leibniz-psychology.org>
 ;;;
 ;;; This file is part of GNU Guix.
 ;;;
@@ -439,10 +440,12 @@ VERSION, SOURCE-URL, HOME-PAGE, SYNOPSIS, DESCRIPTION, and LICENSE."
   (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)
+    ((or "BSD" "BSD-3" "BSD License") license:bsd-3)
+    ("BSD-2-Clause" license:bsd-2)
+    ((or "MIT" "MIT license" "MIT License" "Expat license") license:expat)
     ("Public domain" license:public-domain)
     ((or "Apache License, Version 2.0" "Apache 2.0") license:asl2.0)
+    ("MPL 2.0" license:mpl2.0)
     (_ #f)))
 
 (define (pypi-package? package)
diff --git a/guix/scripts.scm b/guix/scripts.scm
index 77cbf12350..e235c8d4c3 100644
--- a/guix/scripts.scm
+++ b/guix/scripts.scm
@@ -1,5 +1,5 @@
 ;;; GNU Guix --- Functional package management for GNU
-;;; Copyright © 2013, 2014, 2015, 2017, 2018, 2019 Ludovic Courtès <ludo@gnu.org>
+;;; Copyright © 2013, 2014, 2015, 2017, 2018, 2019, 2020 Ludovic Courtès <ludo@gnu.org>
 ;;; Copyright © 2014 Deck Pickard <deck.r.pickard@gmail.com>
 ;;; Copyright © 2015, 2016 Alex Kost <alezost@gmail.com>
 ;;;
@@ -181,32 +181,71 @@ Show what and how will/would be built."
     (newline (guix-warning-port))))
 
 (define %disk-space-warning
-  ;; The fraction (between 0 and 1) of free disk space below which a warning
-  ;; is emitted.
-  (make-parameter (match (and=> (getenv "GUIX_DISK_SPACE_WARNING")
-                                string->number)
-                    (#f        .05)               ;5%
-                    (threshold (/ threshold 100.)))))
+  ;; Return a pair of absolute threshold (number of bytes) and relative
+  ;; threshold (fraction between 0 and 1) for the free disk space below which
+  ;; a warning is emitted.
+  ;; GUIX_DISK_SPACE_WARNING can contain both thresholds.  A value in [0;100)
+  ;; is a relative threshold, otherwise it's absolute.  The following
+  ;; example values are valid:
+  ;; - 1GiB;10%      ;1 GiB absolute, and 10% relative.
+  ;; - 15G           ;15 GiB absolute, and default relative.
+  ;; - 99%           ;99% relative, and default absolute.
+  ;; - 99            ;Same.
+  ;; - 100           ;100 absolute, and default relative.
+  (let* ((default-absolute-threshold (size->number "5GiB"))
+         (default-relative-threshold 0.05)
+         (percentage->float (lambda (percentage)
+                              (or (and=> (string->number
+                                          (car (string-split percentage #\%)))
+                                         (lambda (n) (/ n 100.0)))
+                                  default-relative-threshold)))
+         (size->number* (lambda (size)
+                          (or (false-if-exception (size->number size))
+                              default-absolute-threshold)))
+         (absolute? (lambda (size)
+                      (not (or (string-suffix? "%" size)
+                               (false-if-exception (< (size->number size) 100)))))))
+    (make-parameter
+     (match (getenv "GUIX_DISK_SPACE_WARNING")
+       (#f (list default-absolute-threshold
+                 default-relative-threshold))
+       (env-string (match (string-split env-string #\;)
+                     ((threshold)
+                      (if (absolute? threshold)
+                          (list (size->number* threshold)
+                                default-relative-threshold)
+                          (list default-absolute-threshold
+                                (percentage->float threshold))))
+                     ((threshold1 threshold2)
+                      (if (absolute? threshold1)
+                          (list (size->number* threshold1)
+                                (percentage->float threshold2))
+                          (list (size->number* threshold2)
+                                (percentage->float threshold1))))))))))
 
 (define* (warn-about-disk-space #:optional profile
                                 #:key
-                                (threshold (%disk-space-warning)))
+                                (thresholds (%disk-space-warning)))
   "Display a hint about 'guix gc' if less than THRESHOLD of /gnu/store is
-available."
+available.
+THRESHOLDS is a pair (ABSOLUTE-THRESHOLD . RELATIVE-THRESHOLD)."
+  (define GiB (expt 2 30))
+
   (let* ((stats      (statfs (%store-prefix)))
          (block-size (file-system-block-size stats))
          (available  (* block-size (file-system-blocks-available stats)))
          (total      (* block-size (file-system-block-count stats)))
-         (ratio      (/ available total 1.)))
-    (when (< ratio threshold)
-      (warning (G_ "only ~,1f% of free space available on ~a~%")
-               (* ratio 100) (%store-prefix))
+         (relative-threshold-in-bytes (* total (cadr thresholds)))
+         (absolute-threshold-in-bytes (car thresholds)))
+    (when (< available (max relative-threshold-in-bytes
+                            absolute-threshold-in-bytes))
+      (warning (G_ "only ~,1f GiB of free space available on ~a~%")
+               (/ available 1. GiB) (%store-prefix))
       (display-hint (format #f (G_ "Consider deleting old profile
 generations and collecting garbage, along these lines:
 
 @example
 guix gc --delete-generations=1m
-@end example\n")
-                            profile)))))
+@end example\n"))))))
 
 ;;; scripts.scm ends here
diff --git a/guix/scripts/package.scm b/guix/scripts/package.scm
index 1cb0d382bf..d2f4f1ccd3 100644
--- a/guix/scripts/package.scm
+++ b/guix/scripts/package.scm
@@ -81,12 +81,15 @@
   "Ensure the default profile symlink and directory exist and are writable."
   (ensure-profile-directory)
 
-  ;; Create ~/.guix-profile if it doesn't exist yet.
+  ;; Try to create ~/.guix-profile if it doesn't exist yet.
   (when (and %user-profile-directory
              %current-profile
              (not (false-if-exception
                    (lstat %user-profile-directory))))
-    (symlink %current-profile %user-profile-directory)))
+    (catch 'system-error
+      (lambda ()
+        (symlink %current-profile %user-profile-directory))
+      (const #t))))
 
 (define (delete-generations store profile generations)
   "Delete GENERATIONS from PROFILE.
diff --git a/guix/scripts/system.scm b/guix/scripts/system.scm
index e69a3b6c97..ac2475c551 100644
--- a/guix/scripts/system.scm
+++ b/guix/scripts/system.scm
@@ -517,12 +517,7 @@ list of services."
               (cond ((uuid? root-device) 0)
                     ((file-system-label? root-device) 1)
                     (else 2))
-              (cond ((uuid? root-device)
-                     (uuid->string root-device))
-                    ((file-system-label? root-device)
-                     (file-system-label->string root-device))
-                    (else
-                     root-device)))
+              (file-system-device->string root-device))
 
       (format #t (G_ "  kernel: ~a~%") kernel)
 
@@ -571,6 +566,8 @@ any, are available.  Raise an error if they're not."
               (and (file-system-mount? fs)
                    (not (member (file-system-type fs)
                                 %pseudo-file-system-types))
+                   ;; Don't try to validate network file systems.
+                   (not (string-prefix? "nfs" (file-system-type fs)))
                    (not (memq 'bind-mount (file-system-flags fs)))))
             file-systems))
 
diff --git a/guix/ssh.scm b/guix/ssh.scm
index 291ce20b61..56b49b177f 100644
--- a/guix/ssh.scm
+++ b/guix/ssh.scm
@@ -157,11 +157,16 @@ server at '~a': ~a")
           (session-set! session 'timeout timeout)
           session)
          (x
-          (disconnect! session)
-          (raise (condition
-                  (&message
-                   (message (format #f (G_ "SSH authentication failed for '~a': ~a~%")
-                                    host (get-error session)))))))))
+          (match (userauth-gssapi! session)
+            ('success
+             (session-set! session 'timeout timeout)
+             session)
+            (x
+             (disconnect! session)
+             (raise (condition
+                     (&message
+                      (message (format #f (G_ "SSH authentication failed for '~a': ~a~%")
+                                       host (get-error session)))))))))))
       (x
        ;; Connection failed or timeout expired.
        (raise (condition
diff --git a/guix/store/deduplication.scm b/guix/store/deduplication.scm
index d42c40932c..80868692c0 100644
--- a/guix/store/deduplication.scm
+++ b/guix/store/deduplication.scm
@@ -1,6 +1,6 @@
 ;;; GNU Guix --- Functional package management for GNU
 ;;; Copyright © 2017 Caleb Ristvedt <caleb.ristvedt@cune.org>
-;;; Copyright © 2018, 2019 Ludovic Courtès <ludo@gnu.org>
+;;; Copyright © 2018, 2019, 2020 Ludovic Courtès <ludo@gnu.org>
 ;;;
 ;;; This file is part of GNU Guix.
 ;;;
@@ -23,7 +23,7 @@
 (define-module (guix store deduplication)
   #:use-module (gcrypt hash)
   #:use-module (guix build utils)
-  #:use-module (guix base16)
+  #:use-module (guix base32)
   #:use-module (srfi srfi-11)
   #:use-module (rnrs io ports)
   #:use-module (ice-9 ftw)
@@ -140,7 +140,7 @@ PATH so that future duplicates can hardlink to it.  PATH is assumed to be
 under STORE."
   (let* ((links-directory (string-append store "/.links"))
          (link-file       (string-append links-directory "/"
-                                         (bytevector->base16-string hash))))
+                                         (bytevector->nix-base32-string hash))))
     (mkdir-p links-directory)
     (if (eq? 'directory (stat:type (lstat path)))
         ;; Can't hardlink directories, so hardlink their atoms.
diff --git a/guix/swh.scm b/guix/swh.scm
index 8bdf9965f6..ec744fed2f 100644
--- a/guix/swh.scm
+++ b/guix/swh.scm
@@ -1,5 +1,6 @@
 ;;; GNU Guix --- Functional package management for GNU
 ;;; Copyright © 2018, 2019, 2020 Ludovic Courtès <ludo@gnu.org>
+;;; Copyright © 2020 Jakub Kądziołka <kuba@kadziolka.net>
 ;;;
 ;;; This file is part of GNU Guix.
 ;;;
@@ -126,9 +127,16 @@
   (make-parameter "https://archive.softwareheritage.org"))
 
 (define (swh-url path . rest)
+  ;; URLs returned by the API may be relative or absolute. This has changed
+  ;; without notice before. Handle both cases by detecting whether the path
+  ;; starts with a domain.
+  (define root
+    (if (string-prefix? "/" path)
+      (string-append (%swh-base-url) path)
+      path))
+
   (define url
-    (string-append (%swh-base-url) path
-                   (string-join rest "/" 'prefix)))
+    (string-append root (string-join rest "/" 'prefix)))
 
   ;; Ensure there's a trailing slash or we get a redirect.
   (if (string-suffix? "/" url)
diff --git a/guix/ui.scm b/guix/ui.scm
index dce97fb7b9..fbe2b70485 100644
--- a/guix/ui.scm
+++ b/guix/ui.scm
@@ -591,7 +591,8 @@ nicely."
 \"1MiB\", to a number of bytes.  Raise an error if STR could not be
 interpreted."
   (define unit-pos
-    (string-rindex str char-set:digit))
+    (string-rindex str
+                   (char-set-union (char-set #\.) char-set:digit)))
 
   (define unit
     (and unit-pos (substring str (+ 1 unit-pos))))
@@ -1472,7 +1473,8 @@ them.  If PORT is a terminal, print at most a full screen of results."
                                  #:hyperlinks? links?
                                  #:extra-fields
                                  `((relevance . ,score)))))))
-         (if (and max-rows
+         (if (and (not (getenv "INSIDE_EMACS"))
+                  max-rows
                   (> (port-line port) first-line) ;print at least one result
                   (> (+ 4 (line-count text) (port-line port))
                      max-rows))