path: root/etc/completion/zsh/_guix

#compdef guix
#
# GNU Guix --- Functional package management for GNU
# Copyright © 2016 Eric Le Bihan <eric.le.bihan.dev@free.fr>
# Copyright © 2021 Noah Evans <noah@nevans.me>
# Copyright © 2021 Brice Waegeneire <brice@waegenei.re>
#
# 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/>.


_guix_caching_policy()
{
    local -a old_policy
    old_policy=( "$1"(Nmh+24) )
    (( $#old_policy ))
}

_guix_list_actions()
{
    _guix_actions=( $(guix system --help | sed -n 's/^   \([a-z-]\+\)\s\+.\+/\1/p') )
}

_guix_list_checkers()
{
    _guix_checkers=( $(guix lint -l | sed -n 's/^- \(.\+\): .\+/\1/p') )
}

_guix_list_graph_types()
{
    _guix_graph_types=( $(guix graph --list-types | sed -n 's/^  - \(.\+\): .\+/\1/p') )
}

_guix_list_importers()
{
    _guix_importers=( $(guix import --help | sed -n 's/^\s\+\([a-z]\+\)$/\1/p') )
}

_guix_list_updaters()
{
    _guix_updaters=( $(guix lint -l | sed -n 's/^- \(.\+\): .\+/\1/p') )
}

_guix_list_available_packages()
{
    if ( [[ ${+_guix_available_packages} -eq 0 ]] || _cache_invalid GUIX_AVAILABLE_PACKAGES ) \
       && ! _retrieve_cache GUIX_AVAILABLE_PACKAGES; then
        _guix_available_packages=(${${(f)"$(guix package -A | cut -f1)"}})
        _guix_available_packages=("${_guix_available_packages[@]// /}")
        _store_cache GUIX_AVAILABLE_PACKAGES _guix_available_packages
    fi
}

_guix_list_installed_packages()
{
    _guix_installed_packages=( $(guix package -I "^${prefix}" | cut -f1) )
}

(( $+functions[_guix_build] )) || _guix_build()
{
    _arguments \
        {-e,--expression=}'[build the package or derivation EXPR evaluates to]:EXPR' \
        {-f,--file=}'[build the package or derivation that the code within FILE evaluates to]:FILE:_files' \
        {-m,--manifest=}'[build the packages that the manifest given in FILE evaluates to]:FILE:_files' \
        {-S,--source}'[build the packages source derivations]' \
        '--sources=[build source derivations]:TYPE:(package all transitive)' \
        {-s,--system=}'[attempt to build for SYSTEM (e.g. "i686-linux")]:SYSTEM' \
        '--target=[cross-build for TRIPLET (e.g. "armel-linux-gnu")]:TRIPLET' \
        {-d,--derivations}'[return the derivation paths of the given packages]' \
        '--check[rebuild items to check for non-determinism issues]' \
        '--repair[repair the specified items]' \
        {-r,--root=}'[make FILE a symlink to the result, and register it as a GC root]:FILE:_files' \
        {-v,--verbosity=}'[use the given verbosity LEVEL]:LEVEL' \
        {-q,--quiet}'[do not show the build log]' \
        '--log-file[return the log file names for the given derivations]' \
        {-L,--load-path=}'[prepend DIR to the package module search path]:DIR:_files -\' \
        {-K,--keep-failed}'[keep build tree of failed builds]' \
        {-k,--keep-going}'[keep going when some of the derivations fail]' \
        {-n,--dry-run}'[do not build the derivations]' \
        '--fallback[fall back to building when the substituter fails]' \
        '--no-substitutes[build instead of resorting to pre-built substitutes]' \
        '--substitute-urls=[fetch substitute from URLS if they are authorized]:URLS:_urls' \
        '--no-grafts[do not graft packages]' \
        '--no-offload[do not attempt to offload builds]' \
        '--max-silent-time=[mark the build as failed after SECONDS of silence]:SECONDS' \
        '--timeout=[mark the build as failed after SECONDS of activity]:SECONDS' \
        '--rounds=[build N times in a row to detect non-determinism]:N' \
        {-c,--cores=}'[allow the use of up to N CPU cores for the build]:N' \
        {-M,--max-jobs=}'[allow at most N build jobs]:N' \
        '--debug=[produce debugging output at LEVEL]:LEVEL' \
        '--help-transform[list package transformation options not shown here]' \
        {-V,--version}'[display version information and exit]' \
        '*:package:->packages'

    if [[ "$state" = packages ]]; then
        _guix_list_available_packages
        compadd -a -- _guix_available_packages
    fi
}

(( $+functions[_guix_challenge] )) || _guix_challenge()
{
    _arguments \
        '--substitute-urls=[compare build results with those at URLS]:URLS:_urls' \
        '--diff=[show differences according to MODE]:MODE' \
        {-v,--verbose}'[show details about successful comparisons]' \
        {-V,--version}'[display version information and exit]' \
        '*:package:->packages'

    if [[ "$state" = packages ]]; then
        _guix_list_available_packages
        compadd -a -- _guix_available_packages
    fi
}

(( $+functions[_guix_container] )) || _guix_container()
{
    _arguments \
        ':action:(exec)' \
        '*:args'
}

(( $+functions[_guix_download] )) || _guix_download()
{
    _arguments \
        {-f,--format=}'[write the hash in the given format]:FMT:(nix-base32 base16 base32 hex)' \
        {-H,--hash=}'[use the given hash ALGORITHM]:ALGORITHM' \
        '--no-check-certificate[do not validate the certificate of HTTPS servers ]' \
        {-o,--output=}'[download to FILE]:FILE:_files' \
        {-V,--version}'[display version information and exit]' \
        '1:URL:_urls'
}

(( $+functions[_guix_edit] )) || _guix_edit()
{
    _guix_list_available_packages
    compadd -a -- _guix_available_packages
}

(( $+functions[_guix_environment] )) || _guix_environment()
{
    _arguments \
        {-e,--expression=}'[create environment for the package that EXPR evaluates to]:EXPR' \
        {-l,--load=}'[create environment for the package that the code within FILE evaluates to]:FILE:_files' \
        {-m,--manifest=}'[create environment with the manifest from FILE]:FILE:_files' \
        {-p,--profile=}'[create environment from profile at PATH]:PATH:_files -/' \
        '--ad-hoc[include all specified packages in the environment instead of only their inputs]' \
        '--pure[unset existing environment variables]' \
        {-E,--preserve=}'[preserve environment variables that match REGEXP]:REGEXP' \
        '--search-paths[display needed environment variable definitions]' \
        {-s,--system=}'[attempt to build for SYSTEM (e.g. "i686-linux")]:SYSTEM' \
        {-r,--root=}'[make FILE a symlink to the result, and register it as a GC root]:FILE:_files' \
        {-C,--container}'[run command within an isolated container]' \
        {-N,--network}'[allow containers to access the network]' \
        {-P,--link-profile}'[link environment profile to ~/.guix-profile within an isolated container]' \
        {-u,--user=}'[instead of copying the name and home of the current user into an isolated container, use the name USER with home directory /home/USER]:USER:_users' \
        '--no-cwd[do not share current working directory with an isolated container]' \
        '--share=[for containers, share writable host file system according to SPEC]:SPEC' \
        '--expose=[for containers, expose read-only host file system according to SPEC]:SPEC' \
        {-v,--verbosity=}'[use the given verbosity LEVEL]:LEVEL' \
        '--bootstrap[use bootstrap binaries to build the environment]' \
        {-L,--load-path=}'[prepend DIR to the package module search path]:DIR:_files -/' \
        {-K,--keep-failed}'[keep build tree of failed builds]' \
        {-k,--keep-going}'[keep going when some of the derivations fail]' \
        {-n,--dry-run}'[do not build the derivations]' \
        '--fallback[fall back to building when the substituter fails]' \
        '--no-substitutes[build instead of resorting to pre-built substitutes]' \
        '--substitute-urls=[fetch substitute from URLS if they are authorized]:URLS:_urls' \
        '--no-grafts[do not graft packages]' \
        '--no-offload[do not attempt to offload builds]' \
        '--max-silent-time=[mark the build as failed after SECONDS of silence]:SECONDS' \
        '--timeout=[mark the build as failed after SECONDS of activity]:SECONDS' \
        '--rounds=[build N times in a row to detect non-determinism]:N' \
        {-c,--cores=}'[allow the use of up to N CPU cores for the build]:N' \
        {-M,--max-jobs=}'[allow at most N build jobs]:N' \
        '--debug=[produce debugging output at LEVEL]:LEVEL' \
        '--help-transform[list package transformation options not shown here]' \
        {-V,--version}'[display version information and exit]' \
        '*:package:->packages'

    if [[ "$state" = packages ]]; then
        _guix_list_available_packages
        compadd -a -- _guix_available_packages
    fi

}

(( $+functions[_guix_gc] )) || _guix_gc()
{
    _arguments \
        {-C,--collect-garbage=}'[collect at least MIN bytes of garbage]:MIN' \
        {-F,--free-space=}'[attempt to reach FREE available space in the store]:FREE' \
        {-d,--delete-generations=}'[delete profile generations matching PATTERN]:PATTERN' \
        {-D,--delete}'[attempt to delete PATHS]' \
        '--list-roots[list the users GC roots]' \
        '--list-busy[list store items used by running processes]' \
        '--optimize[optimize the store by deduplicating identical files]' \
        '--list-dead[list dead paths]' \
        '--list-live[list live paths]' \
        '--references[list the references of PATHS]' \
        {-R,--requisites}'[list the requisites of PATHS]' \
        '--referrers[list the referrers of PATHS]' \
        '--derivers[list the derivers of PATHS]' \
        '--verify=[verify the integrity of the store]:OPTS:(contents repair)' \
        '--list-failures[list cached build failures]' \
        '--clear-failures[remove PATHS from the set of cached failures]' \
        {-V,--version}'[display version information and exit]:V' \
        '1:PATH:_files -/'
}

(( $+functions[_guix_graph] )) || _guix_graph()
{
    _arguments \
        {-b,--backend=}'[produce a graph with the given backend TYPE]:TYPE:->types' \
        '--list-backends[list the available graph backends]' \
        {-t,--type=}'[represent nodes of the given TYPE]:TYPE:->types' \
        '--list-types[list the available graph types]' \
        '--path[display the shortest path between the given nodes]' \
        {-e,--expression=}'[consider the package EXPR evaluates to]:EXPR' \
        {-s,--system=}'[consider the graph for SYSTEM (e.g. "i686-linux")]:SYSTEM' \
        {-L,--load-path=}'[prepend DIR to the package module search path]:DIR:_files -/' \
        '--help-transform[list package transformation options not shown here]' \
        {-V,--version}'[display version information and exit]' \
        '1:PACKAGE:->packages'

    case "$state" in
        types)
            _guix_list_graph_types
            compadd -a -- _guix_graph_types
            ;;
        packages)
            _guix_list_available_packages
            compadd -a -- _guix_available_packages
            ;;
    esac

}

