# GNU Guix --- Functional package management for GNU
# Copyright © 2015-2016, 2019-2020, 2022-2023 Ludovic Courtès <ludo@gnu.org>
# Copyright © 2019 Simon Tournier <zimon.toutoune@gmail.com>
#
# 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/>.

#
# Test the 'guix graph' command-line utility.
#

module_dir="t-guix-graph-$$"
mkdir "$module_dir"

tmpfile1="$module_dir/t-guix-graph1-$$"
tmpfile2="$module_dir/t-guix-graph2-$$"
trap 'rm -r "$module_dir"' EXIT


cat > "$module_dir/foo.scm"<<EOF
(define-module (foo)
  #:use-module (guix packages)
  #:use-module (gnu packages base))

(define-public dummy
  (package (inherit hello)
    (name "dummy")
    (version "42")
    (synopsis "dummy package")
    (description "dummy package. Only used for testing purposes.")))
EOF


guix graph --version

for package in guile-bootstrap coreutils python
do
    for graph in package bag-emerged bag bag-with-origins
    do
	guix graph -t "$graph" "$package" | grep "$package"
    done
done

guix build guile-bootstrap
guix graph -t references guile-bootstrap | grep guile-bootstrap

guix graph -e '(@ (gnu packages bootstrap) %bootstrap-guile)' \
    | grep guile-bootstrap

guix graph -e + && false

# Try passing store file names.

guix graph -t references guile-bootstrap > "$tmpfile1"
guix graph -t references `guix build guile-bootstrap` > "$tmpfile2"
cmp "$tmpfile1" "$;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2018 Mathieu Othacehe &lt;m.othacehe@gmail.com&gt;
;;; Copyright © 2019 Ludovic Courtès &lt;ludo@gnu.org&gt;
;;;
;;; 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 &lt;http://www.gnu.org/licenses/&gt;.

(define-module (gnu installer locale)
  #:use-module (gnu installer utils)
  #:use-module ((gnu build locale) #:select (normalize-codeset))
  #:use-module (guix records)
  #:use-module (json)
  #:use-module (srfi srfi-1)
  #:use-module (ice-9 match)
  #:use-module (ice-9 regex)
  #:export (locale-language
            locale-territory
            locale-codeset
            locale-modifier

            locale-&gt;locale-string
            supported-locales-&gt;locales

            iso639-&gt;iso639-languages
            language-code-&gt;language-name

            iso3166-&gt;iso3166-territories
            territory-code-&gt;territory-name

            locale-&gt;configuration))


;;;
;;; Locale.
;;;

;; A glibc locale string has the following format:
;; language[_territory[.codeset][@modifier]].
(define locale-regexp &quot;^([^_@]+)(_([^\\.@]+))?(\\.([^@]+))?(@([^$]+))?$&quot;)

;; LOCALE will be better expressed in a (guix record) that in an association
;; list. However, loading large files containing records does not scale
;; well. The same thing goes for ISO639 and ISO3166 association lists used
;; later in this module.
(define (locale-language assoc)
  (assoc-ref assoc &apos;language))
(define (locale-territory assoc)
  (assoc-ref assoc &apos;territory))
(define (locale-codeset assoc)
  (assoc-ref assoc &apos;codeset))
(define (locale-modifier assoc)
  (assoc-ref assoc &apos;modifier))

(define* (locale-string-&gt;locale string #:optional codeset)
  &quot;Return the locale association list built from the parsing of STRING and,
optionally, CODESET.&quot;
  (let ((matches (string-match locale-regexp string)))
    `((language  . ,(match:substring matches 1))
      (territory . ,(match:substring matches 3))
      (codeset   . ,(or codeset (match:substring matches 5)))
      (modifier  . ,(match:substring matches 7)))))

(define (locale-&gt;locale-string locale)
  &quot;Reverse operation of locale-string-&gt;locale.&quot;
  (let ((language (locale-language locale))
        (territory (locale-territory locale))
        (codeset (locale-codeset locale))
        (modifier (locale-modifier locale)))
    (apply string-append
           `(,language
             ,@(if territory
                   `(&quot;_&quot; ,territory)
                   &apos;())
             ,@(if codeset
                   `(&quot;.&quot; ,(normalize-codeset codeset))
                   &apos;())
             ,@(if modifier
                   `(&quot;@&quot; ,modifier)
                   &apos;())))))

(define (supported-locales-&gt;locales supported-locales)
  &quot;Given SUPPORTED-LOCALES, a file produced by &apos;glibc-supported-locales&apos;,
return a list of locales where each locale is an alist.&quot;
  (filter-map (match-lambda
                ((&quot;C.UTF-8&quot; . codeset) #f)
                ((locale . codeset)
                 (locale-string-&gt;locale locale codeset)))
       (call-with-input-file supported-locales read)))


;;;
;;; Language.
;;;

(define (iso639-language-alpha2 assoc)
  (assoc-ref assoc &apos;alpha2))

(define (iso639-language-alpha3 assoc)
  (assoc-ref assoc &apos;alpha3))

(define (iso639-language-name assoc)
  (assoc-ref assoc &apos;name))

(define (supported-locale? locales alpha2 alpha3)
  &quot;Find a locale in LOCALES whose alpha2 field matches ALPHA-2 or alpha3 field
matches ALPHA-3. The ISO639 standard specifies that ALPHA-2 is optional. Thus,
if ALPHA-2 is #f, only consider ALPHA-3. Return #f if not matching locale was
found.&quot;
  (find (lambda (locale)
          (let ((language (locale-language locale)))
            (or (and=&gt; alpha2
                       (lambda (code)