scripts/shell_completions/zsh/_borg
#compdef borg borgfs -P -value-,BORG_*,-default-
# Zsh completion for Borg Backup 1.2.0a9 (2020-09-27).
#
# Recommended _borg specific settings:
#
# zstyle -e ':completion:*:*:borg-*:argument-rest:*' tag-order \
# '[[ $words[CURRENT] == -* ]] && reply=( "! archives archive-files" "-" )'
# zstyle ':completion:*:*:(borg|-value-,BORG_)*' sort false
# zstyle ':completion:*:*:borg-config:argument-2:keys' list-grouped false
# zstyle ':completion:*:*:borg-*:*' gain-privileges true
# zstyle ':completion:*' fake-parameters 'BORG_REPO:scalar'
#
# Custom styles:
#
# archive-description-format
# Default: `{archive:<36} {time} [{id}]`.
# archive-sort
# In which order archive names should be listed.
# Possible values are: `inverse`, `timestamp`, `name`, `id`.
# file-description-format
# Default: `{mode} {user:6} {group:6} {size:8d} {mtime} {path}{extra}`.
# path-style-selector
# Style selector used to select a path (when Borg would use either `pp` or `pf`).
# Default: `fm`.
# repository-suffix
# This boolean style controls whether to add the `::` auto-removable suffix to a repository.
# Default: `true`.
(( $+functions[_borg_commands] )) ||
_borg_commands() {
local -a commands_=(
'benchmark:benchmark command'
'break-lock:break the repository lock'
'check:check repository consistency'
'compact:compact segment files in the repository'
'config:get, set, and delete values in a repository or cache config file'
'create:create new archive'
'debug:debugging command (not intended for normal use)'
'delete:delete an existing repository or archives'
'diff:diff contents of two archives'
'export-tar:export archive contents as a tarball'
'extract:extract archive contents'
'help:extra help'
'info:show repository or archive information'
'init:initialize an empty repository'
'key:manage repository key'
'list:list archive or repository contents'
'mount:mount archive or an entire repository as a FUSE filesystem'
'prune:prune repository archives according to specified rules'
'recreate:re-create archives'
'rename:rename an existing archive'
'serve:start in server mode'
'umount:un-mount the FUSE filesystem'
'upgrade:upgrade a repository from a previous version'
'with-lock:run a user specified command with the repository lock held'
)
_describe -t commands 'borg commands' commands_
}
(( $+functions[_borg-benchmark] )) ||
_borg-benchmark() {
local -a common_options
__borg_setup_common_options
_arguments -s -w -S : \
$common_options \
':type:(crud)' \
': :_borg_repository' \
':PATH:_files'
}
(( $+functions[_borg-break-lock] )) ||
_borg-break-lock() {
local -a common_options
__borg_setup_common_options
_arguments -s -w -S : \
$common_options \
':: :_borg_repository'
}
(( $+functions[_borg-check] )) ||
_borg-check() {
local -a common_options common_archive_filters_options
__borg_setup_common_options
__borg_setup_common_archive_filters_options
_arguments -s -w -S : \
'--repository-only[only perform repository checks]' \
'--archives-only[only perform archives checks]' \
'(--repository-only)--verify-data[perform cryptographic archive data integrity verification]' \
'--repair[attempt to repair any inconsistencies found]' \
'--save-space[work slower, but using less space]' \
'--max-duration=[partial repo check for max. SECONDS]: : _borg_guard_unsigned_number "SECONDS"' \
$common_archive_filters_options \
$common_options \
'::REPOSITORY_OR_ARCHIVE: _borg_repository_or_archive'
}
(( $+functions[_borg-compact] )) ||
_borg-compact() {
local -a common_options
__borg_setup_common_options
_arguments -s -w -S : \
$common_options \
'--cleanup-commits[cleanup commit-only 17-byte segment files]' \
'--threshold=[set minimum threshold for saved space in PERCENT (default: 10)]: : _borg_guard_unsigned_number "PERCENT (default\: 10)"' \
':: :_borg_repository'
}
(( $+functions[_borg-config] )) ||
_borg-config() {
local -a common_options
__borg_setup_common_options
_arguments -s -w -S : \
'(-c --cache)'{-c,--cache}'[get and set values from the repo cache]' \
'(-d --delete)'{-d,--delete}'[delete the key from the config]' \
'(-l --list)'{-l,--list}'[list the configuration of the repo]' \
$common_options \
': :_borg_repository' \
': : _borg_config $line[1]' \
'::VALUE'
}
(( $+functions[_borg-create] )) ||
_borg-create() {
local -a common_options common_create_options state line
local curcontext="$curcontext" state_descr
declare -A opt_args
local -i ret=1
__borg_setup_common_options
__borg_setup_common_create_options
local lastspec='*:PATH:_files'
(( $words[(I)--content-from-command] )) &&
lastspec='*:::PATH:->command'
_arguments -C -s -w -S : \
'*'{-e,--exclude}'=[exclude paths matching PATTERN]: : _borg_style_selector_or_archive_files -f -e "$line[1]" fm "${(@)line[2,-1]}"' \
'*--pattern=[experimental: include/exclude paths matching PATTERN]: : _borg_style_selector_or_archive_files -p -f -e "$line[1]" sh "${(@)line[2,-1]}"' \
$common_create_options \
'(-s --stats)--json[Output stats as JSON. Implies --stats.]' \
'--no-cache-sync[experimental: do not synchronize the cache. Implies not using the files cache.]' \
'--stdin-name=[use NAME in archive for stdin data (default: "stdin")]:NAME' \
'--content-from-command[interpret PATH as command and store its stdout]' \
'--exclude-nodump[exclude files flagged NODUMP]' \
'(-x --one-file-system)'{-x,--one-file-system}'[stay in the same file system]' \
'--numeric-owner[only store numeric user and group identifiers]' \
'--noatime[do not store atime into archive]' \
'--atime[do store atime into archive]' \
'--noctime[do not store ctime into archive]' \
'--nobirthtime[do not store birthtime (creation date) into archive]' \
'--nobsdflags[deprecated, use --noflags instead]' \
'--noacls[do not read and store ACLs into archive]' \
'--noxattrs[do not read and store xattrs into archive]' \
'--noflags[do not read and store flags (e.g. NODUMP, IMMUTABLE) into archive]' \
'--files-cache=[operate files cache in MODE. default: ctime,size,inode]:MODE:(ctime,size,inode mtime,size,inode ctime,size mtime,size rechunk,ctime rechunk,mtime size disabled)' \
'--read-special[open and read block and char device files as well as FIFOs as if they were regular files]' \
$common_options \
':ARCHIVE: _borg_repository_or_archive -a -p' \
$lastspec && ret=0
case $state in
(command)
if (( CURRENT <= 1 )); then
_command_names -e && ret=0
else
_normal && ret=0
fi
;;
esac
return ret
}
(( $+functions[_borg-debug] )) ||
_borg-debug() {
local -a state line common_options
local curcontext="$curcontext" state_descr
declare -A opt_args
local -i ret=1
__borg_setup_common_options
_arguments -s -w -C : \
$common_options \
': :->command' \
'*:: :->option-or-argument' && ret=0
case $state in
(command)
local -a debug_commands=(
'info:show system infos for debugging / bug reports'
'dump-archive-items:dump archive items (metadata)'
'dump-archive:dump decoded archive metadata'
'dump-manifest:dump decoded repository metadata'
'dump-repo-objs:dump repo objects'
'search-repo-objs:search repo objects'
'get-obj:get object from repository'
'put-obj:put object to repository'
'delete-obj:delete object from repository'
'refcount-obj:show refcount for object from repository'
'dump-hints:dump repository hints'
'convert-profile:convert Borg profile to Python profile'
)
_describe -t commands 'command' debug_commands && ret=0
;;
(option-or-argument)
curcontext="${curcontext%:*}-$line[1]:"
case $line[1] in
(info)
_arguments -s -w -S : \
$common_options && ret=0
;;
(dump-archive-items)
_arguments -s -w -S : \
$common_options \
':ARCHIVE: _borg_repository_or_archive -a' && ret=0
;;
(dump-archive)
_arguments -s -w -S : \
$common_options \
':ARCHIVE: _borg_repository_or_archive -a' \
':PATH:_files' && ret=0
;;
(dump-manifest)
_arguments -s -w -S : \
$common_options \
': :_borg_repository' \
':PATH:_files' && ret=0
;;
(dump-repo-objs)
_arguments -s -w -S : \
$common_options \
': :_borg_repository' && ret=0
;;
(search-repo-objs)
_arguments -s -w -S : \
$common_options \
': :_borg_repository' \
':WANTED (hex or string):' && ret=0
;;
(get-obj)
_arguments -s -w -S : \
$common_options \
': :_borg_repository' \
':ID (hex object):' \
':PATH:_files' && ret=0
;;
(put-obj)
_arguments -s -w -S : \
$common_options \
': :_borg_repository' \
'*:PATH:_files' && ret=0
;;
(delete-obj)
_arguments -s -w -S : \
$common_options \
': :_borg_repository' \
'*:ID (hex object):' && ret=0
;;
(refcount-obj)
_arguments -s -w -S : \
$common_options \
': :_borg_repository' \
'*:ID (hex object):' && ret=0
;;
(dump-hints)
_arguments -s -w -S : \
$common_options \
': :_borg_repository' \
'*:PATH:_files' && ret=0
;;
(convert-profile)
_arguments -s -w -S : \
$common_options \
':INPUT:_files' \
':OUTPUT:_files' && ret=0
;;
(*)
if ! _call_function ret _borg_debug_$line[1]; then
_default && ret=0
fi
;;
esac
;;
esac
return ret
}
(( $+functions[_borg-delete] )) ||
_borg-delete() {
local -a common_options common_archive_filters_options common_dry_run_stats_options
__borg_setup_common_options
__borg_setup_common_archive_filters_options
__borg_setup_common_dry_run_stats_options
_arguments -s -w -S : \
$common_dry_run_stats_options \
'--cache-only[delete only the local cache for the given repository]' \
'*--force[force deletion of corrupted archives, use "--force --force" in case "--force" does not work]' \
'--keep-security-info[keep the local security info when deleting a repository]' \
'--save-space[work slower, but using less space]' \
$common_archive_filters_options \
$common_options \
':REPOSITORY_OR_ARCHIVE: _borg_repository_or_archive' \
'*:ARCHIVE: _borg_archive "${line[1]%%::*}"'
}
(( $+functions[_borg-diff] )) ||
_borg-diff() {
local -a common_options common_exclude_options
__borg_setup_common_options
__borg_setup_common_exclude_options
_arguments -s -w -S : \
'--numeric-owner[only obey numeric user and group identifiers]' \
'--same-chunker-params[override check of chunker parameters]' \
'--sort[sort the output lines by file path]' \
'--json-lines[format output as JSON Lines]' \
$common_exclude_options \
$common_options \
':ARCHIVE1: _borg_repository_or_archive -a' \
':ARCHIVE2: _borg_archive "${line[1]%%::*}"' \
'*: : _borg_style_selector_or_archive_files -e "$line[1]" pp'
}
(( $+functions[_borg-export-tar] )) ||
_borg-export-tar() {
local -a common_options common_exclude_extract_options
__borg_setup_common_options
__borg_setup_common_exclude_extract_options
_arguments -s -w -S : \
'--tar-filter[filter program to pipe data through]: :_cmdstring' \
'--list[output verbose list of items (files, dirs, ...)]' \
$common_exclude_extract_options \
$common_options \
':ARCHIVE: _borg_repository_or_archive -a' \
':FILE:_files' \
'*: : _borg_style_selector_or_archive_files -e "$line[1]" pp'
}
(( $+functions[_borg-extract] )) ||
_borg-extract() {
local -a common_options common_exclude_extract_options
__borg_setup_common_options
__borg_setup_common_exclude_extract_options
_arguments -s -w -S : \
'--list[output verbose list of items (files, dirs, ...)]' \
'(-n --dry-run)'{-n,--dry-run}'[do not actually change any files]' \
'--numeric-owner[only obey numeric user and group identifiers]' \
'--nobsdflags[deprecated, use --noflags instead]' \
'--noacls[do not extract/set ACLs]' \
'--noxattrs[do not extract/set xattrs]' \
'--noflags[do not extract/set flags (e.g. NODUMP, IMMUTABLE)]' \
'--stdout[write all extracted data to stdout]' \
'--sparse[create holes in output sparse file from all-zero chunks]' \
$common_exclude_extract_options \
$common_options \
':ARCHIVE: _borg_repository_or_archive -a' \
'*: : _borg_style_selector_or_archive_files -e "$line[1]" pp'
}
(( $+functions[_borg-help] )) ||
_borg-help() {
local -a common_options
__borg_setup_common_options
_arguments -s -w -S : \
'--epilog-only' \
'--usage-only' \
$common_options \
':: : _alternative "topics:TOPIC:(patterns placeholders compression)" ": :_borg_commands"'
}
(( $+functions[_borg-info] )) ||
_borg-info() {
local -a common_options common_archive_filters_options
__borg_setup_common_options
__borg_setup_common_archive_filters_options
_arguments -s -w -S : \
'--json[format output as JSON]' \
$common_archive_filters_options \
$common_options \
'::REPOSITORY_OR_ARCHIVE: _borg_repository_or_archive'
}
(( $+functions[_borg-init] )) ||
_borg-init() {
local -i ret=1
local -a common_options common_init_options
__borg_setup_common_options
__borg_setup_common_init_options
# special handling for the required optional argument
if (( ! ${words[(I)(-e|--encryption)(|=*)]} )); then
local desc='select encryption key mode'
local -a long=( "--encryption:$desc" ) short=( "-e:$desc" ) remove_chars=( -r '= \t\n\-' )
_describe -t required-options 'required option' long -S '=' $remove_chars -- short $remove_chars && ret=0
fi
_arguments -s -w -S : \
'(-e --encryption)'{-e,--encryption}'=[select encryption key mode (required)]:MODE:(none keyfile keyfile-blake2 repokey repokey-blake2 authenticated authenticated-blake2)' \
$common_init_options \
'--make-parent-dirs[create parent directories]' \
'::REPOSITORY:_directories' && ret=0
return ret
}
(( $+functions[_borg-key] )) ||
_borg-key() {
local -a state line common_options
local curcontext="$curcontext" state_descr
declare -A opt_args
local -i ret=1
__borg_setup_common_options
_arguments -s -w -C : \
$common_options \
': :->command' \
'*:: :->option-or-argument' && ret=0
case $state in
(command)
local -a key_commands=(
'change-passphrase:Change repository key file passphrase'
'export:Export the repository key for backup'
'import:Import the repository key from backup'
'migrate-to-repokey:Migrate passphrase -> repokey'
)
_describe -t commands 'command' key_commands && ret=0
;;
(option-or-argument)
curcontext="${curcontext%:*}-$line[1]:"
case $line[1] in
(change-passphrase)
_arguments -s -w -S : \
$common_options \
': :_borg_repository' && ret=0
;;
(export)
_arguments -s -w -S : \
'--paper[create an export suitable for printing and later type-in]' \
'--qr-html[create an html file suitable for printing and later type-in or qr scan]' \
$common_options \
': :_borg_repository' \
'::PATH:_files' && ret=0
;;
(import)
_arguments -s -w -S : \
'--paper[interactively import from a backup done with --paper]' \
$common_options \
': :_borg_repository' \
'::PATH:_files' && ret=0
;;
(migrate-to-repokey)
_arguments -s -w -S : \
$common_options \
':: :_borg_repository' && ret=0
;;
(*)
if ! _call_function ret _borg_key_$line[1]; then
_default && ret=0
fi
;;
esac
;;
esac
return ret
}
(( $+functions[_borg-list] )) ||
_borg-list() {
local -a common_options common_exclude_options common_archive_filters_options
__borg_setup_common_options
__borg_setup_common_exclude_options
__borg_setup_common_archive_filters_options
_arguments -s -w -S : \
'--consider-checkpoints[show checkpoint archives in the repository contents list (default: hidden)]' \
'--short[only print file/directory names, nothing else]' \
{--format,--list-format}'=[specify format for file listing]:FORMAT: _borg_format_keys $line[1]' \
'--json[Only valid for listing repository contents. Format output as JSON.]' \
'--json-lines[Only valid for listing archive contents. Format output as JSON Lines.]' \
$common_archive_filters_options \
$common_exclude_options \
$common_options \
':REPOSITORY_OR_ARCHIVE: _borg_repository_or_archive' \
'*: : _borg_style_selector_or_archive_files -e "$line[1]" pp'
}
(( $+functions[_borg-mount] )) ||
_borg-mount() {
local -a common_options common_exclude_extract_options common_archive_filters_options
__borg_setup_common_options
__borg_setup_common_exclude_extract_options
__borg_setup_common_archive_filters_options
_arguments -s -w -S : \
$* \
'--consider-checkpoints[show checkpoint archives in the repository contents list (default: hidden)]' \
'(-f --foreground)'{-f,--foreground}'[stay in foreground, do not daemonize]' \
'-o[mount options]: :_fuse_values "mount options"
"versions[merged, versioned view of the files in the archives]"
"allow_damaged_files[read damaged files]"
"ignore_permissions[not enforce \"default_permissions\"]"' \
$common_archive_filters_options \
$common_exclude_extract_options \
$common_options \
':REPOSITORY_OR_ARCHIVE: _borg_repository_or_archive' \
':MOUNTPOINT:_directories' \
'*: : _borg_style_selector_or_archive_files "$line[1]" pp'
}
(( $+functions[_borg-prune] )) ||
_borg-prune() {
local -a common_options common_prefix_and_glob_archives_filter_options common_dry_run_stats_options
__borg_setup_common_options
__borg_setup_common_prefix_and_glob_archives_filter_options
__borg_setup_common_dry_run_stats_options
_arguments -s -w -S : \
$common_dry_run_stats_options \
'*--force[force pruning of corrupted archives, use "--force --force" in case "--force" does not work]' \
'--list[output verbose list of archives it keeps/prunes]' \
'--keep-within[keep all archives within this time interval]: : _borg_guard_unsigned_number "INTERVAL"' \
'(--keep-last --keep-secondly)'{--keep-last,--keep-secondly}'[number of secondly archives to keep]: : _borg_guard_unsigned_number "N"' \
'--keep-minutely[number of minutely archives to keep]: : _borg_guard_unsigned_number "N"' \
'(-H --keep-hourly)'{-H,--keep-hourly}'[number of hourly archives to keep]: : _borg_guard_unsigned_number "N"' \
'(-d --keep-daily)'{-d,--keep-daily}'[number of daily archives to keep]: : _borg_guard_unsigned_number "N"' \
'(-w --keep-weekly)'{-w,--keep-weekly}'[number of weekly archives to keep]: : _borg_guard_unsigned_number "N"' \
'(-m --keep-monthly)'{-m,--keep-monthly}'[number of monthly archives to keep]: : _borg_guard_unsigned_number "N"' \
'(-y --keep-yearly)'{-y,--keep-yearly}'[number of yearly archives to keep]: : _borg_guard_unsigned_number "N"' \
'--save-space[work slower, but using less space]' \
$common_prefix_and_glob_archives_filter_options \
$common_options \
':: :_borg_repository'
}
(( $+functions[_borg-recreate] )) ||
_borg-recreate() {
local -a common_options common_create_options
__borg_setup_common_options
__borg_setup_common_create_options
local -a mods=(
'if-different:recompress if current compression is with a different compression algorithm (the level is not considered)'
'always:recompress even if current compression is with the same compression algorithm (use this to change the compression level)'
'never:do not recompress (use this option explicitly to prevent recompression)'
)
mods=( ${(q)mods//\\/\\\\} )
mods=( ${mods//:/\\:} )
_arguments -s -w -S : \
$common_create_options \
'--target=[create a new archive with the name ARCHIVE]:ARCHIVE: _borg_placeholder_or_archive "${line[1]%%\:\:*}"' \
'--recompress=[recompress data chunks according to "MODE" and "--compression"]:MODE:'"(($mods))" \
$common_options \
':REPOSITORY_OR_ARCHIVE: _borg_repository_or_archive' \
'*: : _borg_style_selector_or_archive_files -e "$line[1]" pp'
}
(( $+functions[_borg-rename] )) ||
_borg-rename() {
local -a common_options
__borg_setup_common_options
_arguments -s -w -S : \
$common_options \
':ARCHIVE: _borg_repository_or_archive -a' \
':NEWNAME'
}
(( $+functions[_borg-serve] )) ||
_borg-serve() {
local -a common_options common_init_options
__borg_setup_common_options
__borg_setup_common_init_options
_arguments -s -w -S : \
$common_init_options \
'*--restrict-to-path=[restrict repository access to PATH]:PATH:_files' \
'*--restrict-to-repository=[restrict repository access]: :_borg_repository'
}
(( $+functions[_borg-umount] )) ||
_borg-umount() {
local -a common_options
__borg_setup_common_options
_arguments -s -w -S : \
$common_options \
':MOUNTPOINT:_umountable'
}
(( $+functions[_borg-upgrade] )) ||
_borg-upgrade() {
local -a common_options
__borg_setup_common_options
_arguments -s -w -S : \
'(-n --dry-run)'{-n,--dry-run}'[do not change repository]' \
'--inplace[rewrite repository in place, with no chance of going back to older versions of the repository]' \
'--force[force upgrade]' \
'--tam[enable manifest authentication (in key and cache)]' \
'--disable-tam[disable manifest authentication (in key and cache)]' \
$common_options \
':: :_borg_repository'
}
(( $+functions[_borg-with-lock] )) ||
_borg-with-lock() {
local -a state line common_options
local curcontext="$curcontext" state_descr
declare -A opt_args
local -i ret=1
__borg_setup_common_options
_arguments -s -w -C -S : \
$common_options \
'(-): :_borg_repository' \
'(-):COMMAND: _command_names -e' \
'(-)*:ARGS:->normal' && ret=0
case $state in
(normal)
shift 2 words
(( CURRENT -= 2 ))
_normal && ret=0
;;
esac
return ret
}
(( $+functions[__borg_setup_common_options] )) ||
__borg_setup_common_options() {
typeset -ga common_options=(
'(- :)'{-h,--help}'[show this help message and exit]'
'--critical[work on log level CRITICAL]'
'--error[work on log level ERROR]'
'--warning[work on log level WARNING (default)]'
'(--info -v --verbose)'{--info,-v,--verbose}'[work on log level INFO]'
'--debug[work on log level DEBUG]'
'--debug-topic=[enable TOPIC debugging (can be specified multiple times)]:TOPIC'
'(-p --progress)'{-p,--progress}'[show progress information]'
'--log-json[Output one JSON object per log line instead of formatted text.]'
'--lock-wait=[wait at most SECONDS for acquiring a repository/cache lock (default: 1)]: : _borg_guard_unsigned_number "SECONDS"'
'--bypass-lock[bypass locking mechanism]'
'(- :)--show-version[show/log the borg version]'
'--show-rc[show/log the return code (rc)]'
'--umask=[set umask to M (local only, default: 0077)]:M'
'--remote-path=[set remote path to executable (default: "borg")]: :_cmdstring'
'--remote-ratelimit=[set remote network upload rate limit in kiByte/s (default: 0=unlimited)]: : _borg_guard_unsigned_number "RATE"'
'--remote-buffer=[set upload buffer size in MiB. (default: 0=no buffer)]: : _borg_guard_unsigned_number "UPLOAD_BUFFER"'
'--consider-part-files[treat part files like normal files (e.g. to list/extract them)]'
'--debug-profile=[write execution profile in Borg format into FILE]:FILE:_files'
'--rsh=[use COMMAND instead of ssh]: :_cmdstring'
)
}
(( $+functions[__borg_setup_common_exclude_options] )) ||
__borg_setup_common_exclude_options() {
typeset -ga common_exclude_options=(
'*'{-e,--exclude}'=[exclude paths matching PATTERN]: : _borg_style_selector_or_archive_files "$line[1]" fm'
'*--exclude-from=[read exclude patterns from EXCLUDEFILE, one per line]:EXCLUDEFILE:_files'
'*--pattern=[experimental: include/exclude paths matching PATTERN]: : _borg_style_selector_or_archive_files -p "$line[1]" sh'
'*--patterns-from=[experimental: read include/exclude patterns from PATTERNFILE, one per line]:PATTERNFILE:_files'
)
}
(( $+functions[__borg_setup_common_exclude_extract_options] )) ||
__borg_setup_common_exclude_extract_options() {
local -a common_exclude_options
__borg_setup_common_exclude_options
typeset -ga common_exclude_extract_options=(
$common_exclude_options
'--strip-components=[Remove the specified number of leading path elements. Paths with fewer elements will be silently skipped.]: : _borg_guard_unsigned_number "NUMBER"'
)
}
(( $+functions[__borg_setup_common_prefix_and_glob_archives_filter_options] )) ||
__borg_setup_common_prefix_and_glob_archives_filter_options() {
typeset -ga common_prefix_and_glob_archives_filter_options=(
'(-P --prefix -a --glob-archives)'{-P,--prefix}'=[only consider archive names starting with this prefix]:PREFIX: _borg_archive -n "${line[1]%%\:\:*}"'
'(-P --prefix)*'{-a,--glob-archives}'=[only consider archive names matching the glob]:GLOB: _borg_archive -n "${line[1]%%\:\:*}"'
)
}
(( $+functions[__borg_setup_common_archive_filters_options] )) ||
__borg_setup_common_archive_filters_options() {
local -a common_prefix_and_glob_archives_filter_options
__borg_setup_common_prefix_and_glob_archives_filter_options
typeset -ga common_archive_filters_options=(
$common_prefix_and_glob_archives_filter_options
'--sort-by=[Comma-separated list of sorting keys, default: timestamp]:KEYS:(timestamp name id)'
'(--last)--first=[consider first N archives after other filters were applied]:N: _borg_archive -n "${line[1]%%\:\:*}"'
'(--first)--last=[consider last N archives after other filters were applied]:N: _borg_archive -n "${line[1]%%\:\:*}"'
)
}
(( $+functions[__borg_setup_common_dry_run_stats_options] )) ||
__borg_setup_common_dry_run_stats_options() {
typeset -ga common_dry_run_stats_options=(
'(-n --dry-run -s --stats)'{-n,--dry-run}'[do not change anything]'
'(-n --dry-run -s --stats)'{-s,--stats}'[print statistics at end]'
# NOTE: actual messages for subcommands differ in details
)
}
(( $+functions[__borg_setup_common_create_options] )) ||
__borg_setup_common_create_options() {
local -a common_dry_run_stats_options common_exclude_options
__borg_setup_common_dry_run_stats_options
__borg_setup_common_exclude_options
typeset -ga common_create_options=(
$common_dry_run_stats_options
'--list[output verbose list of items (files, dirs, ...)]'
'--filter=[only display items with the given status characters]: :_borg_statuschars'
$common_exclude_options
'--exclude-caches[exclude directories that contain a CACHEDIR.TAG file]'
'*--exclude-if-present=[exclude directories that are tagged by containing a filesystem object with the given NAME]:NAME:_files'
'--keep-exclude-tags[if tag objects are specified with --exclude-if-present, don'\''t omit the tag objects themselves]'
'--comment=[add a comment text to the archive]:COMMENT:_borg_placeholders'
'--timestamp=[manually specify the archive creation date/time]:TIMESTAMP:_borg_timestamp'
'(-c --checkpoint-interval)'{-c,--checkpoint-interval}'=[write checkpoint every SECONDS seconds (default: 1800)]: : _borg_guard_unsigned_number "SECONDS"'
'--chunker-params=[specify the chunker parameters]: :_borg_chunker_params_examples'
'(-C --compression)'{-C,--compression}'=[select compression algorithm]: :_borg_compression'
)
}
(( $+functions[__borg_setup_common_init_options] )) ||
__borg_setup_common_init_options() {
local -a common_options
__borg_setup_common_options
typeset -ga common_init_options=(
$common_options
'--append-only[only allow appending to repository segment files]'
'--storage-quota=[override storage quota of the repository]: :_borg_quota_suffixes'
)
}
(( $+functions[_borgfs] )) ||
_borgfs() {
_borg-mount '(- :)'{-V,--version}'[show version number and exit]'
}
(( $+functions[_borg_parameters] )) ||
_borg_parameters() {
local name=$1
shift
local -i ret=1
local -a expl
case $name in
(REPO)
local BORG_REPO
unset BORG_REPO
_borg_repository && ret=0
;;
((|NEW_)PASSPHRASE)
_message -e 'passphrase' && ret=0
;;
(DISPLAY_PASSPHRASE)
_message -e 'answer to the "display the passphrase for verification" question' && ret=0
;;
(HOST_ID)
_message -e 'unique ID' && ret=0
;;
(FILES_CACHE_TTL)
_borg_guard_unsigned_number 'time to live (default: 20)' && ret=0
;;
(MOUNT_DATA_CACHE_ENTRIES)
_borg_guard_unsigned_number 'number of cached data chunks' && ret=0
;;
(PASSCOMMAND|RSH|REMOTE_PATH)
_cmdstring && ret=0
;;
(HOSTNAME_IS_UNIQUE|SHOW_SYSINFO|(UNKNOWN_UNENCRYPTED|RELOCATED)_REPO_ACCESS_IS_OK)
_description values expl 'value'
compadd "$expl[@]" yes no && ret=0
;;
((CHECK|DELETE)_I_KNOW_WHAT_I_AM_DOING)
_description values expl 'value'
compadd "$expl[@]" YES NO && ret=0
;;
(SELFTEST)
_description values expl 'value'
compadd "$expl[@]" disabled && ret=0
;;
(WORKAROUNDS)
_wanted workarounds expl 'workaround' _sequence compadd - basesyncfile && ret=0
;;
(KEYS_DIR)
_directories && ret=0
;;
(*)
_default && ret=0
;;
esac
return ret
}
(( $+functions[_borg_repository] )) ||
_borg_repository() {
local -a alts opts qopts
zparseopts -E -a opts S:
qopts=( ${(q)opts} )
[[ -n $BORG_REPO ]] && alts+=( "default-repository: : __borg_default_repository $qopts" )
alts+=( "cached-repositories:cached repositories:_borg_cached_repositories $qopts" )
alts+=( 'directories: :_directories -r ":/ \t\n\-"' )
alts+=( 'remote-repositories: : _borg_remote_repositories' )
_alternative $alts
}
(( $+functions[__borg_default_repository] )) ||
__borg_default_repository() {
local -a opts suf
zparseopts -E -a opts S:
(( $opts[(I)-S] )) && suf=( -S '' )
local -a default_repository=( "\:\::$BORG_REPO" )
_describe -t default-repository 'default repository' default_repository "$suf[@]"
}
(( $+functions[_borg_cached_repositories] )) ||
_borg_cached_repositories() {
local -a cached_repos
local sed_script='/^previous_location = / {
s///
# no port was given
/ssh:\/\/[^/:]+:[0-9]+/! {
# lstrip the `ssh://` prefix and add a colon before the first slash
s!ssh://([^:/]+)/(.*)!\1:/\2!
}
p
}'
local cachedir=${BORG_CACHE_DIR:-${XDG_CACHE_HOME:-${BORG_BASE_DIR:-$HOME}/.cache}/borg}
cached_repos=( ${(f)"$(_call_program -p cached-repositories sed -n -E ${(q)sed_script} \
"${(q)cachedir}/*/config(#qN.om)" 2>/dev/null)"} )
if [[ $compstate[quote] != (\'|\") ]]; then
# hide ~BORG_REPO and other scalars
local BORG_REPO
unset BORG_REPO sed_script cachedir
cached_repos=( "${(@D)cached_repos}" )
fi
compadd -Q "$@" -r ': \t\n\-' -a cached_repos
}
(( $+functions[_borg_remote_repositories] )) ||
_borg_remote_repositories() {
local -a match mbegin mend expl alts
if compset -P '(#b)ssh://[^/]##@[^/]##:([0-9]##)/'; then
_remote_files -/ -- ssh -p $match[1]
return
fi
local -i have_scheme=0
compset -P 'ssh://' && have_scheme=1
if compset -P '*:'; then
(( have_scheme )) && alts+=( 'ports: : _borg_guard_unsigned_number "port"' )
alts+=( 'remote-files:remote file: _remote_files -/ -- ssh' )
_alternative $alts
elif compset -P 1 '(#b)(*)@'; then
local user=$match[1]
_wanted -C user-at hosts expl "host for $user" \
_combination -s '[:@]' accounts users-hosts users="$user" hosts -S ':' -
elif compset -S '@*'; then
_wanted users expl "user" \
_combination -s '[:@]' accounts users-hosts users -q -
else
alts=(
'users:user:_users -S "@"'
'hosts:host:_hosts -S ":"'
)
(( ! have_scheme )) && alts+=( 'prefixes:ssh:compadd -S "" ssh://' )
_alternative $alts
fi
}
# _borg_repository_or_archive [-a] [-p]
#
# -a archive is mandatory. The suffix `::` will be added to the repository if possible.
# -p complete placeholders
(( $+functions[_borg_repository_or_archive] )) ||
_borg_repository_or_archive() {
local -A opts
zparseopts -A opts -D -E a p
if compset -P 1 '*::'; then
local qrepo=$IPREFIX[1,-3]
local -i def_repo=0
[[ -z $qrepo && -n $BORG_REPO ]] && qrepo=${(q)BORG_REPO} && def_repo=1
if [[ -n $qrepo ]]; then
if (( ! def_repo )); then
case $compstate[quote] in
(\') qrepo=${(qq)qrepo} ;;
(\") qrepo=${(qqq)${(e)qrepo}} ;;
# NOTE: currently `(e)` don't have any effect, but maybe one day zsh will stop to change the quoting method
# of double quoted parameters
esac
fi
if (( $+opts[-p] )); then
_borg_placeholder_or_archive $qrepo
else
_borg_archive $qrepo
fi
else
_message "not a borg repository: ${(Q)qrepo}"
return 1
fi
else
local -a suf
if ! compset -S '::*'; then
if (( $+opts[-a] )) || zstyle -T ":completion:${curcontext}:repositories" repository-suffix; then
suf=( -S '::' )
fi
local oqrepo="$PREFIX$SUFFIX"
local qrepo=$oqrepo
[[ $compstate[quote] != (\'|\") ]] && qrepo=${(Q)qrepo}
if __borg_is_borg_repo $qrepo; then
qrepo=${oqrepo%%/}
[[ -z $SUFFIX ]] && PREFIX=${PREFIX%%/} || SUFFIX=${SUFFIX%%/}
compadd -S '::' -r ':/ \t\n\-' -Q -- $qrepo
return
fi
fi
_borg_repository "$suf[@]"
fi
}
# _borg_archive [-F] [-n] [qrepo]
#
# -F don't apply archive filter options on the command line
# -n reverse order, disable matchers and don't do menu completion/selection
(( $+functions[_borg_archive] )) ||
_borg_archive() {
local -A opts
zparseopts -A opts -D -E F n
local qrepo=$1
if [[ -z $qrepo ]]; then
if [[ -n $BORG_REPO ]]; then
qrepo=${(q)BORG_REPO}
else
_message 'no repository specified'
return 1
fi
fi
local -i ret=1
_tags archives
while _tags; do
if _requested archives; then
local -a expl disp archive_filters
local -i reversed_order=1
if (( ! $+opts[-F] )); then
local -a archive_filter_options=( -P --prefix -a --glob-archives --first --last --sort-by ) tmp
local k
for k in $archive_filter_options; do
if [[ -n $opt_args[$k] ]]; then
IFS=: read -A tmp <<<$opt_args[$k]
archive_filters+=( $k=${^tmp:#} )
fi
done
fi
if (( $+opts[-n] )); then
__borg_skip_pattern_matching || return 1
disp+=( -U )
compstate[insert]=''
compstate[list]='list force'
reversed_order=0
fi
local -a asort
zstyle -a ":completion:${curcontext}:archives" archive-sort asort
if (( $asort[(I)inverse] )); then
(( reversed_order = ! reversed_order ))
fi
local -a sort_by=( --sort-by=${(M)^asort:#(timestamp|name|id)} )
# NOTE: in case of option repetition, the later one takes precedence
if (( ! $+__borg_archives_need_update )); then
comppostfuncs+=( __borg_unset_archives_need_update )
typeset -gHi __borg_archives_need_update=1
if (( ! $#archive_filters && ! $+opts[-n] )); then
local erepo
[[ -n $1 ]] && __borg_expand_path ${(Q)qrepo} erepo
local -a newest_file=( $erepo/(hints|index|integrity).<1->(#qN.om[1]) )
if [[ -n $newest_file ]]; then
if zmodload -F zsh/stat b:zstat 2>/dev/null; then
local -a stats
zstat -A stats +mtime $newest_file
local -i mtime=$stats[1]
if [[ $__borg_prev_repo == $erepo
&& __borg_prev_mtime -ge mtime
&& $__borg_prev_order == $reversed_order
&& $__borg_prev_sort_by == $sort_by ]]
then
__borg_archives_need_update=0
else
typeset -gH __borg_prev_repo=$erepo
typeset -gHi __borg_prev_mtime=mtime __borg_prev_order=reversed_order
typeset -gHa __borg_prev_sort_by=( $sort_by )
fi
fi
fi
else
unset __borg_prev_{repo,mtime,order,sort_by}
comppostfuncs+=( __borg_unset_archives )
fi
fi
if zstyle -t ":completion:${curcontext}:archives" verbose; then
if (( __borg_archives_need_update || ! $+__borg_archive_names || ! $+__borg_archive_descriptions )); then
__borg_archives_need_update=0
typeset -gHa __borg_archive_names=() __borg_archive_descriptions=()
local fmt descfmt name desc
zstyle -s ":completion:${curcontext}:archives" archive-description-format descfmt ||
descfmt='{archive:<36} {time} [{id}]'
fmt="{barchive}{NUL}$descfmt{NUL}"
_call_program -p archive-descriptions \
${(q)__borg_command:-borg} list --format=${(q)fmt} ${(q)sort_by} $archive_filters $qrepo 2>/dev/null |
while IFS= read -r -d $'\0' name && IFS= read -r -d $'\0' descr; do
__borg_archive_names[1,0]=( $name )
__borg_archive_descriptions[1,0]=( "$descr" )
done
(( $pipestatus[1] )) && {
_message "couldn't list repository: ${(Q)qrepo}"
unset __borg_prev_{repo,mtime,order,sort_by}
return 1
}
(( ! reversed_order )) &&
__borg_archive_names=( "${(@aO)__borg_archive_names}" ) &&
__borg_archive_descriptions=( "${(@aO)__borg_archive_descriptions}" )
fi
disp+=( -ld __borg_archive_descriptions )
elif (( __borg_archives_need_update || ! $+__borg_archive_names )); then
__borg_archives_need_update=0
typeset -gHa __borg_archive_names=()
local fmt='{barchive}{NUL}'
__borg_archive_names=( ${(@0aO)"$(_call_program -p archives \
${(q)__borg_command:-borg} list --format=${(q)fmt} ${(q)sort_by} $archive_filters $qrepo 2>/dev/null)"} )
(( $pipestatus[1] )) && {
_message "couldn't list repository: ${(Q)qrepo}"
unset __borg_prev_{repo,mtime,order,sort_by}
return 1
}
(( ! reversed_order )) &&
__borg_archive_names=( "${(@aO)__borg_archive_names}" )
fi
_all_labels archives expl 'ARCHIVE' compadd "$disp[@]" -a __borg_archive_names && ret=0
fi
(( ret )) || return 0
done
return 1
}
(( $+functions[__borg_unset_archives] )) ||
__borg_unset_archives() {
unset __borg_archive_names __borg_archive_descriptions
}
(( $+functions[__borg_unset_archives_need_update] )) ||
__borg_unset_archives_need_update() {
unset __borg_archives_need_update
}
(( $+functions[__borg_is_borg_repo] )) ||
__borg_is_borg_repo() {
local repo=$1
__borg_expand_path $repo repo
if [[ -d $repo && -d $repo/data ]]; then
local -a files=( $repo/(hints|index|integrity).<1->(#qN.) )
(( $#files >= 3 )) && return 0
fi
return 1
}
(( $+functions[__borg_expand_path] )) ||
__borg_expand_path() {
local _path=$1
local -a match mbegin mend
if [[ $_path == (#b)(\~[^/]#)(|/*) ]]; then
local etilde
etilde=$~match[1] 2>/dev/null
_path="$etilde$match[2]"
fi
_path=${(e)_path//\\\\/\\\\\\\\}
eval typeset -g ${2:-REPLY}=\$_path
}
(( $+functions[_borg_placeholder_or_archive] )) ||
_borg_placeholder_or_archive() {
local qrepo=$1
shift
_alternative \
'placeholders: :_borg_placeholders' \
"archives: : _borg_archive ${(q)qrepo}"
}
(( $+functions[_borg_placeholders] )) ||
_borg_placeholders() {
local -a placeholders=(
'hostname:The (short) hostname of the machine.'
'fqdn:The full name of the machine.'
'reverse-fqdn:The full name of the machine in reverse domain name notation.'
'now:The current local date and time, by default in ISO-8601 format. You can also supply your own format string, e.g. {now:%Y-%m-%d_%H:%M:%S}'
'utcnow:The current UTC date and time, by default in ISO-8601 format. You can also supply your own format string, e.g. {utcnow:%Y-%m-%d_%H:%M:%S}'
'user:The user name (or UID, if no name is available) of the user running borg.'
'pid:The current process ID.'
'borgversion:The version of borg, e.g.: 1.0.8rc1'
'borgmajor:The version of borg, only the major version, e.g.: 1'
'borgminor:The version of borg, only major and minor version, e.g.: 1.0'
'borgpatch:The version of borg, only major, minor and patch version, e.g.: 1.0.8'
)
__borg_complete_keys _describe -t placeholders 'placeholder' placeholders '"$copts[@]"'
}
(( $+functions[_borg_format_keys] )) ||
_borg_format_keys() {
local repo_or_arch=${(Q)1}
local -a keys=( NEWLINE NL NUL SPACE TAB CR LF )
local -a repository_keys=( archive name barchive comment bcomment id start time end command_line hostname username )
local -a archive_keys=( type mode uid gid user group path bpath source linktarget flags size csize dsize dcsize
num_chunks unique_chunks mtime ctime atime isomtime isoctime isoatime blake2b blake2s md5 sha1 sha224 sha256 sha384
sha3_224 sha3_256 sha3_384 sha3_512 sha512 shake_128 shake_256 archiveid archivename extra health )
local akeys rkeys
akeys='archive-keys:archive keys:compadd -a archive_keys'
rkeys='repository-keys:repository keys:compadd -a repository_keys'
local -a alts=( 'keys:keys:compadd -a keys' )
if [[ $repo_or_arch == *::?* ]]; then
alts+=( $akeys )
elif [[ -n $repo_or_arch ]]; then
alts+=( $rkeys )
else
alts+=( $rkeys $akeys )
fi
__borg_complete_keys _alternative -O copts ${(q)alts}
}
(( $+functions[__borg_complete_keys] )) ||
__borg_complete_keys() {
compset -P '*[^A-Za-z]##'
compset -S '[^A-Za-z]##*'
[[ -n $ISUFFIX ]] && compstate[to_end]=''
# NOTE: `[[ -n $ISUFFIX ]]` is a workaround for a bug that causes cursor movement to the right further than it should
# NOTE: the _oldlist completer doesn't respect compstate[to_end]=''
local ipref suf
if [[ $IPREFIX[-1] != '{' ]]; then
ipref='{'
[[ $compstate[quote] != (\'|\") ]] && ipref='\{'
fi
if [[ $ISUFFIX[1] != (|\\)\} ]]; then
suf='}'
[[ $compstate[quote] != (\'|\") ]] && suf='\}'
fi
local -a copts=( -i "$ipref" -S "$suf" )
eval "$@"
}
# _borg_style_selector_or_archive_files [-e] [-p] archive default_style_selector
#
# -e apply exclusion options on the command line
# -p complete `--pattern`
# -f complete files rather than borg paths
(( $+functions[_borg_style_selector_or_archive_files] )) ||
_borg_style_selector_or_archive_files() {
local -A opts
zparseopts -A opts -D -E e p f
local arch=$1 default_style_selector=$2
shift 2
local -a match mbegin mend expl tags=( style-selectors archive-files ) ss_suf=( -S ':' -r ':' )
(( $+opts[-f] )) && tags=( style-selectors files )
local -i ret=1
if (( $+opts[-p] )); then
if ! compset -P '(#b)([RP\+\-\!])'; then
local -a pattern_rules=(
'P:pattern style'
'R:root path'
'+:include'
'-:exclude'
'!:exclude non-recurse'
)
_describe -t pattern-rules 'pattern rule' pattern_rules -S ''
return
else
if [[ $compstate[quote] == (\'|\") ]]; then
compset -P ' #'
else
compset -P '(\\ )#'
fi
if [[ $match[1] == 'R' ]]; then
default_style_selector='pp'
elif [[ $match[1] == 'P' ]]; then
tags=( style-selectors )
ss_suf=()
fi
fi
fi
_tags $tags
while _tags; do
if _requested style-selectors; then
_all_labels style-selectors expl 'style selector' \
__borg_style_selectors $default_style_selector "$ss_suf[@]" - && ret=0
fi
if _requested archive-files; then
_all_labels archive-files expl 'PATTERN' \
__borg_archive_files ${(k)opts} "$arch" $default_style_selector - && ret=0
fi
if _requested files; then
local -a borg_paths=( ${(Q)${(e)${~@}}} )
_all_labels files expl 'PATH' \
__borg_pattern_files ${(k)opts} borg_paths - && ret=0
fi
(( ret )) || return 0
done
return 1
}
(( $+functions[__borg_style_selectors] )) ||
__borg_style_selectors() {
local default_style_selector=$1 path_style_selector
shift
zstyle -s ":completion:${curcontext}:archive-files" path-style-selector path_style_selector ||
path_style_selector='fm'
local -a disp
local -A style_selectors
__borg_setup_style_selectors
if zstyle -T ":completion:${curcontext}:style-selectors" verbose; then
local -a style_selector_descriptions extra
local k v sep
for k v in ${(kv)style_selectors}; do
extra=()
[[ $k == $default_style_selector ]] && extra+=( 'default' )
[[ $k == $path_style_selector ]] && __borg_choose_path_or_pattern "" "$default_style_selector" &&
extra+=( 'path' )
(( $#extra )) && v+=" (${(j:, :)extra})"
style_selector_descriptions+=( "${${k//\\/\\\\}//:/\\:}:$v" )
done
zstyle -s ":completion:${curcontext}:style-selectors" list-separator sep || sep=--
zformat -a style_selector_descriptions " $sep " $style_selector_descriptions
disp=( -ld style_selector_descriptions )
fi
compadd "$disp[@]" "$@" -k style_selectors
}
(( $+functions[__borg_archive_files] )) ||
__borg_archive_files() {
local -A opts
zparseopts -A opts -D e p
local arch=$1 default_style_selector=$2
shift 2
if [[ -z $arch || $arch != *::?* ]]; then
_message 'no archive specified'
return 1
fi
local -a qargs tmp disp pref match mbegin mend archive_files descs
local -A style_selectors
local k cword fmt descfmt style_selector path_style_selector name descr
# take into account exclude options on the command line
if (( $+opts[-e] )); then
local -a exclude_options=( -e --exclude --exclude-from --pattern --pattern-from )
local -a excludes
for k in $exclude_options; do
if [[ -n $opt_args[$k] ]]; then
IFS=: read -A tmp <<<$opt_args[$k]
excludes+=( $k="${^tmp[@]}" )
fi
done
[[ -n $excludes ]] && qargs+=( "$excludes[@]" )
fi
(( $_matcher_num > 1 )) && return 1
__borg_skip_pattern_matching || return 1
cword="$PREFIX$SUFFIX"
[[ $compstate[quote] != (\'|\") ]] && cword=${(Q)cword}
[[ -z $cword ]] && return 1
if zstyle -t ":completion:${curcontext}:archive-files" verbose; then
zstyle -s ":completion:${curcontext}:archive-files" file-description-format descfmt ||
descfmt='{mode} {user:6} {group:6} {size:8d} {mtime} {path}{extra}'
fmt="{bpath}{NUL}$descfmt{NUL}"
else
fmt='{bpath}{NUL}'
fi
qargs+=( --format=${(q)fmt} )
qargs+=( $arch )
__borg_setup_style_selectors
[[ $cword == (#b)(${~${(j:|:)${(kb)style_selectors}}}):* ]] && style_selector=$match[1]
local -i path_expected=0
__borg_choose_path_or_pattern "$style_selector" $default_style_selector $cword && path_expected=1
if [[ -n $cword ]]; then
if (( path_expected )); then
[[ -n $style_selector ]] && compset -P "$style_selector:" && pref=( -P "$style_selector:" )
cword="$PREFIX$SUFFIX"
[[ $compstate[quote] != (\'|\") ]] && cword=${(Q)cword}
zstyle -s ":completion:${curcontext}:archive-files" path-style-selector path_style_selector ||
path_style_selector='fm'
cword="$path_style_selector:$cword"
else
[[ -z $style_selector ]] && cword="$default_style_selector:$cword"
fi
qargs+=( ${(q)cword} )
fi
if zstyle -t ":completion:${curcontext}:archive-files" verbose; then
_call_program -p archive-file-descriptions ${(q)__borg_command:-borg} list $qargs 2>/dev/null |
while IFS= read -r -d $'\0' name && IFS= read -r -d $'\0' descr; do
archive_files+=( $name )
descs+=( $descr )
done
(( $pipestatus[1] )) && { _message "couldn't list archive: ${(Q)arch}"; return 1 }
disp=( -ld descs )
else
archive_files=( ${(0)"$(_call_program -p archive-files ${(q)__borg_command:-borg} list $qargs 2>/dev/null)"} )
(( $pipestatus[1] )) && { _message "couldn't list archive: ${(Q)arch}"; return 1 }
fi
if (( $#archive_files )); then
if (( path_expected )); then
compstate[insert]='automenu'
else
compstate[insert]=''
compstate[list]='list force'
fi
fi
compadd "$pref[@]" -U "$disp[@]" "$@" -a archive_files
}
(( $+functions[__borg_choose_path_or_pattern] )) ||
__borg_choose_path_or_pattern() {
local ss=$1 defss=$2 cword=$3
shift 2
[[ $ss == (pp|pf) || ( -z $ss && $defss == (pp|pf) ) ]]
}
# transform borg exclude patterns into zsh ignore patterns and then complete files
(( $+functions[__borg_pattern_files] )) ||
__borg_pattern_files() {
local -A opts
zparseopts -A opts -D -E e p f
local paths_varname=$1
shift
local -a args
local -A style_selectors
__borg_setup_style_selectors
local pr_pat='[RP\+\-\!]' ss_pat="(${(j:|:)${(@kb)style_selectors}}):"
local prs_pat="$pr_pat #"
if (( $+opts[-e] )); then
local -a borg_excludes exclude_options=( -e --exclude --pattern ) tmp
local k cword
local -i i
for k in $exclude_options; do
if [[ -n $opt_args[$k] ]]; then
IFS=: read -A tmp <<<$opt_args[$k]
tmp=( ${(Q)tmp} )
# lstrip style selectors and pattern rules
[[ $+opts[-p] -gt 0 || $k == --pattern ]] && tmp=( ${tmp#$~prs_pat} )
tmp=( ${tmp#$~ss_pat} )
# don't take into account the word under the cursor
cword="$PREFIX$SUFFIX"
[[ $compstate[quote] != (\'|\") ]] && cword=${(Q)cword}
[[ $+opts[-p] -gt 0 || $k == --pattern ]] && cword=${cword#$~prs_pat}
cword=${cword#$~ss_pat}
i=$tmp[(I)$cword]
(( i )) && tmp=( "${(@)tmp[1,i-1]}" "${(@)tmp[i+1,-1]}" )
borg_excludes+=( "$tmp[@]" )
fi
done
[[ -n $borg_excludes ]] && args+=( -F borg_excludes )
fi
[[ -n ${(P)paths_varname} ]] && args+=( -W $paths_varname )
args+=( "$@" )
# lstrip style selectors and pattern rules
if (( $+opts[-p] )); then
if [[ $compstate[quote] != (\'|\") ]]; then
compset -P $pr_pat
compset -P '(\\ )#'
else
compset -P $prs_pat
fi
fi
compset -P $ss_pat
compstate[insert]=''
compstate[list]='list force'
_path_files "$args[@]"
}
(( $+functions[__borg_setup_style_selectors] )) ||
__borg_setup_style_selectors() {
typeset -gA style_selectors=(
fm 'Fnmatch'
sh 'Shell-style patterns'
re 'Regular expressions'
pp 'Path prefix'
pf 'Path full-match'
)
}
(( $+functions[__borg_skip_pattern_matching] )) ||
__borg_skip_pattern_matching() {
# unset glob_complete
[[ $compstate[pattern_match] == '*' ]] && compstate[pattern_match]=''
# skip the _match completer
[[ -n $compstate[pattern_match] ]] && return 1
return 0
}
(( $+functions[_borg_config] )) ||
_borg_config() {
local qrepo=$1
shift
if (( ! $+__borg_config_sect )); then
comppostfuncs+=( __borg_unset_config )
typeset -gH __borg_config_sect=
typeset -gHa __borg_config_keys=()
local sect line
local -a match mbegin mend
_call_program -p keys ${(q)__borg_command:-borg} config --list $qrepo 2>/dev/null | {
IFS= read -r sect
sect=${${sect#\[}%\]}
__borg_config_sect=$sect
while IFS= read -r line && [[ $line == (#b)(*)\ =\ (*) ]]; do
__borg_config_keys+=( "${${match[1]//\\/\\\\}//:/\\:}:(current: $match[2])" )
done
}
fi
local -a alts=( 'keys:key: _describe -t keys "key" __borg_config_keys' )
compset -P "${__borg_config_sect}." || alts+=( 'sections:section:compadd -S "." $__borg_config_sect' )
_alternative $alts
}
(( $+functions[__borg_unset_config] )) ||
__borg_unset_config() {
unset __borg_config_sect __borg_config_keys
}
# A simple prefix-oriented completion function for compressors. Can be improved by supporting the suffix.
(( $+functions[_borg_compression] )) ||
_borg_compression() {
local -a nolvl=(
'none:do not compress'
'lz4:very high speed, very low compression'
)
local -a havelvl=(
'zstd:("zstandard")'
'zlib:("gz") medium speed, medium compression'
'lzma:("xz") low speed, high compression'
)
local -a auto=(
'auto:compress compressible, otherwise "none"'
)
local -a match mbegin mend
# NOTE: Zsh's `-prefix` condition is confused by the leading parenthesis in the pattern.
# Fortunately, we simply need to show a message.
if compset -P '(#b)(|auto,)(zstd|zlib|lzma),'; then
local -i from to def
case $match[2] in
(zstd) from=1 to=22 def=3 ;;
(zlib|lzma) from=0 to=9 def=6 ;;
esac
_message -e "compression level (from $from to $to, default: $def)"
elif compset -P 'auto,'; then
_describe -t compression 'compression' nolvl -- havelvl -qS,
else
_describe -t compression 'compression' nolvl -- havelvl -qS, -- auto -S,
fi
}
(( $+functions[_borg_chunker_params] )) ||
_borg_chunker_params() {
if compset -P 'buzhash,'; then
if compset -P '*,*,*,'; then
_message -e 'HASH_WINDOW_SIZE'
elif compset -P '*,*,'; then
_message -e 'HASH_MASK_BITS (statistical medium chunk size ~= 2^HASH_MASK_BITS B)'
elif compset -P '*,'; then
_message -e 'CHUNK_MAX_EXP (maximum chunk size = 2^CHUNK_MAX_EXP B)'
else
_message -e 'CHUNK_MIN_EXP (minimum chunk size = 2^CHUNK_MIN_EXP B)'
fi
elif compset -P 'fixed,'; then
if compset -P '*,'; then
_message -e 'HEADER_SIZE (B)'
else
_message -e 'BLOCK_SIZE (B)'
fi
else
local -a algorithms=(
'fixed:a simple, low cpu overhead, fixed blocksize chunker, optionally supporting a header block of different size'
'buzhash:variable, content-defined blocksize, uses a rolling hash computed by the Buzhash algorithm'
)
_describe -t algorithm 'ALGO' algorithms -S ,
fi
}
(( $+functions[_borg_chunker_params_examples] )) ||
_borg_chunker_params_examples() {
local -a params=(
'default:buzhash,19,23,21,4095'
'buzhash,19,23,21,4095:small amount of chunks (default)'
'buzhash,10,23,16,4095:big amount of chunks'
)
params=( ${(q)params} )
_alternative \
'chunker-params: :_borg_chunker_params' \
"chunker-params-examples:chunker params examples:(($params))"
}
(( $+functions[_borg_statuschars] )) ||
_borg_statuschars() {
_values -s '' 'STATUSCHARS' \
'A[regular file, added]' \
'M[regular file, modified]' \
'U[regular file, unchanged]' \
'C[regular file, it changed while we backed it up]' \
'E[regular file, an error happened while accessing/reading this file]' \
'd[directory]' \
'b[block device]' \
'c[char device]' \
'h[regular file, hardlink (to already seen inodes)]' \
's[symlink]' \
'f[fifo]' \
'i[backup data was read from standard input (stdin)]' \
'-[dry run, item was not backed up]' \
'x[excluded, item was not backed up]' \
'?[missing status code]'
}
(( $+functions[_borg_quota_suffixes] )) ||
_borg_quota_suffixes() {
if compset -P '[0-9]##'; then
local -a suffixes=(
'K:10 ** 3 bytes'
'M:10 ** 6 bytes'
'G:10 ** 9 bytes'
'T:10 ** 12 bytes'
'P:10 ** 15 bytes'
)
# NOTE: tag `suffixes` is already in use (file extensions)
_describe -t multiplier 'suffix' suffixes
else
_message -e 'QUOTA'
fi
}
(( $+functions[_borg_timestamp] )) ||
_borg_timestamp() {
_alternative \
"dates:TIMESTAMP: _dates -f '%FT%T'" \
'files:reference:_files'
}
(( $+functions[_borg_guard_unsigned_number] )) ||
_borg_guard_unsigned_number() {
local -A opts
zparseopts -K -D -A opts M+: J+: V+: 1 2 o+: n F: x+: X+:
_guard '[0-9]#' ${1:-number}
}
_borg() {
local -a match mbegin mend line state
local curcontext="$curcontext" state_descr
typeset -A opt_args
local -i ret=1
if [[ $service == 'borg' ]]; then
local __borg_command=$words[1]
local -a common_options
__borg_setup_common_options
_arguments -s -w -C : \
'(- :)'{-V,--version}'[show version number and exit]' \
$common_options \
'(-): :->command' \
'(-)*:: :->option-or-argument' && return
case $state in
(command)
_borg_commands && ret=0
;;
(option-or-argument)
curcontext="${curcontext%:*:*}:borg-$words[1]:"
if ! _call_function ret _borg-$words[1]; then
_default && ret=0
fi
;;
esac
elif [[ $service == (#b)-value-,BORG_(*),-default- ]]; then
_borg_parameters $match[1] && ret=0
elif ! _call_function ret _$service; then
_default && ret=0
fi
return ret
}
_borg "$@"