(( $+functions[_guix_hash] )) || _guix_hash()
{
    _arguments \
        {-x,--exclude-vcs}'[exclude version control directories]' \
        {-H,--hash=}'[use the given hash ALGORITHM]:ALGORITHM' \
        {-f,--format=}'[write the hash in the given format]:FMT:(nix-base32 base16 base32 hex)' \
        {-r,--recursive}'[compute the hash on FILE recursively]' \
        {-V,--version}'[display version information and exit]' \
        '1:FILE:_files'
}

(( $+functions[_guix_import] )) || _guix_import()
{
    _arguments \
        {-V,--version}'[display version information and exit]' \
        '1:IMPORTER:->importer' \
        '*:args:'

    if [[ "$state" = importer ]]; then
        _guix_list_importers
        compadd -a -- _guix_importers
    fi
}

(( $+functions[_guix_lint] )) || _guix_lint()
{
    _arguments \
        {-c,--checkers=}'[only run the specified checkers]:CHECKERS:->checkers' \
        {-x,--exclude=}'[exclude the specified checkers]:CHECKERSS:->checkers' \
        {-n,--no-network}'[only run checkers that do not access the network]' \
        {-L,--load-path=}'[prepend DIR to the package module search path]:DIR:_files -/' \
        {-l,--list-checkers}'[display the list of available lint checkers]' \
        {-V,--version}'[display version information and exit]' \
        '1:PACKAGE:->packages'

    case "$state" in
        checkers)
            _guix_list_checkers
            compadd -a -- _guix_checkers
            ;;
        packages)
            _guix_list_available_packages
            compadd -a -- _guix_available_packages
            ;;
    esac
}

