aboutsummaryrefslogtreecommitdiff
path: root/etc/completion/zsh/_guix
blob: 9b1f16c664e598177cc2c82eab42d3bf94d1f81a (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
#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: