guix/ui.scm

   1 ;;; GNU Guix --- Functional package management for GNU
   2 ;;; Copyright © 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 Ludovic Courtès <ludo@gnu.org>
   3 ;;; Copyright © 2013, 2018 Mark H Weaver <mhw@netris.org>
   4 ;;; Copyright © 2013 Nikita Karetnikov <nikita@karetnikov.org>
   5 ;;; Copyright © 2014 Cyril Roelandt <tipecaml@gmail.com>
   6 ;;; Copyright © 2014 Cyrill Schenkel <cyrill.schenkel@gmail.com>
   7 ;;; Copyright © 2014, 2015, 2017 Alex Kost <alezost@gmail.com>
   8 ;;; Copyright © 2015 David Thompson <davet@gnu.org>
   9 ;;; Copyright © 2015, 2016 Mathieu Lirzin <mthl@gnu.org>
  10 ;;; Copyright © 2016 Roel Janssen <roel@gnu.org>
  11 ;;; Copyright © 2016 Benz Schenk <benz.schenk@uzh.ch>
  12 ;;; Copyright © 2018 Kyle Meyer <kyle@kyleam.com>
  13 ;;; Copyright © 2018 Ricardo Wurmus <rekado@elephly.net>
  14 ;;; Copyright © 2019 Chris Marusich <cmmarusich@gmail.com>
  15 ;;; Copyright © 2019 Tobias Geerinckx-Rice <me@tobias.gr>
  16 ;;; Copyright © 2019 Simon Tournier <zimon.toutoune@gmail.com>
  17 ;;; Copyright © 2020 Arun Isaac <arunisaac@systemreboot.net>
  18 ;;;
  19 ;;; This file is part of GNU Guix.
  20 ;;;
  21 ;;; GNU Guix is free software; you can redistribute it and/or modify it
  22 ;;; under the terms of the GNU General Public License as published by
  23 ;;; the Free Software Foundation; either version 3 of the License, or (at
  24 ;;; your option) any later version.
  25 ;;;
  26 ;;; GNU Guix is distributed in the hope that it will be useful, but
  27 ;;; WITHOUT ANY WARRANTY; without even the implied warranty of
  28 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  29 ;;; GNU General Public License for more details.
  30 ;;;
  31 ;;; You should have received a copy of the GNU General Public License
  32 ;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.
  33
  34 (define-module (guix ui)
  35   #:use-module (guix i18n)
  36   #:use-module (guix colors)
  37   #:use-module (guix diagnostics)
  38   #:use-module (guix gexp)
  39   #:use-module (guix sets)
  40   #:use-module (guix utils)
  41   #:use-module (guix store)
  42   #:use-module (guix config)
  43   #:use-module (guix packages)
  44   #:use-module (guix profiles)
  45   #:use-module (guix derivations)
  46   #:use-module (guix build-system)
  47   #:use-module (guix serialization)
  48   #:use-module ((guix licenses)
  49                 #:select (license? license-name license-uri))
  50   #:use-module ((guix build syscalls)
  51                 #:select (free-disk-space terminal-columns terminal-rows
  52                           with-file-lock/no-wait))
  53   #:use-module ((guix build utils)
  54                 ;; XXX: All we need are the bindings related to
  55                 ;; '&invoke-error'.  However, to work around the bug described
  56                 ;; in 5d669883ecc104403c5d3ba7d172e9c02234577c, #:hide
  57                 ;; unwanted bindings instead of #:select'ing the needed
  58                 ;; bindings.
  59                 #:hide (package-name->name+version
  60                         ;; Avoid "overrides core binding" warning.
  61                         delete))
  62   #:use-module (srfi srfi-1)
  63   #:use-module (srfi srfi-11)
  64   #:use-module (srfi srfi-19)
  65   #:use-module (srfi srfi-26)
  66   #:use-module (srfi srfi-31)
  67   #:use-module (srfi srfi-34)
  68   #:use-module (srfi srfi-35)
  69   #:autoload   (ice-9 ftw)  (scandir)
  70   #:use-module (ice-9 match)
  71   #:use-module (ice-9 format)
  72   #:use-module (ice-9 regex)
  73   #:autoload   (ice-9 popen) (open-pipe* close-pipe)
  74   #:autoload   (system base compile) (compile-file)
  75   #:autoload   (system repl repl)  (start-repl)
  76   #:autoload   (system repl debug) (make-debug stack->vector)
  77   #:autoload   (web uri) (encode-and-join-uri-path)
  78   #:use-module (texinfo)
  79   #:use-module (texinfo plain-text)
  80   #:use-module (texinfo string-utils)
  81
  82   ;; Re-exports for backward compatibility.
  83   #:re-export (G_ N_ P_                           ;now in (guix i18n)
  84
  85                warning info report-error leave    ;now in (guix diagnostics)
  86                location->string
  87                guix-warning-port program-name)
  88   #:export (display-hint
  89             make-user-module
  90             load*
  91             warn-about-load-error
  92             show-version-and-exit
  93             show-bug-report-information
  94             make-regexp*
  95             string->number*
  96             size->number
  97             show-derivation-outputs
  98             build-notifier
  99             show-what-to-build
 100             show-what-to-build*
 101             show-manifest-transaction
 102             call-with-error-handling
 103             with-error-handling
 104             with-unbound-variable-handling
 105             leave-on-EPIPE
 106             read/eval
 107             read/eval-package-expression
 108             check-available-space
 109             indented-string
 110             fill-paragraph
 111             %text-width
 112             texi->plain-text
 113             package-description-string
 114             package-synopsis-string
 115             string->recutils
 116             package->recutils
 117             package-specification->name+version+output
 118
 119             supports-hyperlinks?
 120             hyperlink
 121             file-hyperlink
 122             location->hyperlink
 123
 124             with-paginated-output-port
 125             relevance
 126             package-relevance
 127             display-search-results
 128
 129             with-profile-lock
 130             string->generations
 131             string->duration
 132             matching-generations
 133             display-generation
 134             display-profile-content
 135             display-profile-content-diff
 136             roll-back*
 137             switch-to-generation*
 138             delete-generation*
 139
 140             %default-message-language
 141             current-message-language
 142
 143             run-guix-command
 144             run-guix
 145             guix-main))
 146
 147 ;;; Commentary:
 148 ;;;
 149 ;;; User interface facilities for command-line tools.
 150 ;;;
 151 ;;; Code:
 152
 153 (define (print-unbound-variable-error port key args default-printer)
 154   ;; Print unbound variable errors more nicely, and in the right language.
 155   (match args
 156     ((proc message (variable) _ ...)
 157      ;; We can always omit PROC because when it's useful (i.e., different from
 158      ;; "module-lookup"), it gets displayed before.
 159      (format port (G_ "error: ~a: unbound variable") variable))
 160     (_
 161      (default-printer))))
 162
 163 (set-exception-printer! 'unbound-variable print-unbound-variable-error)
 164
 165 (define (make-user-module modules)
 166   "Return a new user module with the additional MODULES loaded."
 167   ;; Module in which the machine description file is loaded.
 168   (let ((module (make-fresh-user-module)))
 169     (for-each (lambda (iface)
 170                 (module-use! module (resolve-interface iface)))
 171               modules)
 172     module))
 173
 174 (define (last-frame-with-source stack)
 175   "Walk stack upwards and return the last frame that has source location
 176 information, or #f if it could not be found."
 177   (define (frame-with-source frame)
 178     ;; Walk from FRAME upwards until source location information is found.
 179     (let loop ((frame    frame)
 180                (previous frame))
 181       (if (not frame)
 182           previous
 183
 184           ;; On Guile 3, the latest frame with source may be that of
 185           ;; 'raise-exception' in boot-9.scm.  Skip it.
 186           (if (and (frame-source frame)
 187                    (not (eq? 'raise-exception (frame-procedure-name frame))))
 188               frame
 189               (loop (frame-previous frame) frame)))))
 190
 191   (let* ((depth (stack-length stack))
 192          (last  (and (> depth 0) (stack-ref stack 0))))
 193     (frame-with-source (if (> depth 1)
 194                            (stack-ref stack 1)    ;skip the 'throw' frame
 195                            last))))
 196
 197 (define* (load* file user-module
 198                 #:key (on-error 'nothing-special))
 199   "Load the user provided Scheme source code FILE."
 200   (define (error-string frame args)
 201     (call-with-output-string
 202       (lambda (port)
 203         (apply display-error frame port (cdr args)))))
 204
 205   (define tag
 206     (make-prompt-tag "user-code"))
 207
 208   (catch #t
 209     (lambda ()
 210       ;; XXX: Force a recompilation to avoid ABI issues.
 211       ;;
 212       ;; In 2.2.3, the bogus answer to <https://bugs.gnu.org/29226> was to
 213       ;; ignore all available .go, not just those from ~/.cache, which in turn
 214       ;; meant that we had to rebuild *everything*.  Since this is too costly,
 215       ;; we have to turn off '%fresh-auto-compile' with that version, so to
 216       ;; avoid ABI breakage in the user's config file, we explicitly compile
 217       ;; it (the problem remains if the user's config is spread on several
 218       ;; modules.)  See <https://bugs.gnu.org/29881>.
 219       (unless (string=? (version) "2.2.3")
 220         (set! %fresh-auto-compile #t))
 221
 222       (set! %load-should-auto-compile #t)
 223
 224       (save-module-excursion
 225        (lambda ()
 226          (set-current-module user-module)
 227
 228          ;; Hide the "auto-compiling" messages.
 229          (parameterize ((current-warning-port (%make-void-port "w")))
 230            (call-with-prompt tag
 231              (lambda ()
 232                (when (string=? (version) "2.2.3")
 233                  (catch 'system-error
 234                    (lambda ()
 235                      (compile-file file #:env user-module))
 236                    (const #f)))              ;EACCES maybe, let's interpret it
 237
 238                ;; Give 'load' an absolute file name so that it doesn't try to
 239                ;; search for FILE in %LOAD-PATH.  Note: use 'load', not
 240                ;; 'primitive-load', so that FILE is compiled, which then allows
 241                ;; us to provide better error reporting with source line numbers.
 242                (load (canonicalize-path file)))
 243              (const #f))))))
 244     (lambda _
 245       ;; XXX: Errors are reported from the pre-unwind handler below, but
 246       ;; calling 'exit' from there has no effect, so we call it here.
 247       (exit 1))
 248     (rec (handle-error . args)
 249          ;; Capture the stack up to this procedure call, excluded, and pass
 250          ;; the faulty stack frame to 'report-load-error'.
 251          (let* ((stack (make-stack #t handle-error tag))
 252                 (frame (last-frame-with-source stack)))
 253
 254            (report-load-error file args frame)
 255
 256            (case on-error
 257              ((debug)
 258               (newline)
 259               (display (G_ "entering debugger; type ',bt' for a backtrace\n"))
 260               (start-repl #:debug (make-debug (stack->vector stack) 0
 261                                               (error-string frame args)
 262                                               #f)))
 263              ((backtrace)
 264               (newline (current-error-port))
 265               (display-backtrace stack (current-error-port)))
 266              (else
 267               #t))))))
 268
 269 (define (known-variable-definition variable)
 270   "Search among the currently loaded modules one that defines a variable named
 271 VARIABLE and return it, or #f if none was found."
 272   (define (module<? m1 m2)
 273     (match (module-name m2)
 274       (('gnu _ ...) #t)
 275       (('guix _ ...)
 276        (match (module-name m1)
 277          (('gnu _ ...) #f)
 278          (_ #t)))
 279       (_ #f)))
 280
 281   (let loop ((modules     (list (resolve-module '() #f #f #:ensure #f)))
 282              (suggestions '())
 283              (visited     (setq)))
 284     (match modules
 285       (()
 286        ;; Pick the "best" suggestion.
 287        (match (sort suggestions module<?)
 288          (() #f)
 289          ((first _ ...) first)))
 290       ((head tail ...)
 291        (if (set-contains? visited head)
 292            (loop tail suggestions visited)
 293            (let ((visited (set-insert head visited))
 294                  (next    (append tail
 295                                   (hash-map->list (lambda (name module)
 296                                                     module)
 297                                                   (module-submodules head)))))
 298              (match (module-local-variable head variable)
 299                (#f (loop next suggestions visited))
 300                (_
 301                 (match (module-name head)
 302                   (('gnu _ ...) head)             ;must be that one
 303                   (_ (loop next (cons head suggestions) visited)))))))))))
 304
 305 (define %hint-color (color BOLD CYAN))
 306
 307 (define* (display-hint message #:optional (port (current-error-port)))
 308   "Display MESSAGE, a l10n message possibly containing Texinfo markup, to
 309 PORT."
 310   (define colorize
 311     (if (color-output? port)
 312         (lambda (str)
 313           (colorize-string str %hint-color))
 314         identity))
 315
 316   (display (colorize (G_ "hint: ")) port)
 317   (display
 318    ;; XXX: We should arrange so that the initial indent is wider.
 319    (parameterize ((%text-width (max 15 (- (terminal-columns) 5))))
 320      (texi->plain-text message))
 321    port))
 322
 323 (define* (report-unbound-variable-error args #:key frame)
 324   "Return the given unbound-variable error, where ARGS is the list of 'throw'
 325 arguments."
 326   (match args
 327     ((key . args)
 328      (print-exception (current-error-port) frame key args)))
 329   (match args
 330     (('unbound-variable proc message (variable) _ ...)
 331      (match (known-variable-definition variable)
 332        (#f
 333         (display-hint (G_ "Did you forget a @code{use-modules} form?")))
 334        ((? module? module)
 335         (display-hint (format #f (G_ "Did you forget @code{(use-modules ~a)}?")
 336                               (module-name module))))))))
 337
 338 (define (check-module-matches-file module file)
 339   "Check whether FILE starts with 'define-module MODULE' and print a hint if
 340 it doesn't."
 341   ;; This is a common mistake when people start writing their own package
 342   ;; definitions and try loading them with 'guix build -L …', so help them
 343   ;; diagnose the problem.
 344   (define (hint)
 345     (display-hint (format #f (G_ "File @file{~a} should probably start with:
 346
 347 @example\n(define-module ~a)\n@end example")
 348                           file module)))
 349
 350   (catch 'system-error
 351     (lambda ()
 352       (let* ((sexp (call-with-input-file file read))
 353              (loc  (and (pair? sexp)
 354                         (source-properties->location (source-properties sexp)))))
 355         (match sexp
 356           (('define-module (names ...) _ ...)
 357            (unless (equal? module names)
 358              (warning loc
 359                       (G_ "module name ~a does not match file name '~a'~%")
 360                       names (module->source-file-name module))
 361              (hint)))
 362           ((? eof-object?)
 363            (warning (G_ "~a: file is empty~%") file))
 364           (else
 365            (hint)))))
 366     (const #f)))
 367
 368 (define* (report-load-error file args #:optional frame)
 369   "Report the failure to load FILE, a user-provided Scheme file.
 370 ARGS is the list of arguments received by the 'throw' handler."
 371   (match args
 372     (('system-error . rest)
 373      (let ((err (system-error-errno args)))
 374        (report-error (G_ "failed to load '~a': ~a~%") file (strerror err))))
 375     (('read-error "scm_i_lreadparen" message _ ...)
 376      ;; Guile's missing-paren messages are obscure so we make them more
 377      ;; intelligible here.
 378      (if (string-suffix? "end of file" message)
 379          (let ((location (string-drop-right message
 380                                             (string-length "end of file"))))
 381            (format (current-error-port) (G_ "~amissing closing parenthesis~%")
 382                    location))
 383          (apply throw args)))
 384     (('syntax-error proc message properties form subform . rest)
 385      (let ((loc (source-properties->location properties)))
 386        (report-error loc (G_ "~s: ~a~%")
 387                      (or subform form) message)))
 388     (('unbound-variable _ ...)
 389      (report-unbound-variable-error args #:frame frame))
 390     (((or 'srfi-34 '%exception) obj)
 391      (if (message-condition? obj)
 392          (report-error (and (error-location? obj)
 393                             (error-location obj))
 394                        (G_ "~a~%")
 395                        (gettext (condition-message obj) %gettext-domain))
 396          (report-error (G_ "exception thrown: ~s~%") obj))
 397      (when (fix-hint? obj)
 398        (display-hint (condition-fix-hint obj))))
 399     ((key args ...)
 400      (report-error (G_ "failed to load '~a':~%") file)
 401      (match args
 402        (((? symbol? proc) (? string? message) (args ...) . rest)
 403         (display-error frame (current-error-port) proc message
 404                        args rest))
 405        (_
 406         ;; Some exceptions like 'git-error' do not follow Guile's convention
 407         ;; above and need to be printed with 'print-exception'.
 408         (print-exception (current-error-port) frame key args))))))
 409
 410 (define (warn-about-load-error file module args)  ;FIXME: factorize with ↑
 411   "Report the failure to load FILE, a user-provided Scheme file, without
 412 exiting.  ARGS is the list of arguments received by the 'throw' handler."
 413   (match args
 414     (('system-error . rest)
 415      (let ((err (system-error-errno args)))
 416        (warning (G_ "failed to load '~a': ~a~%") module (strerror err))))
 417     (('syntax-error proc message properties form . rest)
 418      (let ((loc (source-properties->location properties)))
 419        (warning loc (G_ "~a~%") message)))
 420     (('unbound-variable _ ...)
 421      (report-unbound-variable-error args))
 422     (((or 'srfi-34 '%exception) obj)
 423      (if (message-condition? obj)
 424          (warning (G_ "failed to load '~a': ~a~%")
 425                   file
 426                   (gettext (condition-message obj) %gettext-domain))
 427          (warning (G_ "failed to load '~a': exception thrown: ~s~%")
 428                   file obj)))
 429     ((error args ...)
 430      (warning (G_ "failed to load '~a':~%") module)
 431      (apply display-error #f (current-error-port) args)
 432      (check-module-matches-file module file))))
 433
 434 (define (call-with-unbound-variable-handling thunk)
 435   (define tag
 436     (make-prompt-tag "user-code"))
 437
 438   (catch 'unbound-variable
 439     (lambda ()
 440       (call-with-prompt tag
 441         thunk
 442         (const #f)))
 443     (const #t)
 444     (rec (handle-error . args)
 445          (let* ((stack (make-stack #t handle-error tag))
 446                 (frame (and stack (last-frame-with-source stack))))
 447            (report-unbound-variable-error args #:frame frame)
 448            (exit 1)))))
 449
 450 (define-syntax-rule (with-unbound-variable-handling exp ...)
 451   "Capture 'unbound-variable' exceptions in the dynamic extent of EXP... and
 452 report them in a user-friendly way."
 453   (call-with-unbound-variable-handling (lambda () exp ...)))
 454
 455 (define %default-message-language
 456   ;; Default language to use for messages.
 457   (make-parameter "en"))
 458
 459 (define (current-message-language)
 460   "Return the language used for messages according to the current locale.
 461 Return %DEFAULT-MESSAGE-LANGUAGE if that information could not be obtained.  The
 462 result is an ISO-639-2 language code such as \"ar\", without the territory
 463 part."
 464   (let ((locale (setlocale LC_MESSAGES)))
 465     (match (string-index locale #\_)
 466       (#f    locale)
 467       (index (string-take locale index)))))
 468
 469 (define (install-locale)
 470   "Install the current locale settings."
 471   (catch 'system-error
 472     (lambda _
 473       (setlocale LC_ALL ""))
 474     (lambda args
 475       (display-hint (G_ "Consider installing the @code{glibc-utf8-locales} or
 476 @code{glibc-locales} package and defining @code{GUIX_LOCPATH}, along these
 477 lines:
 478
 479 @example
 480 guix package -i glibc-utf8-locales
 481 export GUIX_LOCPATH=\"$HOME/.guix-profile/lib/locale\"
 482 @end example
 483
 484 See the \"Application Setup\" section in the manual, for more info.\n")))))
 485
 486 (define (initialize-guix)
 487   "Perform the usual initialization for stand-alone Guix commands."
 488   ;; By default don't annoy users with deprecation warnings.  In practice,
 489   ;; 'define-deprecated' in (ice-9 deprecated) arranges so that those warnings
 490   ;; are emitted at expansion-time only, but there are cases where they could
 491   ;; slip through, for instance when interpreting code.
 492   (unless (getenv "GUILE_WARN_DEPRECATED")
 493     (debug-disable 'warn-deprecated))
 494
 495   (install-locale)
 496   (textdomain %gettext-domain)
 497
 498   ;; Ignore SIGPIPE.  If the daemon closes the connection, we prefer to be
 499   ;; notified via an EPIPE later.
 500   (sigaction SIGPIPE SIG_IGN)
 501
 502   (setvbuf (current-output-port) 'line)
 503   (setvbuf (current-error-port) 'line))
 504
 505 (define* (show-version-and-exit #:optional (command (car (command-line))))
 506   "Display version information for COMMAND and `(exit 0)'."
 507   (simple-format #t "~a (~a) ~a~%"
 508                  command %guix-package-name %guix-version)
 509   (format #t "Copyright ~a 2020 ~a"
 510           ;; TRANSLATORS: Translate "(C)" to the copyright symbol
 511           ;; (C-in-a-circle), if this symbol is available in the user's
 512           ;; locale.  Otherwise, do not translate "(C)"; leave it as-is.  */
 513           (G_ "(C)")
 514           (G_ "the Guix authors\n"))
 515   (display (G_"\
 516 License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
 517 This is free software: you are free to change and redistribute it.
 518 There is NO WARRANTY, to the extent permitted by law.
 519 "))
 520   (exit 0))
 521
 522 (define (show-bug-report-information)
 523   ;; TRANSLATORS: The placeholder indicates the bug-reporting address for this
 524   ;; package.  Please add another line saying "Report translation bugs to
 525   ;; ...\n" with the address for translation bugs (typically your translation
 526   ;; team's web or email address).
 527   (format #t (G_ "
 528 Report bugs to: ~a.") %guix-bug-report-address)
 529   (format #t (G_ "
 530 ~a home page: <~a>") %guix-package-name %guix-home-page-url)
 531   (display (G_ "
 532 General help using GNU software: <http://www.gnu.org/gethelp/>"))
 533   (newline))
 534
 535 (define (augmented-system-error-handler file)
 536   "Return a 'system-error' handler that mentions FILE in its message."
 537   (lambda (key proc fmt args errno)
 538     ;; Augment the FMT and ARGS with information about TARGET (this
 539     ;; information is missing as of Guile 2.0.11, making the exception
 540     ;; uninformative.)
 541     (apply throw key proc "~A: ~S"
 542            (list (strerror (car errno)) file)
 543            (list errno))))
 544
 545 (define-syntax apply-formals
 546   (syntax-rules ()
 547     ((_ proc (args ...)) (proc args ...))
 548     ((_ proc (arg1 args ... . rest)) (apply proc arg1 args ... rest))))
 549
 550 (define-syntax-rule (error-reporting-wrapper proc formals file)
 551   "Wrap PROC such that its 'system-error' exceptions are augmented to mention
 552 FILE."
 553   (let ((real-proc (@ (guile) proc)))
 554     (lambda formals
 555       (catch 'system-error
 556         (lambda ()
 557           (apply-formals real-proc formals))
 558         (augmented-system-error-handler file)))))
 559
 560 (set! symlink
 561   ;; We 'set!' the global binding because (gnu build ...) modules and similar
 562   ;; typically don't use (guix ui).
 563   (error-reporting-wrapper symlink (source target) target))
 564
 565 (set! copy-file
 566   ;; Note: here we use 'set!', not #:replace, because UIs typically use
 567   ;; 'copy-recursively', which doesn't use (guix ui).
 568   (error-reporting-wrapper copy-file (source target) target))
 569
 570 (set! canonicalize-path
 571   (error-reporting-wrapper canonicalize-path (file) file))
 572
 573 (set! delete-file
 574   (error-reporting-wrapper delete-file (file) file))
 575
 576 (set! execlp
 577   (error-reporting-wrapper execlp (filename . args) filename))
 578
 579 (define (make-regexp* regexp . flags)
 580   "Like 'make-regexp' but error out if REGEXP is invalid, reporting the error
 581 nicely."
 582   (catch 'regular-expression-syntax
 583     (lambda ()
 584       (apply make-regexp regexp flags))
 585     (lambda (key proc message . rest)
 586       (leave (G_ "'~a' is not a valid regular expression: ~a~%")
 587              regexp message))))
 588
 589 (define (string->number* str)
 590   "Like `string->number', but error out with an error message on failure."
 591   (or (string->number str)
 592       (leave (G_ "~a: invalid number~%") str)))
 593
 594 (define (size->number str)
 595   "Convert STR, a storage measurement representation such as \"1024\" or
 596 \"1MiB\", to a number of bytes.  Raise an error if STR could not be
 597 interpreted."
 598   (define unit-pos
 599     (string-rindex str
 600                    (char-set-union (char-set #\.) char-set:digit)))
 601
 602   (define unit
 603     (and unit-pos (substring str (+ 1 unit-pos))))
 604
 605   (let* ((numstr (if unit-pos
 606                      (substring str 0 (+ 1 unit-pos))
 607                      str))
 608          (num    (string->number numstr)))
 609     (unless num
 610       (leave (G_ "invalid number: ~a~%") numstr))
 611
 612     ((compose inexact->exact round)
 613      (* num
 614         (match unit
 615           ((or "KiB" "K" "k") (expt 2 10))
 616           ((or "MiB" "M")     (expt 2 20))
 617           ((or "GiB" "G")     (expt 2 30))
 618           ((or "TiB" "T")     (expt 2 40))
 619           ((or "PiB" "P")     (expt 2 50))
 620           ((or "EiB" "E")     (expt 2 60))
 621           ((or "ZiB" "Z")     (expt 2 70))
 622           ((or "YiB" "Y")     (expt 2 80))
 623           ("kB"  (expt 10 3))
 624           ("MB"  (expt 10 6))
 625           ("GB"  (expt 10 9))
 626           ("TB"  (expt 10 12))
 627           ("PB"  (expt 10 15))
 628           ("EB"  (expt 10 18))
 629           ("ZB"  (expt 10 21))
 630           ("YB"  (expt 10 24))
 631           (""    1)
 632           (x
 633            (leave (G_ "unknown unit: ~a~%") unit)))))))
 634
 635 (define (display-collision-resolution-hint collision)
 636   "Display hints on how to resolve COLLISION, a &profile-collistion-error."
 637   (define (top-most-entry entry)
 638     (let loop ((entry entry))
 639       (match (force (manifest-entry-parent entry))
 640         (#f entry)
 641         (parent (loop parent)))))
 642
 643   (let* ((first  (profile-collision-error-entry collision))
 644          (second (profile-collision-error-conflict collision))
 645          (name1  (manifest-entry-name (top-most-entry first)))
 646          (name2  (manifest-entry-name (top-most-entry second))))
 647     (if (string=? name1 name2)
 648         (display-hint (format #f (G_ "You cannot have two different versions
 649 or variants of @code{~a} in the same profile.")
 650                               name1))
 651         (display-hint (format #f (G_ "Try upgrading both @code{~a} and @code{~a},
 652 or remove one of them from the profile.")
 653                               name1 name2)))))
 654
 655 (cond-expand
 656   (guile-3
 657    ;; On Guile 3.0, in 'call-with-error-handling' we need to re-raise.  To
 658    ;; preserve useful backtraces in case of unhandled errors, we want that to
 659    ;; happen before the stack has been unwound, hence 'guard*'.
 660    (define-syntax-rule (guard* (var clauses ...) exp ...)
 661      "This variant of SRFI-34 'guard' does not unwind the stack before
 662 evaluating the tests and bodies of CLAUSES."
 663      (with-exception-handler
 664          (lambda (var)
 665            (cond clauses ... (else (raise var))))
 666        (lambda () exp ...)
 667        #:unwind? #f)))
 668   (else
 669    (define-syntax-rule (guard* (var clauses ...) exp ...)
 670      (guard (var clauses ...) exp ...))))
 671
 672 (define (call-with-error-handling thunk)
 673   "Call THUNK within a user-friendly error handler."
 674   (define (port-filename* port)
 675     ;; 'port-filename' returns #f for non-file ports, but it raises an
 676     ;; exception for file ports that are closed.  Work around that.
 677     (and (not (port-closed? port))
 678          (port-filename port)))
 679
 680   (guard* (c ((package-input-error? c)
 681               (let* ((package  (package-error-package c))
 682                      (input    (package-error-invalid-input c))
 683                      (location (package-location package))
 684                      (file     (location-file location))
 685                      (line     (location-line location))
 686                      (column   (location-column location)))
 687                 (leave (G_ "~a:~a:~a: package `~a' has an invalid input: ~s~%")
 688                        file line column
 689                        (package-full-name package) input)))
 690              ((package-cross-build-system-error? c)
 691               (let* ((package (package-error-package c))
 692                      (loc     (package-location package))
 693                      (system  (package-build-system package)))
 694                 (leave (G_ "~a: ~a: build system `~a' does not support cross builds~%")
 695                        (location->string loc)
 696                        (package-full-name package)
 697                        (build-system-name system))))
 698              ((gexp-input-error? c)
 699               (let ((input (package-error-invalid-input c)))
 700                 (leave (G_ "~s: invalid G-expression input~%")
 701                        (gexp-error-invalid-input c))))
 702              ((profile-not-found-error? c)
 703               (leave (G_ "profile '~a' does not exist~%")
 704                      (profile-error-profile c)))
 705              ((missing-generation-error? c)
 706               (leave (G_ "generation ~a of profile '~a' does not exist~%")
 707                      (missing-generation-error-generation c)
 708                      (profile-error-profile c)))
 709              ((unmatched-pattern-error? c)
 710               (let ((pattern (unmatched-pattern-error-pattern c)))
 711                 (leave (G_ "package '~a~@[@~a~]~@[:~a~]' not found in profile~%")
 712                        (manifest-pattern-name pattern)
 713                        (manifest-pattern-version pattern)
 714                        (match (manifest-pattern-output pattern)
 715                          ("out" #f)
 716                          (output output)))))
 717              ((profile-collision-error? c)
 718               (let ((entry    (profile-collision-error-entry c))
 719                     (conflict (profile-collision-error-conflict c)))
 720                 (define (report-parent-entries entry)
 721                   (let ((parent (force (manifest-entry-parent entry))))
 722                     (when (manifest-entry? parent)
 723                       (report-error (G_ "   ... propagated from ~a@~a~%")
 724                                     (manifest-entry-name parent)
 725                                     (manifest-entry-version parent))
 726                       (report-parent-entries parent))))
 727
 728                 (define (manifest-entry-output* entry)
 729                   (match (manifest-entry-output entry)
 730                     ("out"   "")
 731                     (output (string-append ":" output))))
 732
 733                 (report-error (G_ "profile contains conflicting entries for ~a~a~%")
 734                               (manifest-entry-name entry)
 735                               (manifest-entry-output* entry))
 736                 (report-error (G_ "  first entry: ~a@~a~a ~a~%")
 737                               (manifest-entry-name entry)
 738                               (manifest-entry-version entry)
 739                               (manifest-entry-output* entry)
 740                               (manifest-entry-item entry))
 741                 (report-parent-entries entry)
 742                 (report-error (G_ "  second entry: ~a@~a~a ~a~%")
 743                               (manifest-entry-name conflict)
 744                               (manifest-entry-version conflict)
 745                               (manifest-entry-output* conflict)
 746                               (manifest-entry-item conflict))
 747                 (report-parent-entries conflict)
 748                 (display-collision-resolution-hint c)
 749                 (exit 1)))
 750              ((nar-error? c)
 751               (let ((file (nar-error-file c))
 752                     (port (nar-error-port c)))
 753                 (if file
 754                     (leave (G_ "corrupt input while restoring '~a' from ~s~%")
 755                            file (or (port-filename* port) port))
 756                     (leave (G_ "corrupt input while restoring archive from ~s~%")
 757                            (or (port-filename* port) port)))))
 758              ((store-connection-error? c)
 759               (leave (G_ "failed to connect to `~a': ~a~%")
 760                      (store-connection-error-file c)
 761                      (strerror (store-connection-error-code c))))
 762              ((store-protocol-error? c)
 763               ;; FIXME: Server-provided error messages aren't i18n'd.
 764               (leave (G_ "~a~%")
 765                      (store-protocol-error-message c)))
 766              ((derivation-missing-output-error? c)
 767               (leave (G_ "reference to invalid output '~a' of derivation '~a'~%")
 768                      (derivation-missing-output c)
 769                      (derivation-file-name (derivation-error-derivation c))))
 770              ((file-search-error? c)
 771               (leave (G_ "file '~a' could not be found in these \
 772 directories:~{ ~a~}~%")
 773                      (file-search-error-file-name c)
 774                      (file-search-error-search-path c)))
 775              ((invoke-error? c)
 776               (leave (G_ "program exited\
 777 ~@[ with non-zero exit status ~a~]\
 778 ~@[ terminated by signal ~a~]\
 779 ~@[ stopped by signal ~a~]: ~s~%")
 780                      (invoke-error-exit-status c)
 781                      (invoke-error-term-signal c)
 782                      (invoke-error-stop-signal c)
 783                      (cons (invoke-error-program c)
 784                            (invoke-error-arguments c))))
 785              ((and (error-location? c) (message-condition? c))
 786               (report-error (error-location c) (G_ "~a~%")
 787                             (gettext (condition-message c) %gettext-domain))
 788               (when (fix-hint? c)
 789                 (display-hint (condition-fix-hint c)))
 790               (exit 1))
 791              ((and (message-condition? c) (fix-hint? c))
 792               (report-error (G_ "~a~%")
 793                             (gettext (condition-message c) %gettext-domain))
 794               (display-hint (condition-fix-hint c))
 795               (exit 1))
 796
 797              ;; On Guile 3.0.0, exceptions such as 'unbound-variable' are
 798              ;; compound and include a '&message'.  However, that message only
 799              ;; contains the format string.  Thus, special-case it here to
 800              ;; avoid displaying a bare format string.
 801              ;;
 802              ;; Furthermore, use of 'guard*' ensures that the stack has not
 803              ;; been unwound when we re-raise, since that would otherwise show
 804              ;; useless backtraces.
 805              ((cond-expand
 806                 (guile-3
 807                  ((exception-predicate &exception-with-kind-and-args) c))
 808                 (else #f))
 809               (raise c))
 810
 811              ((message-condition? c)
 812               ;; Normally '&message' error conditions have an i18n'd message.
 813               (leave (G_ "~a~%")
 814                      (gettext (condition-message c) %gettext-domain))))
 815       ;; Catch EPIPE and the likes.
 816       (catch 'system-error
 817         thunk
 818         (lambda (key proc format-string format-args . rest)
 819           (leave (G_ "~a: ~a~%") proc
 820                  (apply format #f format-string format-args))))))
 821
 822 (define-syntax-rule (leave-on-EPIPE exp ...)
 823   "Run EXP... in a context where EPIPE errors are caught and lead to 'exit'
 824 with successful exit code.  This is useful when writing to the standard output
 825 may lead to EPIPE, because the standard output is piped through 'head' or
 826 similar."
 827   (catch 'system-error
 828     (lambda ()
 829       exp ...)
 830     (lambda args
 831       ;; We really have to exit this brutally, otherwise Guile eventually
 832       ;; attempts to flush all the ports, leading to an uncaught EPIPE down
 833       ;; the path.
 834       (if (= EPIPE (system-error-errno args))
 835           (primitive-_exit 0)
 836           (apply throw args)))))
 837
 838 (define %guix-user-module
 839   ;; Module in which user expressions are evaluated.
 840   ;; Compute lazily to avoid circularity with (guix gexp).
 841   (delay
 842     (let ((module (make-module)))
 843       (beautify-user-module! module)
 844       ;; Use (guix gexp) so that one can use #~ & co.
 845       (module-use! module (resolve-interface '(guix gexp)))
 846       module)))
 847
 848 (define (read/eval str)
 849   "Read and evaluate STR, raising an error if something goes wrong."
 850   (let ((exp (catch #t
 851                (lambda ()
 852                  (call-with-input-string str read))
 853                (lambda args
 854                  (leave (G_ "failed to read expression ~s: ~s~%")
 855                         str args)))))
 856     (catch #t
 857       (lambda ()
 858         (eval exp (force %guix-user-module)))
 859       (lambda args
 860         (report-error (G_ "failed to evaluate expression '~a':~%") exp)
 861         (match args
 862           (('syntax-error proc message properties form . rest)
 863            (report-error (G_ "syntax error: ~a~%") message))
 864           (((or 'srfi-34 '%exception) obj)
 865            (if (message-condition? obj)
 866                (report-error (G_ "~a~%")
 867                              (gettext (condition-message obj)
 868                                       %gettext-domain))
 869                (report-error (G_ "exception thrown: ~s~%") obj)))
 870           ((error args ...)
 871            (apply display-error #f (current-error-port) args))
 872           (what? #f))
 873         (exit 1)))))
 874
 875 (define (read/eval-package-expression str)
 876   "Read and evaluate STR and return the package it refers to, or exit an
 877 error."
 878   (match (read/eval str)
 879     ((? package? p) p)
 880     (x
 881      (leave (G_ "expression ~s does not evaluate to a package~%")
 882             str))))
 883
 884 (define (show-derivation-outputs derivation)
 885   "Show the output file names of DERIVATION, which can be a derivation or a
 886 derivation input."
 887   (define (show-outputs derivation outputs)
 888     (format #t "~{~a~%~}"
 889             (map (cut derivation->output-path derivation <>)
 890                  outputs)))
 891
 892   (match derivation
 893     ((? derivation?)
 894      (show-outputs derivation (derivation-output-names derivation)))
 895     ((? derivation-input? input)
 896      (show-outputs (derivation-input-derivation input)
 897                    (derivation-input-sub-derivations input)))))
 898
 899 (define* (check-available-space need
 900                                 #:optional (directory (%store-prefix)))
 901   "Make sure at least NEED bytes are available in DIRECTORY.  Otherwise emit a
 902 warning."
 903   (let ((free (catch 'system-error
 904                 (lambda ()
 905                   (free-disk-space directory))
 906                 (const #f))))
 907     (when (and free (>= need free))
 908       (warning (G_ "at least ~,1h MB needed but only ~,1h MB available in ~a~%")
 909                (/ need 1e6) (/ free 1e6) directory))))
 910
 911 (define (graft-derivation? drv)
 912   "Return true if DRV is definitely a graft derivation, false otherwise."
 913   (match (assq-ref (derivation-properties drv) 'type)
 914     ('graft #t)
 915     (_ #f)))
 916
 917 (define (profile-hook-derivation? drv)
 918   "Return true if DRV is definitely a profile hook derivation, false otherwise."
 919   (match (assq-ref (derivation-properties drv) 'type)
 920     ('profile-hook #t)
 921     (_ #f)))
 922
 923 (define (colorize-store-file-name file)
 924   "Colorize FILE, a store file name, such that the hash part is less prominent
 925 that the rest."
 926   (let ((len    (string-length file))
 927         (prefix (+ (string-length (%store-prefix)) 32 2)))
 928     (if (< len prefix)
 929         file
 930         (string-append (colorize-string (string-take file prefix)
 931                                         (color DARK))
 932                        (string-drop file prefix)))))
 933
 934 (define* (show-what-to-build store drv
 935                              #:key dry-run? (use-substitutes? #t)
 936                              (mode (build-mode normal)))
 937   "Show what will or would (depending on DRY-RUN?) be built in realizing the
 938 derivations listed in DRV using MODE, a 'build-mode' value.  The elements of
 939 DRV can be either derivations or derivation inputs.
 940
 941 Return two values: a Boolean indicating whether there's something to build,
 942 and a Boolean indicating whether there's something to download.  When
 943 USE-SUBSTITUTES?, check and report what is prerequisites are available for
 944 download."
 945   (define inputs
 946     (map (match-lambda
 947            ((? derivation? drv) (derivation-input drv))
 948            ((? derivation-input? input) input))
 949          drv))
 950
 951   (define substitutable-info
 952     ;; Call 'substitution-oracle' upfront so we don't end up launching the
 953     ;; substituter many times.  This makes a big difference, especially when
 954     ;; DRV is a long list as is the case with 'guix environment'.
 955     (if use-substitutes?
 956         (substitution-oracle store inputs #:mode mode)
 957         (const #f)))
 958
 959   (define colorized-store-item
 960     (if (color-output? (current-error-port))
 961         colorize-store-file-name
 962         identity))
 963
 964   (let*-values (((build/full download)
 965                  (derivation-build-plan store inputs
 966                                         #:mode mode
 967                                         #:substitutable-info
 968                                         substitutable-info))
 969                 ((graft hook build)
 970                  (match (fold (lambda (drv acc)
 971                                 (let ((file (derivation-file-name drv)))
 972                                   (match acc
 973                                     ((#:graft graft #:hook hook #:build build)
 974                                      (cond
 975                                       ((graft-derivation? drv)
 976                                        `(#:graft ,(cons file graft)
 977                                          #:hook ,hook
 978                                          #:build ,build))
 979                                       ((profile-hook-derivation? drv)
 980                                        `(#:graft ,graft
 981                                          #:hook ,(cons file hook)
 982                                          #:build ,build))
 983                                       (else
 984                                        `(#:graft ,graft
 985                                          #:hook ,hook
 986                                          #:build ,(cons file build))))))))
 987                               '(#:graft () #:hook () #:build ())
 988                               build/full)
 989                    ((#:graft graft #:hook hook #:build build)
 990                     (values graft hook build)))))
 991     (define installed-size
 992       (reduce + 0 (map substitutable-nar-size download)))
 993
 994     (define download-size
 995       (/ (reduce + 0 (map substitutable-download-size download))
 996          1e6))
 997
 998     (define display-download-size?
 999       ;; Sometimes narinfos lack information about the download size.  Only
1000       ;; display when we have information for all of DOWNLOAD.
1001       (not (any (compose zero? substitutable-download-size) download)))
1002
1003     (if dry-run?
1004         (begin
1005           (format (current-error-port)
1006                   (N_ "~:[The following derivation would be built:~%~{   ~a~%~}~;~]"
1007                       "~:[The following derivations would be built:~%~{   ~a~%~}~;~]"
1008                       (length build))
1009                   (null? build) (map colorized-store-item build))
1010           (if display-download-size?
1011               (format (current-error-port)
1012                       ;; TRANSLATORS: "MB" is for "megabyte"; it should be
1013                       ;; translated to the corresponding abbreviation.
1014                       (G_ "~:[~,1h MB would be downloaded:~%~{   ~a~%~}~;~]")
1015                       (null? download)
1016                       download-size
1017                       (map (compose colorized-store-item substitutable-path)
1018                            download))
1019               (format (current-error-port)
1020                       (N_ "~:[The following file would be downloaded:~%~{   ~a~%~}~;~]"
1021                           "~:[The following files would be downloaded:~%~{   ~a~%~}~;~]"
1022                           (length download))
1023                       (null? download)
1024                       (map (compose colorized-store-item substitutable-path)
1025                            download)))
1026           (format (current-error-port)
1027                   (N_ "~:[The following graft would be made:~%~{   ~a~%~}~;~]"
1028                       "~:[The following grafts would be made:~%~{   ~a~%~}~;~]"
1029                       (length graft))
1030                   (null? graft) (map colorized-store-item graft))
1031           (format (current-error-port)
1032                   (N_ "~:[The following profile hook would be built:~%~{   ~a~%~}~;~]"
1033                       "~:[The following profile hooks would be built:~%~{   ~a~%~}~;~]"
1034                       (length hook))
1035                   (null? hook) (map colorized-store-item hook)))
1036         (begin
1037           (format (current-error-port)
1038                   (N_ "~:[The following derivation will be built:~%~{   ~a~%~}~;~]"
1039                       "~:[The following derivations will be built:~%~{   ~a~%~}~;~]"
1040                       (length build))
1041                   (null? build) (map colorized-store-item build))
1042           (if display-download-size?
1043               (format (current-error-port)
1044                       ;; TRANSLATORS: "MB" is for "megabyte"; it should be
1045                       ;; translated to the corresponding abbreviation.
1046                       (G_ "~:[~,1h MB will be downloaded:~%~{   ~a~%~}~;~]")
1047                       (null? download)
1048                       download-size
1049                       (map (compose colorized-store-item substitutable-path)
1050                            download))
1051               (format (current-error-port)
1052                       (N_ "~:[The following file will be downloaded:~%~{   ~a~%~}~;~]"
1053                           "~:[The following files will be downloaded:~%~{   ~a~%~}~;~]"
1054                           (length download))
1055                       (null? download)
1056                       (map (compose colorized-store-item substitutable-path)
1057                            download)))
1058           (format (current-error-port)
1059                   (N_ "~:[The following graft will be made:~%~{   ~a~%~}~;~]"
1060                       "~:[The following grafts will be made:~%~{   ~a~%~}~;~]"
1061                       (length graft))
1062                   (null? graft) (map colorized-store-item graft))
1063           (format (current-error-port)
1064                   (N_ "~:[The following profile hook will be built:~%~{   ~a~%~}~;~]"
1065                       "~:[The following profile hooks will be built:~%~{   ~a~%~}~;~]"
1066                       (length hook))
1067                   (null? hook) (map colorized-store-item hook))))
1068
1069     (check-available-space installed-size)
1070
1071     (values (pair? build/full) (pair? download))))
1072
1073 (define show-what-to-build*
1074   (store-lift show-what-to-build))
1075
1076 (define* (build-notifier #:key (dry-run? #f) (use-substitutes? #t))
1077   "Return a procedure suitable for 'with-build-handler' that, when
1078 'build-things' is called, invokes 'show-what-to-build' to display the build
1079 plan.  When DRY-RUN? is true, the 'with-build-handler' form returns without
1080 any build happening."
1081   (define not-comma
1082     (char-set-complement (char-set #\,)))
1083
1084   (define (read-derivation-from-file* item)
1085     (catch 'system-error
1086       (lambda ()
1087         (read-derivation-from-file item))
1088       (const #f)))
1089
1090   (lambda (continue store things mode)
1091     (define inputs
1092       ;; List of derivation inputs to build.  Filter out non-existent '.drv'
1093       ;; files because the daemon transparently tries to substitute them.
1094       (filter-map (match-lambda
1095                     (((? derivation-path? drv) . output)
1096                      (let ((drv     (read-derivation-from-file* drv))
1097                            (outputs (string-tokenize output not-comma)))
1098                        (and drv (derivation-input drv outputs))))
1099                     ((? derivation-path? drv)
1100                      (and=> (read-derivation-from-file* drv)
1101                             derivation-input))
1102                     (_
1103                      #f))
1104                   things))
1105
1106     (let-values (((build? download?)
1107                   (show-what-to-build store inputs
1108                                       #:dry-run? dry-run?
1109                                       #:use-substitutes? use-substitutes?
1110                                       #:mode mode)))
1111
1112       (unless (and (or build? download?)
1113                    dry-run?)
1114         (continue #t)))))
1115
1116 (define (right-arrow port)
1117   "Return either a string containing the 'RIGHT ARROW' character, or an ASCII
1118 replacement if PORT is not Unicode-capable."
1119   (let ((encoding (port-encoding port))
1120         (arrow "→"))
1121     (catch 'encoding-error
1122       (lambda ()
1123         (call-with-output-string
1124           (lambda (port)
1125             (set-port-encoding! port encoding)
1126             (set-port-conversion-strategy! port 'error)
1127             (display arrow port))))
1128       (lambda (key . args)
1129         "->"))))
1130
1131 (define* (tabulate rows #:key (initial-indent 0) (max-width 25)
1132                    (inter-column " "))
1133   "Return a list of strings where each string is a tabulated representation of
1134 an element of ROWS.  All the ROWS must be lists of the same number of cells.
1135
1136 Add INITIAL-INDENT white space at the beginning of each row.  Ensure that
1137 columns are at most MAX-WIDTH characters wide.  Use INTER-COLUMN as a
1138 separator between subsequent columns."
1139   (define column-widths
1140     ;; List of column widths.
1141     (let loop ((rows rows)
1142                (widths '()))
1143       (match rows
1144         (((? null?) ...)
1145          (reverse widths))
1146         (((column rest ...) ...)
1147          (loop rest
1148                (cons (min (apply max (map string-length column))
1149                           max-width)
1150                      widths))))))
1151
1152   (define indent
1153     (make-string initial-indent #\space))
1154
1155   (define (string-pad-right* str len)
1156     (if (> (string-length str) len)
1157         str
1158         (string-pad-right str len)))
1159
1160   (map (lambda (row)
1161          (string-trim-right
1162           (string-append indent
1163                          (string-join
1164                           (map string-pad-right* row column-widths)
1165                           inter-column))))
1166        rows))
1167
1168 (define* (show-manifest-transaction store manifest transaction
1169                                     #:key dry-run?)
1170   "Display what will/would be installed/removed from MANIFEST by TRANSACTION."
1171   (define (package-strings names versions outputs)
1172     (tabulate (zip (map (lambda (name output)
1173                           (if (string=? output "out")
1174                               name
1175                               (string-append name ":" output)))
1176                         names outputs)
1177                    versions)
1178               #:initial-indent 3))
1179
1180   (define →                        ;an arrow that can be represented on stderr
1181     (right-arrow (current-error-port)))
1182
1183   (define (upgrade-string names old-version new-version outputs)
1184     (tabulate (zip (map (lambda (name output)
1185                           (if (string=? output "out")
1186                               name
1187                               (string-append name ":" output)))
1188                         names outputs)
1189                    (map (lambda (old new)
1190                           (if (string=? old new)
1191                               (G_ "(dependencies or package changed)")
1192                               (string-append old " " → " " new)))
1193                         old-version new-version))
1194               #:initial-indent 3))
1195
1196   (let-values (((remove install upgrade downgrade)
1197                 (manifest-transaction-effects manifest transaction)))
1198     (match remove
1199       ((($ <manifest-entry> name version output item) ..1)
1200        (let ((len    (length name))
1201              (remove (package-strings name version output)))
1202          (if dry-run?
1203              (format (current-error-port)
1204                      (N_ "The following package would be removed:~%~{~a~%~}~%"
1205                          "The following packages would be removed:~%~{~a~%~}~%"
1206                          len)
1207                      remove)
1208              (format (current-error-port)
1209                      (N_ "The following package will be removed:~%~{~a~%~}~%"
1210                          "The following packages will be removed:~%~{~a~%~}~%"
1211                          len)
1212                      remove))))
1213       (x #f))
1214     (match downgrade
1215       (((($ <manifest-entry> name old-version)
1216          . ($ <manifest-entry> _ new-version output item)) ..1)
1217        (let ((len       (length name))
1218              (downgrade (upgrade-string name old-version new-version
1219                                         output)))
1220          (if dry-run?
1221              (format (current-error-port)
1222                      (N_ "The following package would be downgraded:~%~{~a~%~}~%"
1223                          "The following packages would be downgraded:~%~{~a~%~}~%"
1224                          len)
1225                      downgrade)
1226              (format (current-error-port)
1227                      (N_ "The following package will be downgraded:~%~{~a~%~}~%"
1228                          "The following packages will be downgraded:~%~{~a~%~}~%"
1229                          len)
1230                      downgrade))))
1231       (x #f))
1232     (match upgrade
1233       (((($ <manifest-entry> name old-version)
1234          . ($ <manifest-entry> _ new-version output item)) ..1)
1235        (let ((len     (length name))
1236              (upgrade (upgrade-string name
1237                                       old-version new-version
1238                                       output)))
1239          (if dry-run?
1240              (format (current-error-port)
1241                      (N_ "The following package would be upgraded:~%~{~a~%~}~%"
1242                          "The following packages would be upgraded:~%~{~a~%~}~%"
1243                          len)
1244                      upgrade)
1245              (format (current-error-port)
1246                      (N_ "The following package will be upgraded:~%~{~a~%~}~%"
1247                          "The following packages will be upgraded:~%~{~a~%~}~%"
1248                          len)
1249                      upgrade))))
1250       (x #f))
1251     (match install
1252       ((($ <manifest-entry> name version output item _) ..1)
1253        (let ((len     (length name))
1254              (install (package-strings name version output)))
1255          (if dry-run?
1256              (format (current-error-port)
1257                      (N_ "The following package would be installed:~%~{~a~%~}~%"
1258                          "The following packages would be installed:~%~{~a~%~}~%"
1259                          len)
1260                      install)
1261              (format (current-error-port)
1262                      (N_ "The following package will be installed:~%~{~a~%~}~%"
1263                          "The following packages will be installed:~%~{~a~%~}~%"
1264                          len)
1265                      install))))
1266       (x #f))))
1267
1268 (define-syntax with-error-handling
1269   (syntax-rules ()
1270     "Run BODY within a user-friendly error condition handler."
1271     ((_ body ...)
1272      (call-with-error-handling
1273       (lambda ()
1274         body ...)))))
1275
1276 (define* (indented-string str indent
1277                           #:key (initial-indent? #t))
1278   "Return STR with each newline preceded by INDENT spaces.  When
1279 INITIAL-INDENT? is true, the first line is also indented."
1280   (define indent-string
1281     (make-list indent #\space))
1282
1283   (list->string
1284    (string-fold-right (lambda (chr result)
1285                         (if (eqv? chr #\newline)
1286                             (cons chr (append indent-string result))
1287                             (cons chr result)))
1288                       '()
1289                       (if initial-indent?
1290                           (string-append (list->string indent-string) str)
1291                           str))))
1292
1293 (define* (fill-paragraph str width #:optional (column 0))
1294   "Fill STR such that each line contains at most WIDTH characters, assuming
1295 that the first character is at COLUMN.
1296
1297 When STR contains a single line break surrounded by other characters, it is
1298 converted to a space; sequences of more than one line break are preserved."
1299   (define (maybe-break chr result)
1300     (match result
1301       ((column newlines chars)
1302        (case chr
1303          ((#\newline)
1304           `(,column ,(+ 1 newlines) ,chars))
1305          (else
1306           (let* ((spaces (if (and (pair? chars) (eqv? (car chars) #\.)) 2 1))
1307                  (chars  (case newlines
1308                            ((0) chars)
1309                            ((1)
1310                             (append (make-list spaces #\space) chars))
1311                            (else
1312                             (append (make-list newlines #\newline) chars))))
1313                  (column (case newlines
1314                            ((0) column)
1315                            ((1) (+ spaces column))
1316                            (else 0))))
1317             (let ((chars  (cons chr chars))
1318                   (column (+ 1 column)))
1319               (if (> column width)
1320                   (let*-values (((before after)
1321                                  (break (cut eqv? #\space <>) chars))
1322                                 ((len)
1323                                  (length before)))
1324                     (if (<= len width)
1325                         `(,len
1326                           0
1327                           ,(if (null? after)
1328                                before
1329                                (append before
1330                                        (cons #\newline
1331                                              (drop-while (cut eqv? #\space <>)
1332                                                          after)))))
1333                         `(,column 0 ,chars)))     ; unbreakable
1334                   `(,column 0 ,chars)))))))))
1335
1336   (match (string-fold maybe-break
1337                       `(,column 0 ())
1338                       str)
1339     ((column newlines chars)
1340      (list->string (reverse chars)))))
1341
1342 \f
1343 ;;;
1344 ;;; Packages.
1345 ;;;
1346
1347 (define %text-width
1348   ;; '*line-width*' was introduced in Guile 2.2.7/3.0.1.  On older versions of
1349   ;; Guile, monkey-patch 'wrap*' below.
1350   (if (defined? '*line-width*)
1351       (let ((parameter (fluid->parameter *line-width*)))
1352         (parameter (terminal-columns))
1353         parameter)
1354       (make-parameter (terminal-columns))))
1355
1356 (unless (defined? '*line-width*)                  ;Guile < 2.2.7
1357   (set! (@@ (texinfo plain-text) wrap*)
1358     ;; XXX: Monkey patch this private procedure to let 'package->recutils'
1359     ;; parameterize the fill of description field correctly.
1360     (lambda strings
1361       (let ((indent (fluid-ref (@@ (texinfo plain-text) *indent*))))
1362         (fill-string (string-concatenate strings)
1363                      #:line-width (%text-width) #:initial-indent indent
1364                      #:subsequent-indent indent)))))
1365
1366 (define (texi->plain-text str)
1367   "Return a plain-text representation of texinfo fragment STR."
1368   ;; 'texi-fragment->stexi' uses a string port so make sure it's a
1369   ;; Unicode-capable one (see <http://bugs.gnu.org/11197>.)
1370   (with-fluids ((%default-port-encoding "UTF-8"))
1371     (stexi->plain-text (texi-fragment->stexi str))))
1372
1373 (define (package-field-string package field-accessor)
1374   "Return a plain-text representation of PACKAGE field."
1375   (and=> (field-accessor package)
1376          (compose texi->plain-text P_)))
1377
1378 (define (package-description-string package)
1379   "Return a plain-text representation of PACKAGE description field."
1380   (package-field-string package package-description))
1381
1382 (define (package-synopsis-string package)
1383   "Return a plain-text representation of PACKAGE synopsis field."
1384   (package-field-string package package-synopsis))
1385
1386 (define (string->recutils str)
1387   "Return a version of STR where newlines have been replaced by newlines
1388 followed by \"+ \", which makes for a valid multi-line field value in the
1389 `recutils' syntax."
1390   (list->string
1391    (string-fold-right (lambda (chr result)
1392                         (if (eqv? chr #\newline)
1393                             (cons* chr #\+ #\space result)
1394                             (cons chr result)))
1395                       '()
1396                       str)))
1397
1398 (define (hyperlink uri text)
1399   "Return a string that denotes a hyperlink using an OSC escape sequence as
1400 documented at
1401 <https://gist.github.com/egmontkob/eb114294efbcd5adb1944c9f3cb5feda>."
1402   (string-append "\x1b]8;;" uri "\x1b\\"
1403                  text "\x1b]8;;\x1b\\"))
1404
1405 (define* (supports-hyperlinks? #:optional (port (current-output-port)))
1406   "Return true if PORT is a terminal that supports hyperlink escapes."
1407   ;; Note that terminals are supposed to ignore OSC escapes they don't
1408   ;; understand (this is the case of xterm as of version 349, for instance.)
1409   ;; However, Emacs comint as of 26.3 does not ignore it and instead lets it
1410   ;; through, hence the 'INSIDE_EMACS' special case below.
1411   (and (isatty?* port)
1412        (not (getenv "INSIDE_EMACS"))))
1413
1414 (define* (file-hyperlink file #:optional (text file))
1415   "Return TEXT with escapes for a hyperlink to FILE."
1416   (hyperlink (string-append "file://" (gethostname)
1417                             (encode-and-join-uri-path
1418                              (string-split file #\/)))
1419              text))
1420
1421 (define (location->hyperlink location)
1422   "Return a string corresponding to LOCATION, with escapes for a hyperlink."
1423   (let ((str  (location->string location))
1424         (file (if (string-prefix? "/" (location-file location))
1425                   (location-file location)
1426                   (search-path %load-path (location-file location)))))
1427     (if file
1428         (file-hyperlink file str)
1429         str)))
1430
1431 (define* (package->recutils p port #:optional (width (%text-width))
1432                             #:key
1433                             (hyperlinks? (supports-hyperlinks? port))
1434                             (extra-fields '()))
1435   "Write to PORT a `recutils' record of package P, arranging to fit within
1436 WIDTH columns.  EXTRA-FIELDS is a list of symbol/value pairs to emit.  When
1437 HYPERLINKS? is true, emit hyperlink escape sequences when appropriate."
1438   (define width*
1439     ;; The available number of columns once we've taken into account space for
1440     ;; the initial "+ " prefix.
1441     (if (> width 2) (- width 2) width))
1442
1443   (define (dependencies->recutils packages)
1444     (let ((list (string-join (delete-duplicates
1445                               (map package-full-name
1446                                    (sort packages package<?))) " ")))
1447       (string->recutils
1448        (fill-paragraph list width*
1449                        (string-length "dependencies: ")))))
1450
1451   (define (package<? p1 p2)
1452     (string<? (package-full-name p1) (package-full-name p2)))
1453
1454   ;; Note: Don't i18n field names so that people can post-process it.
1455   (format port "name: ~a~%" (package-name p))
1456   (format port "version: ~a~%" (package-version p))
1457   (format port "outputs: ~a~%" (string-join (package-outputs p)))
1458   (format port "systems: ~a~%"
1459           (string-join (package-transitive-supported-systems p)))
1460   (format port "dependencies: ~a~%"
1461           (match (package-direct-inputs p)
1462             (((labels inputs . _) ...)
1463              (dependencies->recutils (filter package? inputs)))))
1464   (format port "location: ~a~%"
1465           (or (and=> (package-location p)
1466                      (if hyperlinks? location->hyperlink location->string))
1467               (G_ "unknown")))
1468
1469   ;; Note: Starting from version 1.6 or recutils, hyphens are not allowed in
1470   ;; field identifiers.
1471   (format port "homepage: ~a~%" (package-home-page p))
1472
1473   (format port "license: ~a~%"
1474           (match (package-license p)
1475             (((? license? licenses) ...)
1476              (string-join (map license-name licenses)
1477                           ", "))
1478             ((? license? license)
1479              (let ((text (license-name license))
1480                    (uri  (license-uri license)))
1481                (if (and hyperlinks? uri (string-prefix? "http" uri))
1482                    (hyperlink uri text)
1483                    text)))
1484             (x
1485              (G_ "unknown"))))
1486   (format port "synopsis: ~a~%"
1487           (string-map (match-lambda
1488                         (#\newline #\space)
1489                         (chr       chr))
1490                       (or (package-synopsis-string p) "")))
1491   (format port "~a~%"
1492           (string->recutils
1493            (string-trim-right
1494             (parameterize ((%text-width width*))
1495               ;; Call 'texi->plain-text' on the concatenated string to account
1496               ;; for the width of "description:" in paragraph filling.
1497               (texi->plain-text
1498                (string-append "description: "
1499                               (or (and=> (package-description p) P_)
1500                                   ""))))
1501             #\newline)))
1502   (for-each (match-lambda
1503               ((field . value)
1504                (let ((field (symbol->string field)))
1505                  (format port "~a: ~a~%"
1506                          field
1507                          (fill-paragraph (object->string value) width*
1508                                          (string-length field))))))
1509             extra-fields)
1510   (newline port))
1511
1512 \f
1513 ;;;
1514 ;;; Searching.
1515 ;;;
1516
1517 (define (relevance obj regexps metrics)
1518   "Compute a \"relevance score\" for OBJ as a function of its number of
1519 matches of REGEXPS and accordingly to METRICS.  METRICS is list of
1520 field/weight pairs, where FIELD is a procedure that returns a string or list
1521 of strings describing OBJ, and WEIGHT is a positive integer denoting the
1522 weight of this field in the final score.
1523
1524 A score of zero means that OBJ does not match any of REGEXPS.  The higher the
1525 score, the more relevant OBJ is to REGEXPS."
1526   (define (score regexp str)
1527     (fold-matches regexp str 0
1528                   (lambda (m score)
1529                     (+ score
1530                        (if (string=? (match:substring m) str)
1531                            5             ;exact match
1532                            1)))))
1533
1534   (define (regexp->score regexp)
1535     (let ((score-regexp (lambda (str) (score regexp str))))
1536       (fold (lambda (metric relevance)
1537               (match metric
1538                 ((field . weight)
1539                  (match (field obj)
1540                    (#f  relevance)
1541                    ((? string? str)
1542                     (+ relevance (* (score-regexp str) weight)))
1543                    ((lst ...)
1544                     (+ relevance (* weight (apply + (map score-regexp lst)))))))))
1545             0 metrics)))
1546
1547   (let loop ((regexps regexps)
1548              (total-score 0))
1549     (match regexps
1550       ((head . tail)
1551        (let ((score (regexp->score head)))
1552          ;; Return zero if one of PATTERNS doesn't match.
1553          (if (zero? score)
1554              0
1555              (loop tail (+ total-score score)))))
1556       (() total-score))))
1557
1558 (define %package-metrics
1559   ;; Metrics used to compute the "relevance score" of a package against a set
1560   ;; of regexps.
1561   `((,package-name . 4)
1562
1563     ;; Match against uncommon outputs.
1564     (,(lambda (package)
1565         (filter (lambda (output)
1566                   (not (member output
1567                                ;; Some common outputs shared by many packages.
1568                                '("out" "doc" "debug" "lib" "include" "bin"))))
1569                 (package-outputs package)))
1570      . 1)
1571
1572     ;; Match regexps on the raw Texinfo since formatting it is quite expensive
1573     ;; and doesn't have much of an effect on search results.
1574     (,(lambda (package)
1575         (and=> (package-synopsis package) P_)) . 3)
1576     (,(lambda (package)
1577         (and=> (package-description package) P_)) . 2)
1578
1579     (,(lambda (type)
1580         (match (and=> (package-location type) location-file)
1581           ((? string? file) (basename file ".scm"))
1582           (#f "")))
1583      . 1)))
1584
1585 (define (package-relevance package regexps)
1586   "Return a score denoting the relevance of PACKAGE for REGEXPS.  A score of
1587 zero means that PACKAGE does not match any of REGEXPS."
1588   (relevance package regexps %package-metrics))
1589
1590 (define (call-with-paginated-output-port proc)
1591   (if (isatty?* (current-output-port))
1592       ;; Set 'LESS' so that 'less' exits if everything fits on the screen (F),
1593       ;; lets ANSI escapes through (r), does not send the termcap
1594       ;; initialization string (X).  Set it unconditionally because some
1595       ;; distros set it to something that doesn't work here.
1596       (let ((pager (with-environment-variables `(("LESS" "FrX"))
1597                      (open-pipe* OPEN_WRITE
1598                                  (or (getenv "GUIX_PAGER") (getenv "PAGER")
1599                                      "less")))))
1600         (dynamic-wind
1601           (const #t)
1602           (lambda () (proc pager))
1603           (lambda () (close-pipe pager))))
1604       (proc (current-output-port))))
1605
1606 (define-syntax-rule (with-paginated-output-port port exp ...)
1607   "Evaluate EXP... with PORT bound to a port that talks to the pager if
1608 standard output is a tty, or with PORT set to the current output port."
1609   (call-with-paginated-output-port (lambda (port) exp ...)))
1610
1611 (define* (display-search-results matches port
1612                                  #:key
1613                                  (command "guix search")
1614                                  (print package->recutils))
1615   "Display MATCHES, a list of object/score pairs, by calling PRINT on each of
1616 them.  If PORT is a terminal, print at most a full screen of results."
1617   (define first-line
1618     (port-line port))
1619
1620   (define max-rows
1621     (and first-line (isatty? port)
1622          (terminal-rows port)))
1623
1624   (define (line-count str)
1625     (string-count str #\newline))
1626
1627   (with-paginated-output-port paginated
1628     (let loop ((matches matches))
1629       (match matches
1630         (((package . score) rest ...)
1631          (let* ((links? (supports-hyperlinks? port)))
1632            (print package paginated
1633                   #:hyperlinks? links?
1634                   #:extra-fields `((relevance . ,score)))
1635            (loop rest)))
1636         (()
1637          #t)))))
1638
1639 \f
1640 (define (string->generations str)
1641   "Return the list of generations matching a pattern in STR.  This function
1642 accepts the following patterns: \"1\", \"1,2,3\", \"1..9\", \"1..\", \"..9\"."
1643   (define (maybe-integer)
1644     (let ((x (string->number str)))
1645       (and (integer? x)
1646            x)))
1647
1648   (define (maybe-comma-separated-integers)
1649     (let ((lst (delete-duplicates
1650                 (map string->number
1651                      (string-split str #\,)))))
1652       (and (every integer? lst)
1653            lst)))
1654
1655   (cond ((maybe-integer)
1656          =>
1657          list)
1658         ((maybe-comma-separated-integers)
1659          =>
1660          identity)
1661         ((string-match "^([0-9]+)\\.\\.([0-9]+)$" str)
1662          =>
1663          (lambda (match)
1664            (let ((s (string->number (match:substring match 1)))
1665                  (e (string->number (match:substring match 2))))
1666              (and (every integer? (list s e))
1667                   (<= s e)
1668                   (iota (1+ (- e s)) s)))))
1669         ((string-match "^([0-9]+)\\.\\.$" str)
1670          =>
1671          (lambda (match)
1672            (let ((s (string->number (match:substring match 1))))
1673              (and (integer? s)
1674                   `(>= ,s)))))
1675         ((string-match "^\\.\\.([0-9]+)$" str)
1676          =>
1677          (lambda (match)
1678            (let ((e (string->number (match:substring match 1))))
1679              (and (integer? e)
1680                   `(<= ,e)))))
1681         (else #f)))
1682
1683 (define (string->duration str)
1684   "Return the duration matching a pattern in STR.  This function accepts the
1685 following patterns: \"1d\", \"1w\", \"1m\"."
1686   (define (hours->duration hours match)
1687     (make-time time-duration 0
1688                (* 3600 hours (string->number (match:substring match 1)))))
1689
1690   (cond ((string-match "^([0-9]+)s$" str)
1691          =>
1692          (lambda (match)
1693            (make-time time-duration 0
1694                       (string->number (match:substring match 1)))))
1695         ((string-match "^([0-9]+)h$" str)
1696          =>
1697          (lambda (match)
1698            (hours->duration 1 match)))
1699         ((string-match "^([0-9]+)d$" str)
1700          =>
1701          (lambda (match)
1702            (hours->duration 24 match)))
1703         ((string-match "^([0-9]+)w$" str)
1704          =>
1705          (lambda (match)
1706            (hours->duration (* 24 7) match)))
1707         ((string-match "^([0-9]+)m$" str)
1708          =>
1709          (lambda (match)
1710            (hours->duration (* 24 30) match)))
1711         (else #f)))
1712
1713 (define* (matching-generations str profile
1714                                #:key (duration-relation <=))
1715   "Return the list of available generations matching a pattern in STR.  See
1716 'string->generations' and 'string->duration' for the list of valid patterns.
1717 When STR is a duration pattern, return all the generations whose ctime has
1718 DURATION-RELATION with the current time."
1719   (define (valid-generations lst)
1720     (define (valid-generation? n)
1721       (any (cut = n <>) (generation-numbers profile)))
1722
1723     (fold-right (lambda (x acc)
1724                   (if (valid-generation? x)
1725                       (cons x acc)
1726                       acc))
1727                 '()
1728                 lst))
1729
1730   (define (filter-generations generations)
1731     (match generations
1732       (() '())
1733       (('>= n)
1734        (drop-while (cut > n <>)
1735                    (generation-numbers profile)))
1736       (('<= n)
1737        (valid-generations (iota n 1)))
1738       ((lst ..1)
1739        (valid-generations lst))
1740       (x #f)))
1741
1742   (define (filter-by-duration duration)
1743     (define (time-at-midnight time)
1744       ;; Return TIME at midnight by setting nanoseconds, seconds, minutes, and
1745       ;; hours to zeros.
1746       (let ((d (time-utc->date time)))
1747          (date->time-utc
1748           (make-date 0 0 0 0
1749                      (date-day d) (date-month d)
1750                      (date-year d) (date-zone-offset d)))))
1751
1752     (define generation-ctime-alist
1753       (map (lambda (number)
1754              (cons number
1755                    (time-second
1756                     (time-at-midnight
1757                      (generation-time profile number)))))
1758            (generation-numbers profile)))
1759
1760     (match duration
1761       (#f #f)
1762       (res
1763        (let ((s (time-second
1764                  (subtract-duration (time-at-midnight (current-time))
1765                                     duration))))
1766          (delete #f (map (lambda (x)
1767                            (and (duration-relation s (cdr x))
1768                                 (first x)))
1769                          generation-ctime-alist))))))
1770
1771   (cond ((string->generations str)
1772          =>
1773          filter-generations)
1774         ((string->duration str)
1775          =>
1776          filter-by-duration)
1777         (else
1778          (raise
1779           (condition (&message
1780                       (message (format #f (G_ "invalid syntax: ~a~%")
1781                                        str))))))))
1782
1783 (define (display-generation profile number)
1784   "Display a one-line summary of generation NUMBER of PROFILE."
1785   (unless (zero? number)
1786     (let* ((file   (generation-file-name profile number))
1787            (link   (if (supports-hyperlinks?)
1788                        (cut file-hyperlink file <>)
1789                        identity))
1790            (header (format #f (link (highlight (G_ "Generation ~a\t~a")))
1791                            number
1792                            (date->string
1793                             (time-utc->date
1794                              (generation-time profile number))
1795                             ;; TRANSLATORS: This is a format-string for date->string.
1796                             ;; Please choose a format that corresponds to the
1797                             ;; usual way of presenting dates in your locale.
1798                             ;; See https://www.gnu.org/software/guile/manual/html_node/SRFI_002d19-Date-to-string.html
1799                             ;; for details.
1800                             (G_ "~b ~d ~Y ~T"))))
1801            (current (generation-number profile)))
1802       (if (= number current)
1803           ;; TRANSLATORS: The word "current" here is an adjective for
1804           ;; "Generation", as in "current generation".  Use the appropriate
1805           ;; gender where applicable.
1806           (format #t (G_ "~a\t(current)~%") header)
1807           (format #t "~a~%" header)))))
1808
1809 (define (display-profile-content-diff profile gen1 gen2)
1810   "Display the changed packages in PROFILE GEN2 compared to generation GEN1."
1811
1812   (define (equal-entry? first second)
1813     (string= (manifest-entry-item first) (manifest-entry-item second)))
1814
1815   (define (display-entry entry prefix)
1816     (match entry
1817       (($ <manifest-entry> name version output location _)
1818        (format #t " ~a ~a\t~a\t~a\t~a~%" prefix name version output location))))
1819
1820   (define (list-entries number)
1821     (manifest-entries (profile-manifest (generation-file-name profile number))))
1822
1823   (define (display-diff profile old new)
1824     (display-generation profile new)
1825     (let ((added (lset-difference
1826                   equal-entry? (list-entries new) (list-entries old)))
1827           (removed (lset-difference
1828                     equal-entry? (list-entries old) (list-entries new))))
1829       (for-each (cut display-entry <> "+") added)
1830       (for-each (cut display-entry <> "-") removed)
1831       (newline)))
1832
1833   (display-diff profile gen1 gen2))
1834
1835 (define (profile-lock-handler profile errno . _)
1836   "Handle failure to acquire PROFILE's lock."
1837   ;; NFS mounts can return ENOLCK.  When that happens, there's not much that
1838   ;; can be done, so warn the user and keep going.
1839   (if (= errno ENOLCK)
1840       (warning (G_ "cannot lock profile ~a: ~a~%")
1841                profile (strerror errno))
1842       (leave (G_ "profile ~a is locked by another process~%")
1843              profile)))
1844
1845 (define profile-lock-file
1846   (cut string-append <> ".lock"))
1847
1848 (define-syntax-rule (with-profile-lock profile exp ...)
1849   "Grab PROFILE's lock and evaluate EXP...  Call 'leave' if the lock is
1850 already taken."
1851   (with-file-lock/no-wait (profile-lock-file profile)
1852     (cut profile-lock-handler profile <...>)
1853     exp ...))
1854
1855 (define (display-profile-content profile number)
1856   "Display the packages in PROFILE, generation NUMBER, in a human-readable
1857 way."
1858   (for-each (match-lambda
1859               (($ <manifest-entry> name version output location _)
1860                (format #t "  ~a\t~a\t~a\t~a~%"
1861                        name version output location)))
1862
1863             ;; Show most recently installed packages last.
1864             (reverse
1865              (manifest-entries
1866               (profile-manifest (generation-file-name profile number))))))
1867
1868 (define (display-generation-change previous current)
1869   (format #t (G_ "switched from generation ~a to ~a~%") previous current))
1870
1871 (define (roll-back* store profile)
1872   "Like 'roll-back', but display what is happening."
1873   (call-with-values
1874       (lambda ()
1875         (roll-back store profile))
1876     display-generation-change))
1877
1878 (define (switch-to-generation* profile number)
1879   "Like 'switch-generation', but display what is happening."
1880   (let ((previous (switch-to-generation profile number)))
1881     (display-generation-change previous number)))
1882
1883 (define (delete-generation* store profile generation)
1884   "Like 'delete-generation', but display what is going on."
1885   (format #t (G_ "deleting ~a~%")
1886           (generation-file-name profile generation))
1887   (delete-generation store profile generation))
1888
1889 (define* (package-specification->name+version+output spec
1890                                                      #:optional (output "out"))
1891   "Parse package specification SPEC and return three value: the specified
1892 package name, version number (or #f), and output name (or OUTPUT).  SPEC may
1893 optionally contain a version number and an output name, as in these examples:
1894
1895   guile
1896   guile@2.0.9
1897   guile:debug
1898   guile@2.0.9:debug
1899 "
1900   (let*-values (((name sub-drv)
1901                  (match (string-rindex spec #\:)
1902                    (#f    (values spec output))
1903                    (colon (values (substring spec 0 colon)
1904                                   (substring spec (+ 1 colon))))))
1905                 ((name version)
1906                  (package-name->name+version name)))
1907     (values name version sub-drv)))
1908
1909 \f
1910 ;;;
1911 ;;; Command-line option processing.
1912 ;;;
1913
1914 (define (show-guix-usage)
1915   (format (current-error-port)
1916           (G_ "Try `guix --help' for more information.~%"))
1917   (exit 1))
1918
1919 (define (command-files)
1920   "Return the list of source files that define Guix sub-commands."
1921   (define directory
1922     (and=> (search-path %load-path "guix.scm")
1923            (compose (cut string-append <> "/guix/scripts")
1924                     dirname)))
1925
1926   (define dot-scm?
1927     (cut string-suffix? ".scm" <>))
1928
1929   (if directory
1930       (scandir directory dot-scm?)
1931       '()))
1932
1933 (define (commands)
1934   "Return the list of Guix command names."
1935   (map (compose (cut string-drop-right <> 4)
1936                 basename)
1937        (command-files)))
1938
1939 (define (show-guix-help)
1940   (define (internal? command)
1941     (member command '("substitute" "authenticate" "offload"
1942                       "perform-download")))
1943
1944   (format #t (G_ "Usage: guix COMMAND ARGS...
1945 Run COMMAND with ARGS.\n"))
1946   (newline)
1947   (format #t (G_ "COMMAND must be one of the sub-commands listed below:\n"))
1948   (newline)
1949   ;; TODO: Display a synopsis of each command.
1950   (format #t "~{   ~a~%~}" (sort (remove internal? (commands))
1951                                  string<?))
1952   (show-bug-report-information))
1953
1954 (define (run-guix-command command . args)
1955   "Run COMMAND with the given ARGS.  Report an error when COMMAND is not
1956 found."
1957   (define module
1958     (catch 'misc-error
1959       (lambda ()
1960         (resolve-interface `(guix scripts ,command)))
1961       (lambda -
1962         (format (current-error-port)
1963                 (G_ "guix: ~a: command not found~%") command)
1964         (show-guix-usage))))
1965
1966   (let ((command-main (module-ref module
1967                                   (symbol-append 'guix- command))))
1968     (parameterize ((program-name command))
1969       ;; Disable canonicalization so we don't don't stat unreasonably.
1970       (with-fluids ((%file-port-name-canonicalization #f))
1971         (dynamic-wind
1972           (const #f)
1973           (lambda ()
1974             (apply command-main args))
1975           (lambda ()
1976             ;; Abuse 'exit-hook' (which is normally meant to be used by the
1977             ;; REPL) to run things like profiling hooks upon completion.
1978             (run-hook exit-hook)))))))
1979
1980 (define (run-guix . args)
1981   "Run the 'guix' command defined by command line ARGS.
1982 Unlike 'guix-main', this procedure assumes that locale, i18n support,
1983 and signal handling have already been set up."
1984   (define option? (cut string-prefix? "-" <>))
1985
1986   ;; The default %LOAD-EXTENSIONS includes the empty string, which doubles the
1987   ;; number of 'stat' calls per entry in %LOAD-PATH.  Shamelessly remove it.
1988   (set! %load-extensions '(".scm"))
1989
1990   (match args
1991     (()
1992      (format (current-error-port)
1993              (G_ "guix: missing command name~%"))
1994      (show-guix-usage))
1995     ((or ("-h") ("--help"))
1996      (show-guix-help))
1997     ((or ("-V") ("--version"))
1998      (show-version-and-exit "guix"))
1999     (((? option? o) args ...)
2000      (format (current-error-port)
2001              (G_ "guix: unrecognized option '~a'~%") o)
2002      (show-guix-usage))
2003     (("help" command)
2004      (apply run-guix-command (string->symbol command)
2005             '("--help")))
2006     (("help" args ...)
2007      (show-guix-help))
2008     ((command args ...)
2009      (apply run-guix-command
2010             (string->symbol command)
2011             args))))
2012
2013 (define (guix-main arg0 . args)
2014   (initialize-guix)
2015   (apply run-guix args))
2016
2017 ;;; Local Variables:
2018 ;;; eval: (put 'guard* 'scheme-indent-function 2)
2019 ;;; End:
2020
2021 ;;; ui.scm ends here