(( $+functions[_guix_package] )) || _guix_package()
{
    _arguments \
        {-i,--install}'[install one or more packages]: :->install' \
        {-e,--install-from-expression=}'[install the package EXP evaluates to]:EXP' \
        {-f,--install-from-file=}'[install the package evaluated from FILE]:FILE:_files' \
        {-r,--remove}'[remove one or more packages]: :->remove' \
        {-u,--upgrade=}'[upgrade all the installed packages matching REGEXP]:REGEXP' \
        {-m,--manifest=}'[create a new profile generation from FILE]:FILE:_files' \
        '--do-not-upgrade=[do not upgrade any packages matching REGEXP]:REGEXP' \
        '--roll-back[roll back to the previous generation]' \
        '--search-paths=[display needed environment variable definitions]:KINDS' \
        {-l,--list-generations=}'[list generations matching PATTERN]:PATTERN' \
        {-d,--delete-generations=}'[delete generations matching PATTERN]:PATTERN' \
        {-S,--switch-generation=}'[switch to a generation matching PATTERN]:PATTERN' \
        '--export-manifest[print a manifest for the chosen profile]' \
        '--export-channels[print channels for the chosen profile]' \
        {-p,--profile}'[use PROFILE instead of the default profile]:PROFILE:_files -/' \
        '--list-profiles[list the profiles]' \
        '--allow-collisions[do not treat collisions in the profile as an error]' \
        '--bootstrap[use the bootstrap Guile to build the profile]' \
        {-s,--search=}'[search in synopsis and description using REGEXP]:REGEXP' \
        {-I,--list-installed=}'[list installed packages matching REGEXP]:REGEXP' \
        {-A,--list-available=}'[list available packages matching REGEXP]:REGEXP' \
        '--show=[show details about a package]: :->show' \
        {-L,--load-path=}'[prepend DIR to the package module search path]:DIR:_files -/' \
        {-K,--keep-failed}'[keep build tree of failed builds]' \
        {-k,--keep-going}'[keep going when some of the derivations fail]' \
        {-n,--dry-run}'[do not build the derivations]' \
        '--fallback[fall back to building when the substituter fails]' \
        '--no-substitutes[build instead of resorting to pre-built substitutes]' \
        '--substitute-urls=[fetch substitute from URLS if they are authorized]:URLS:_urls' \
        '--no-grafts[do not graft packages]' \
        '--no-offload[do not attempt to offload builds]' \
        '--max-silent-time=[mark the build as failed after SECONDS of silence]:SECONDS' \
        '--timeout=[mark the build as failed after SECONDS of activity]:SECONDS' \
        '--rounds=[build N times in a row to detect non-determinism]:N' \
        {-c,--cores=}'[allow the use of up to N CPU cores for the build]:N' \
        {-M,--max-jobs=}'[allow at most N build jobs]:N' \
        '--debug=[produce debugging output at LEVEL]' \
        '--help-transform[list package transformation options not shown here]' \
        {-v,--verbosity=}'[use the given verbosity LEVEL]' \
        {-V,--version}'[display version information and exit]'

    case "$state" in
        install|show)
            _guix_list_available_packages
            compadd -a -- _guix_available_packages
            ;;
        remove)
            _guix_list_installed_packages
             compadd -a -- _guix_installed_packages
            ;;
        esac
}

(( $+functions[_guix_install] )) || _guix_install()
{
    _arguments \
        {-p,--profile=}'[use PROFILE instead of the users default profile]:PROFILE:_files -/' \
        {-v,--verbosity=}'[use the given verbosity LEVEL]:LEVEL' \
        {-L,--load-path=}'[prepend DIR to the package module search path]:DIR:_files -/' \
        {-K,--keep-failed}'[keep build tree of failed builds]' \
        {-k,--keep-going}'[keep going when some of the derivations fail]' \
        {-n,--dry-run}'[do not build the derivations]' \
        '--fallback[fall back to building when the substituter fails]' \
        '--no-substitutes[build instead of resorting to pre-built substitutes]' \
        '--substitute-urls=[fetch substitute from URLS if they are authorized]:URLS:_urls' \
        '--no-grafts[do not graft packages]' \
        '--no-offload[do not attempt to offload builds]' \
        '--max-silent-time=[mark the build as failed after SECONDS of silence]:SECONDS' \
        '--timeout=[mark the build as failed after SECONDS of activity]:SECONDS' \
        '--rounds=[build N times in a row to detect non-determinism]:N' \
        {-c,--cores=}'[allow the use of up to N CPU cores for the build]:N' \
        {-M,--max-jobs=}'[allow at most N build jobs]:N' \
        '--debug=[produce debugging output at LEVEL]:LEVEL' \
        '--help-transform[list package transformation options not shown here]' \
        {-V,--version}'[display version information and exit]' \
        '*:package:->packages'

    if [[ "$state" = packages ]]; then
        _guix_list_available_packages
        compadd -a -- _guix_available_packages
    fi
}

(( $+functions[_guix_remove] )) || _guix_remove()
{
    _arguments \
        {-p,--profile=}'[use PROFILE instead of the users default profile]:PROFILE:_files -/' \
        {-v,--verbosity=}'[use the given verbosity LEVEL]:LEVEL' \
        {-L,--load-path=}'[prepend DIR to the package module search path]:DIR:_files -/' \
        {-K,--keep-failed}'[keep build tree of failed builds]' \
        {-k,--keep-going}'[keep going when some of the derivations fail]' \
        {-n,--dry-run}'[do not build the derivations]' \
        '--fallback[fall back to building when the substituter fails]' \
        '--no-substitutes[build instead of resorting to pre-built substitutes]' \
        '--substitute-urls=[fetch substitute from URLS if they are authorized]:URLS:_urls' \
        '--no-grafts[do not graft packages]' \
        '--no-offload[do not attempt to offload builds]' \
        '--max-silent-time=[mark the build as failed after SECONDS of silence]:SECONDS' \
        '--timeout=[mark the build as failed after SECONDS of activity]:SECONDS' \
        '--rounds=[build N times in a row to detect non-determinism]:N' \
        {-c,--cores=}'[allow the use of up to N CPU cores for the build]:N' \
        {-M,--max-jobs=}'[allow at most N build jobs]:N' \
        '--debug=[produce debugging output at LEVEL]:LEVEL' \
        {-V,--version}'[display version information and exit]' \
        '*:package:->packages'

    if [[ "$state" = packages ]]; then
        _guix_list_installed_packages
        compadd -a -- _guix_installed_packages
    fi
}

(( $+functions[_guix_upgrade] )) || _guix_upgrade()
{
    _arguments \
        {-p,--profile=}'[use PROFILE instead of the users default profile]:PROFILE:_files -/' \
        {-v,--verbosity=}'[use the given verbosity LEVEL]:LEVEL' \
        '--do-not-upgrade=[do not upgrade any packages matching REGEXP]:REGEXP' \
        {-L,--load-path=}'[prepend DIR to the package module search path]:DIR:_files -/' \
        {-K,--keep-failed}'[keep build tree of failed builds]' \
        {-k,--keep-going}'[keep going when some of the derivations fail]' \
        {-n,--dry-run}'[do not build the derivations]' \
        '--fallback[fall back to building when the substituter fails]' \
        '--no-substitutes[build instead of resorting to pre-built substitutes]' \
        '--substitute-urls=[fetch substitute from URLS if they are authorized]:URLS:_urls' \
        '--no-grafts[do not graft packages]' \
        '--no-offload[do not attempt to offload builds]' \
        '--max-silent-time=[mark the build as failed after SECONDS of silence]:SECONDS' \
        '--timeout=[mark the build as failed after SECONDS of activity]:SECONDS' \
        '--rounds=[build N times in a row to detect non-determinism]:N' \
        {-c,--cores=}'[allow the use of up to N CPU cores for the build]:N' \
        {-M,--max-jobs=}'[allow at most N build jobs]:N' \
        '--debug=[produce debugging output at LEVEL]:LEVEL' \
        '--help-transform[list package transformation options not shown here]' \
        {-V,--version}'[display version information and exit]' \
        '*:regexp'
}

(( $+functions[_guix_publish] )) || _guix_publish()
{
    _arguments \
        {-p,--port=}'[listen on PORT]:PORT' \
        '--listen=[listen on the network interface for HOST]:HOST_hosts' \
        {-u,--user=}'[change privileges to USER as soon as possible]:USER_users' \
        {-a,--advertise}'[advertise on the local network]' \
        {-C,--compression=}'[compress archives with METHOD at LEVEL]:METHOD' \
        {-c,--cache=}'[cache published items to DIRECTORY]:DIRECTORY:_files -/' \
        '--cache-bypass-threshold=[serve store items below SIZE even when not cached]:SIZE' \
        '--workers=[use N workers to bake items]:N' \
        '--ttl=[announce narinfos can be cached for TTL seconds]:TTL' \
        '--negative-ttl=[announce missing narinfos can be cached for TTL seconds]:TTL' \
        '--nar-path=[use PATH as the prefix for nar URLs]:PATH' \
        '--public-key=[use FILE as the public key for signatures]:FILE:_files' \
        '--private-key=[use FILE as the private key for signatures]:FILE:_files' \
        {-r,--repl=}'[spawn REPL server on PORT]:PORT' \
        {-V,--version}'[display version information and exit]' \
}

(( $+functions[_guix_pull] )) || _guix_pull()
{
    _arguments \
        {-C,--channels=}'[deploy the channels defined in FILE]:FILE:_files' \
        '--url=[download from the Git repository at URL]:URL:_urls' \
        '--commit=[download the specified COMMIT]:COMMIT' \
        '--branch=[download the tip of the specified BRANCH]:BRANCH' \
        '--allow-downgrades[allow downgrades to earlier channel revisions]' \
        '--disable-authentication[disable channel authentication]' \
        {-N,--news}'[display news compared to the previous generation]' \
        {-l,--list-generations=}'[list generations matching PATTERN]:PATTERN' \
        '--roll-back[roll back to the previous generation]' \
        {-d,--delete-generations=}'[delete generations matching PATTERN]:PATTERN' \
        {-S,--switch-generation=}'[switch to a generation matching PATTERN]:PATTERN' \
        {-p,--profile=}'[use PROFILE instead of ~/.config/guix/current]:PROFILE:_files -/' \
        {-v,--verbosity=}'[use the given verbosity LEVEL]:LEVEL' \
        {-s,--system=}'[attempt to build for SYSTEM (e.g. "i686-linux")]:SYSTEM' \
        '--bootstrap[use the bootstrap Guile to build the new Guix]' \
        {-L,--load-path=}'[prepend DIR to the package module search path]:DIR:_files -/' \
        {-K,--keep-failed}'[keep build tree of failed builds]' \
        {-k,--keep-going}'[keep going when some of the derivations fail]' \
        {-n,--dry-run}'[do not build the derivations]' \
        '--fallback[fall back to building when the substituter fails]' \
        '--no-substitutes[build instead of resorting to pre-built substitutes]' \
        '--substitute-urls=[fetch substitute from URLS if they are authorized]:URLS:_urls' \
        '--no-grafts[do not graft packages]' \
        '--no-offload[do not attempt to offload builds]' \
        '--max-silent-time=[mark the build as failed after SECONDS of silence]:SECONDS' \
        '--timeout=[mark the build as failed after SECONDS of activity]:SECONDS' \
        '--rounds=[build N times in a row to detect non-determinism]:N' \
        {-c,--cores=}'[allow the use of up to N CPU cores for the build]:N' \
        {-M,--max-jobs=}'[allow at most N build jobs]:N' \
        '--debug=[produce debugging output at LEVEL]:LEVEL' \
        {-V,--version}'[display version information and exit]'
}

(( $+functions[_guix_refresh] )) || _guix_refresh()
{
    _arguments \
        {-e,--expression=}'[consider the package EXPR evaluates to]:EXPR' \
        {-u,--update}'[update source files in place]' \
        {-s,--select=}'[select all the packages in SUBSET, one of]:SUBSET:(core non-core)' \
        {-m,--manifest=}'[select all the packages from the manifest in FILE]:FILE:_files' \
        {-t,--type=}'[restrict to updates from the specified updaters]:UPDATER:-.updaters' \
        {-L,--list-updaters}'[list available updaters and exit]' \
        {-l,--list-dependent}'[list top-level dependent packages that would need to be rebuilt as a result of upgrading PACKAGE...]' \
        {-r,--recursive}'[check the PACKAGE and its inputs for upgrades]' \
        '--list-transitive[list all the packages that PACKAGE depends on]' \
        '--keyring=[use FILE as the keyring of upstream OpenPGP keys]:FILE:_files' \
        '--key-server=[use HOST as the OpenPGP key server]:HOST_hosts' \
        '--gpg=[use COMMAND as the GnuPG 2.x command]:COMMAND' \
        '--key-download=[handle missing OpenPGP keys according to POLICY:]:POLICY:(always interactive never)' \
        '--load-path=[prepend DIR to the package module search path]:DIR:_files -/' \
        {-V,--version}'[display version information and exit]' \
        '*:package:->packages'

    case "$state" in
        updaters)
            _guix_list_updaters
            compadd -a -- _guix_updaters
            ;;
        packages)
            _guix_list_available_packages
            compadd -a -- _guix_available_packages
            ;;
    esac
}

(( $+functions[_guix_size] )) || _guix_size()
{
    _arguments \
        '--substitute-urls=[fetch substitute from URLS if they are authorized]:URLS:_urls' \
        {-s,--system=}'[consider packages for SYSTEM (e.g. "i686-linux")]:SYSTEM' \
        '--sort=[sort according to KEY]:KEY:(closure self)' \
        {-m,--map-file=}'[write to FILE a graphical map of disk usage]:FILE:_files' \
        {-L,--load-path=}'[prepend DIR to the package module search path]:DIR:_files -/' \
        {-V,--version}'[display version information and exit]' \
        '*:package:->packages'

        if [[ "$state" = packages ]]; then
            _guix_list_available_packages
            compadd -a -- _guix_available_packages
        fi
}

(( $+functions[_guix_system] )) || _guix_system()
{
    _arguments \
        {-L,--load-path=}'[prepend DIR to the package module search path]:DIR:_files -/' \
        {-K,--keep-failed}'[keep build tree of failed builds]' \
        {-k,--keep-going}'[keep going when some of the derivations fail]' \
        {-n,--dry-run}'[do not build the derivations]' \
        '--fallback[fall back to building when the substituter fails]' \
        '--no-substitutes[build instead of resorting to pre-built substitutes]' \
        '--substitute-urls=[fetch substitute from URLS if they are authorized]:URLS:_urls' \
        '--no-grafts[do not graft packages]' \
        '--no-offload[do not attempt to offload builds]' \
        '--max-silent-time=[mark the build as failed after SECONDS of silence]:SECONDS' \
        '--timeout=[mark the build as failed after SECONDS of activity]:SECONDS' \
        '--rounds=[build N times in a row to detect non-determinism]:N' \
        {-c,--cores=}'[allow the use of up to N CPU cores for the build]:N' \
        {-M,--max-jobs=}'[allow at most N build jobs]:N' \
        '--debug=[produce debugging output at LEVEL]:LEVEL' \
        {-d,--derivation}'[return the derivation of the given system]' \
        {-e,--expression=}'[consider the operating-system EXPR evaluates to instead of reading FILE, when applicable]:EXPR' \
        '--allow-downgrades[for reconfigure, allow downgrades to earlier channel revisions]' \
        '--on-error=[apply STRATEGY  when an error occurs while reading FILE]:STRATEGY:(nothing-special backtrace debug)' \
        '--list-image-types[list available image types]' \
        {-t,--image-type=}'[for image, produce an image of TYPE]:TYPE' \
        '--image-size=[for image, produce an image of SIZE]:SIZE' \
        '--no-bootloader[for init, do not install a bootloader]' \
        '--volatile[for image, make the root file system volatile]' \
        '--label=[for image, label disk image with LABEL]:LABEL' \
        '--save-provenance[save provenance information]' \
        '--share=[for vm and container, share host file system with read/write access according to SPEC]:SPEC' \
        '--expose=[for vm and container, expose host file system directory as read-only according to SPEC]:SPEC' \
        {-N,--network}'[for container, allow containers to access the network]' \
        {-r,--root=}'[for vm, image, container and build, make FILE a symlink to the result, and register it as a GC root]:FILE:_files' \
        '--full-boot[for vm, make a full boot sequence]' \
        '--skip-checks[skip file system and initrd module safety checks]' \
        '--target=[cross-build for TRIPLET (e.g. "armel-linux-gnu")]:TRIPLET' \
        {-v,--verbosity=}'[use the given verbosity LEVEL]:LEVEL' \
        '--graph-backend=[use BACKEND for extension-graphs and shepherd-graph]:BACKEND' \
        {-V,--version}'[display version information and exit]' \
        '1:action:->actions' \
        '*:file:_files'

    if [[ "$state" = actions ]]; then
        _guix_list_actions
        compadd -a -- _guix_actions
    fi
}

(( $+functions[_guix_command] )) || _guix_command()
{
    local -a _guix_cmds
    _guix_cmds=(
        "archive:Export/import one or more packages from/to the store"
        "build:Build a given package"
        "challenge:Challenge the substitutes for a package"
        "container:Build and manipulate Linux containers"
        "copy:Copy store items remotely over SSH"
        "deploy:Deploy operating systems on a set of machines"
        "describe:Describe the channel revisions currently used"
        "download:Download the file at given URL and add it to the store"
        "edit:Edit the definitions of a package"
        "environment:Build an environment with a package and its dependencies"
        "gc:Invoke the garbage collector"
        "git:Operate on Git repositories"
        "graph:Emit a DOT representation of the dependencies of a package"
        "hash:Return the cryptographic hash of a file"
        "import:Run an importer"
        "install:Install packages"
        "lint:Run a set of checkers on a package"
        "offload:Set up and operate build offloading"
        "pack:Create application bundles"
        "package:Install, remove, or upgrade packages"
        "processes:List currently running sessions"
        "publish:Publish /gnu/store over HTTP."
        "pull:Download and deploy the latest version of Guix"
        "refresh:Update package definitions to match the latest version"
        "remove:Remove packages"
        "repl:Read-eval-print loop (REPL) for interactive programming"
        "search:Search for packages"
        "show:Show information about packages"
        "size:Report the size of a package and its dependencies"
        "system:Build the operating system"
        "time-machine:Run commands from a different revision"
        "upgrade:Upgrade packages"
        "weather:Report on the availability of pre-built package binaries"
    )

    if (( CURRENT == 1 )); then
        _describe -t commands 'guix command' _guix_cmds || compadd "$@"
    else
        local curcontext="$curcontext"

        cmd="${${_guix_cmds[(r)$words[1]:*]%%:*}}"

        if (( $#cmd )); then
            local cache_policy

            zstyle -s ":completion:${curcontext}:" cache-policy cache_policy
            if [[ -z "$cache_policy" ]]; then
                zstyle ":completion:${curcontext}:" cache-policy _guix_caching_policy
            fi

            curcontext="${curcontext%:*:*}:guix-${cmd}:"

            _call_function ret _guix_${cmd} || _message 'no more arguments'
        else
            _message "unknown guix command: $words[1]"
        fi
        return ret
    fi
}

_arguments \
    '(--version)--version[Display version information and exit]' \
    '*::guix command:_guix_command'

# vim: ts=4 sts=4 sw=4 et ai
# Local variables:
# mode: sh
# End: