1137 lines
40 KiB
Bash
1137 lines
40 KiB
Bash
#compdef conan
|
|
# ------------------------------------------------------------------------------
|
|
# Copyright (c) 2010-2017 Github zsh-users - https://github.com/zsh-users
|
|
# All rights reserved.
|
|
#
|
|
# Redistribution and use in source and binary forms, with or without
|
|
# modification, are permitted provided that the following conditions are met:
|
|
# * Redistributions of source code must retain the above copyright
|
|
# notice, this list of conditions and the following disclaimer.
|
|
# * Redistributions in binary form must reproduce the above copyright
|
|
# notice, this list of conditions and the following disclaimer in the
|
|
# documentation and/or other materials provided with the distribution.
|
|
# * Neither the name of the zsh-users nor the
|
|
# names of its contributors may be used to endorse or promote products
|
|
# derived from this software without specific prior written permission.
|
|
#
|
|
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
# DISCLAIMED. IN NO EVENT SHALL ZSH-USERS BE LIABLE FOR ANY
|
|
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
# ------------------------------------------------------------------------------
|
|
# Description
|
|
# -----------
|
|
#
|
|
# Completion script for conan 2.0.0 (https://conan.io).
|
|
#
|
|
# ------------------------------------------------------------------------------
|
|
# Authors
|
|
# -------
|
|
#
|
|
# * Julien Nicoulaud <julien.nicoulaud@gmail.com>
|
|
# * Shohei Yoshida <https://github.com/syohex>
|
|
#
|
|
# ------------------------------------------------------------------------------
|
|
|
|
_conan_common_options=(
|
|
'(- *)'{-h,--help}'[show help message and exit]'
|
|
'-v[verbose output]'
|
|
'-vquiet[verbose level quiet]'
|
|
'-verror[verbose level error]'
|
|
'-vwarning[verbose level warning]'
|
|
'-vnotice[verbose level notice]'
|
|
'-vstatus[verbose level status]'
|
|
'-vverbose[verbose level verbose]'
|
|
'-vv[more verbose output]'
|
|
'-vdebug[verbose level debug]'
|
|
'-vvv[more and more verbose output]'
|
|
'-vtrace[verbose level trace]'
|
|
'--out-file[write the output of the command to the specified file instead of stdout]:file:_files'
|
|
\*{-cc,--core-conf}'[define core configuration, overwriting global.conf values]:value'
|
|
)
|
|
|
|
_conan_lockfile_options=(
|
|
'(-l --lockfile)'{-l,--lockfile}'[path to a lockfile]: :_files'
|
|
'--lockfile-partial[do not raise an error if some dependency is not found in lockfile]'
|
|
'--lockfile-out[filename of the updated lockfile]: :_files'
|
|
'--lockfile-clean[remove unused entries from the lockfile]'
|
|
'*--lockfile-overrides[overwrite lockfile overrides]:overrides'
|
|
)
|
|
|
|
_conan_remote_options=(
|
|
'(-r --remote -nr --no-remote)'{-r,--remote}'[look in the specified remote server]:remote'
|
|
'(-r --remote -nr --no-remote)'{-nr,--no-remote}'[do not use remote, resolve exclusively in the cache]'
|
|
\*{-u,--update}'[will install newer versions for the given references]:update'
|
|
)
|
|
|
|
_conan() {
|
|
local context state state_descr line ret=1
|
|
typeset -A opt_args
|
|
|
|
local -a conan_reference_options=(
|
|
'--name[provide a package name if not specified in conanfile]:name'
|
|
'--version[provide a package version if not specified in conanfile]:version'
|
|
'--user[provide a user if not specified in conanfile]:user'
|
|
'--channel[provide a channel if not specified in conanfile]:channel'
|
|
)
|
|
|
|
local -a conan_profile_options=(
|
|
'(-pr --profile)'{-pr,--profile}'[apply the specified profile]:profile'
|
|
'(-pr\:b --profile\:build)'{-pr\\:b,--profile\\:build}'[apply the specified profile build]:profile_build'
|
|
'(-pr\:h --profile\:host)'{-pr\\:h,--profile\\:host}'[apply the specified profile host]:profile_host'
|
|
'(-pr\:a --profile\:all)'{-pr\\:a,--profile\\:apply}'[apply the specified profile all]:profile_all'
|
|
'(-o --options)'{-o,--options}'[apply the specified options]:options'
|
|
'(-o\:b --options\:build)'{-o\\:b,--options\\:build}'[apply the specified options build]:options_build'
|
|
'(-o\:h --options\:host)'{-o\\:h,--options\\:host}'[apply the specified options host]:options_host'
|
|
'(-o\:a --options\:all)'{-o\\:a,--options\\:all}'[apply the specified options all]:options_all'
|
|
'(-s --settings)'{-s,--settings}'[apply the specified settings]:settings'
|
|
'(-s\:b --settings\:build)'{-s\\:b,--settings\\:build}'[apply the specified settings build]:settings_build'
|
|
'(-s\:h --settings\:host)'{-s\\:h,--settings\\:host}'[apply the specified settings host]:settings_host'
|
|
'(-s\:a --settings:all)'{-s\\:a,--settings\\:all}'[apply the specified settings all]:settings_all'
|
|
'(-c --conf)'{-c,--conf}'[apply the specified conf]:conf'
|
|
'(-c\:b --conf\:build)'{-c\\:b,--conf\\:build}'[apply the specified conf build]:conf_build'
|
|
'(-c\:h --conf\:host)'{-c\\:h,--conf\\:host}'[apply the specified conf host]:conf_host'
|
|
'(-c\:a --conf\:all)'{-c\\:a,--conf\\:all}'[apply the specified conf all]:conf_all'
|
|
)
|
|
|
|
_arguments -C \
|
|
'(- : *)'{-h,--help}'[display help information]' \
|
|
'(- : *)'{-v,--version}'[display version information]' \
|
|
'(-h --help)1: :_conan_commands' \
|
|
'(-h --help)*:: :->command_args' \
|
|
&& ret=0
|
|
|
|
case $state in
|
|
command_args)
|
|
if (( $+functions[_conan_${words[1]}] )); then
|
|
_call_function ret _conan_${words[1]} && ret=1
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
return ret
|
|
}
|
|
|
|
(( $+functions[_conan_commands] )) ||
|
|
_conan_commands() {
|
|
local -a commands=(
|
|
# consumer commands
|
|
'cache:perform file operations in the local cache'
|
|
'config:manages conan configuration information'
|
|
'graph:obtain information about the dependency graph without fetching binaries'
|
|
'inspect:inspect a conanfile.py to return its public fields'
|
|
'install:installs the requirements specified in a "conanfile.py" or "conanfile.txt"'
|
|
'list:list recipes, revisions or packages in the cache or the remotes'
|
|
'lock:create or manage lockfiles'
|
|
'pkglist:Several operations over package lists'
|
|
'profile:manage profiles'
|
|
'remote:manage the remote list and the users authenticated on them'
|
|
'remove:remove recipes or packages from local cache or a remote'
|
|
'require:Add/remove requirements to/from your local cananfile'
|
|
'run:run a command given a set of requirements from a recipe or command line'
|
|
'search:search for package recipes in all the remotes or a remote'
|
|
'version:give information about the Conan client version'
|
|
'workspace:manage Conan workspaces'
|
|
|
|
# creator commands
|
|
'build:install dependencies and call the build() method'
|
|
'create:create a package'
|
|
'download:download(without installing) a single conan package from a remote server'
|
|
'editable:allow working with a package that resides in user folder'
|
|
'export:export a recipe to the Conan package cache'
|
|
'export-pkg:create a package directly from pre-compiled binaries'
|
|
'new:create a new example recipe and source files from a template'
|
|
'source:call the source() method'
|
|
'test:test a package from a test_package folder'
|
|
'upload:upload packages to a remote'
|
|
|
|
# security commands
|
|
'audit:find vulnerabilities in your dependencies'
|
|
'report:get information about the recipe and its sources'
|
|
)
|
|
|
|
_describe -t 'subcommands' 'subcommands' commands
|
|
}
|
|
|
|
#
|
|
# consumer commands
|
|
#
|
|
|
|
(( $+functions[_conan_cache] )) ||
|
|
_conan_cache() {
|
|
local curcontext=$curcontext state state_descr line ret=1
|
|
typeset -A opt_args
|
|
|
|
_arguments -C \
|
|
$_conan_common_options[@] \
|
|
'1:subcommand:->subcommand' \
|
|
'*:: :->args' \
|
|
&& ret=0
|
|
|
|
case $state in
|
|
(subcommand)
|
|
local -a commands=(
|
|
'backup-upload:upload all the source backups present in the cache'
|
|
'check-integrity:check the integrity of the local cache for the given references'
|
|
'clean:remove non-critical folders from the cache'
|
|
'path:show the path to the Conan cache for a given reference'
|
|
'ref:show the reference for a given Conan cache folder'
|
|
'restore:put the artifacts from an archive into the cache'
|
|
'save:get the artifacts from a package list and archive them'
|
|
'sign:sign packages with the Package Signing Plugin'
|
|
'verify:check the signature of packages with the Package Signing Plugin'
|
|
)
|
|
_describe -t 'commands' "command" commands && ret=0
|
|
;;
|
|
(args)
|
|
local -a opts=($_conan_common_options[@])
|
|
case $words[1] in
|
|
(check-integrity|sign|verify)
|
|
opts+=(
|
|
'(-f --format)'{-f,--format}'[select the output format]:format:(json)'
|
|
'(-l --list)'{-l,--list}'[package list of packages to check integrity for]:list'
|
|
\*{-p,--package-query}'[only the packages matching a specific query]:query'
|
|
'1:pattern'
|
|
)
|
|
;;
|
|
(clean)
|
|
opts+=(
|
|
'(-l --list)'{-l,--list}'[package list of packages to clean]:list'
|
|
'(-s --source)'{-s,--source}'[clean source folders]'
|
|
'(-b --build)'{-b,--build}'[clean build folders]'
|
|
'(-d --download)'{-d,--download}'[clean download folders]'
|
|
'(-t --temp)'{-t,--temp}'[clean temporary folders]'
|
|
'(-bs --backup-sources)'{-bs,--backup-sources}'[clean backup sources]'
|
|
\*{-p,--package-query}'[remove only the packages matching a specific query]:query'
|
|
'1:pattern'
|
|
)
|
|
;;
|
|
(path)
|
|
opts+=(
|
|
'--folder[path to show]::type:(export_source source build metadata)' \
|
|
'1:recipe_or_package_reference:_files'
|
|
)
|
|
;;
|
|
(ref)
|
|
opts+=(
|
|
'1:folder:_files -/'
|
|
)
|
|
;;
|
|
(restore)
|
|
opts+=(
|
|
'1:path:_files'
|
|
)
|
|
;;
|
|
(save)
|
|
opts+=(
|
|
'(-f --format)'{-f,--format}'[select the output format]:format:(json)'
|
|
'(-l --list)'{-l,--list}'[package list of packages to check integrity for]:list'
|
|
'--file[save to this file]:file:_files -g "*.(tgz|txz|tzst)"'
|
|
'--no-source[exclude the sources]'
|
|
'1:pattern'
|
|
)
|
|
;;
|
|
esac
|
|
|
|
_arguments "$opts[@]" && ret=0
|
|
;;
|
|
esac
|
|
|
|
return ret
|
|
}
|
|
|
|
(( $+functions[_conan_config] )) ||
|
|
_conan_config() {
|
|
local curcontext=$curcontext state state_descr line ret=1
|
|
typeset -A opt_args
|
|
|
|
_arguments -C \
|
|
'(- : *)'{-h,--help}'[display help information]' \
|
|
'1: :->subcommand' \
|
|
'*:: :->args' \
|
|
&& ret=0
|
|
|
|
case $state in
|
|
(subcommand)
|
|
local -a commands=(
|
|
'clean:clean the configuration files in the Conan home folder'
|
|
'home:show the Conan home folder'
|
|
'install:install the configuration into the Conan home folder'
|
|
'install-pkg:install the configuration from a Conan package or a conanconfig.yml file'
|
|
'list:show all the Conan available configurations, core and tools'
|
|
'show:get the value of the specified conf'
|
|
)
|
|
_describe -t 'commands' "command" commands && ret=0
|
|
;;
|
|
(args)
|
|
local -a opts=($_conan_common_options[@])
|
|
case $words[1] in
|
|
(install)
|
|
opts+=(
|
|
'--verify-ssl[Verify SSL connection when downloading file]: :(True False)'
|
|
'(-t --type)'{-t,--type}'[Type of remote config]: :(git dir file url)'
|
|
\*{-a,--args}'[String with extra arguments for "git clone"]:arg'
|
|
\*{-sf,--source-folder}'[Install files only from a source subfolder from specified origin]: :_files -/'
|
|
'(-tf --target-folder)'{-tf,--target-folder}'[Install to that path in the conan cache]: :_files -/'
|
|
)
|
|
;;
|
|
(install-pkg)
|
|
opts++(
|
|
'(-l --lockfile)'{-l,--lockfile}'[path to a lockfile]:file:_files'
|
|
'--lockfile-partial[do not raise an error if some dependency is not found in lockfile]'
|
|
'--lockfile-out[file name of the updated lockfile]:file:_files'
|
|
'(-f --force)'{-f,--force}'[force the re-installation of configuration]'
|
|
'--insecure[allow insecure server connections when using SSL]'
|
|
'--url[provide Conan repository URL]:url'
|
|
'(-pr --profile)'{-pr,--profile}'[profile to install config]:profile'
|
|
'(-s --settings)'{-s,--settings}'[settings to install config]:settings'
|
|
'(-o --options)'{-o,--options}'[options to install config]:options'
|
|
)
|
|
;;
|
|
(list|show)
|
|
opts+=(
|
|
'(-f --format)'{-f,--format}'[select the output format]:format:(json)'
|
|
)
|
|
;;
|
|
esac
|
|
|
|
_arguments "$opts[@]" && ret=0
|
|
;;
|
|
esac
|
|
|
|
return ret
|
|
}
|
|
|
|
(( $+functions[_conan_graph] )) ||
|
|
_conan_graph() {
|
|
local curcontext=$curcontext state state_descr line ret=1
|
|
typeset -A opt_args
|
|
|
|
_arguments -C \
|
|
'1:subcommand:->subcommand' \
|
|
'*:: :->args' \
|
|
&& ret=0
|
|
|
|
case $state in
|
|
(subcommand)
|
|
local -a commands=(
|
|
'build-order:compute the build order of a dependency graph'
|
|
'build-order-merge:merge more than 1 build-order file'
|
|
'explain:explan what is wrong with the dependency graph'
|
|
'info:compute the dependency graph and shows information about it'
|
|
'outdated:list the dependencies in the graph and it is newer versions in the remote'
|
|
)
|
|
_describe -t 'commands' "command" commands && ret=0
|
|
;;
|
|
(args)
|
|
local -a opts=($_conan_common_options[@])
|
|
case $words[1] in
|
|
(build-order|explain|info|outdated)
|
|
opts+=(
|
|
\*{-b,--build}'[optional, specify which packages to build from source]:build'
|
|
'--requires[directly provide requires instead of a conanfile]:requires'
|
|
'--tool-requires[directly provide tool-requires instead of a conanfile]:tool-requires'
|
|
$_conan_remote_options[@]
|
|
$conan_profile_options[@]
|
|
$conan_reference_options[@]
|
|
$_conan_lockfile_options[@]
|
|
'*:folder:_files -/'
|
|
)
|
|
;|
|
|
(explain|info|outdated)
|
|
opts+=(
|
|
'--check-updates[check if there are recipe updates]'
|
|
'--build-require[whether the provided reference is a build-require]'
|
|
)
|
|
;;
|
|
(build-order)
|
|
opts+=(
|
|
'--order-by[select how to order the output(default "recipe")]:type:(recipe configuration)'
|
|
'--reduce[reduce the build order, output only those to build]'
|
|
)
|
|
;;
|
|
(explain)
|
|
opts+=(
|
|
'*--missing[a pattern in the form "pkg/version#revision:package_id#revision"]:pattern'
|
|
)
|
|
;;
|
|
(info)
|
|
opts+=(
|
|
'*--filter[show only the specified fields]:pattern'
|
|
'*--package-filter[print information only for packages that match the patterns]:pattern'
|
|
'(-d --deployer)'{-d,--deployer}'[deploy using the provided deployer to the output folder]:deployer:(full_deploy direct_deploy)'
|
|
'(-df --deployer-folder)'{-df,--deployer-folder}'[deployer output folder]:folder:_files -/'
|
|
)
|
|
;;
|
|
(build-order-merge)
|
|
opts+=(
|
|
'(-f --format)'{-f,--format}'[select the output format]:format:(json html)'
|
|
'*--file[files to be merged]:file:_files'
|
|
'--reduce[reduce the build order, output only those to build]'
|
|
)
|
|
;;
|
|
esac
|
|
|
|
_arguments "$opts[@]" && ret=0
|
|
;;
|
|
esac
|
|
|
|
return ret
|
|
}
|
|
|
|
(( $+functions[_conan_inspect] )) ||
|
|
_conan_inspect() {
|
|
local ret=1
|
|
|
|
_arguments \
|
|
$_conan_common_options[@] \
|
|
'(-f --format)'{-f,--format}'[select the output format]:format:(json)' \
|
|
'(-r --remote -nr --no-remote)'{-r,--remote}'[remote names. Accepts wildcards("*")]:remote' \
|
|
'(-r --remote -nr --no-remote)'{-nr,--no-remote}'[do not use remote]' \
|
|
'(-l --lockfile)'{-l,--lockfile}'[path to a lockfile]:path:_files' \
|
|
'--lockfile-partial[do not raise an error if some dependnecy is not found in lockfile]' \
|
|
'*:recipe_folder:_files -/' \
|
|
&& ret=0
|
|
|
|
return ret
|
|
}
|
|
|
|
(( $+functions[_conan_install] )) ||
|
|
_conan_install() {
|
|
local -a generators=(
|
|
cmake cmake_multi cmake_paths cmake_find_package cmake_find_package_multi
|
|
msbuild visual_studio visual_studio_multi visual_studio_legacy xcode compiler_args gcc
|
|
boost-build b2 qbs qmake scons pkg_config virtualenv virtualenv_python virtualbuildenv
|
|
virtualrunenv youcompleteme txt json premake make markdown deploy
|
|
)
|
|
local -a opts=(
|
|
$_conan_common_options[@]
|
|
'(-f --format)'{-f,--format}'[select the output format]:format:(json)'
|
|
\*{-b,--build}'[optional, specify which packages to build from source]:build'
|
|
$_conan_remote_options[@]
|
|
'(-u --update)'{-u,--update}'[will check the remote and in case a newer version]'
|
|
$conan_profile_options[@]
|
|
$_conan_lockfile_options[@]
|
|
'(-g --generator)'{-g,--generator}"[generators to use]:generator:($generators)"
|
|
'(-of --output)'{-of,--output-folder}'[the root output folder for generated and build files]:dir:_files -/'
|
|
'--deploy[deploy using the provided deployer to the output folder]:deployer'
|
|
'1:recipe_dir_or_conanfile:_files'
|
|
)
|
|
|
|
_arguments "$opts[@]"
|
|
}
|
|
|
|
(( $+functions[_conan_list] )) ||
|
|
_conan_list() {
|
|
local ret=1
|
|
local -a opts=(
|
|
$_conan_common_options[@]
|
|
'(-f --format)'{-f,--format}'[select the output format]:format:(json html compact)'
|
|
\*{-p,--package-query}'[remove only the packages matching a specific query]:query'
|
|
\*{-fp,--filter-profile}'[profiles to filter the binaries]:filter_profile'
|
|
\*{-fs,--filter-settings}'[settings to filter the binaries]:filter_settings'
|
|
\*{-fo,--filter-options}'[options to filter the binaries]:filter_options'
|
|
'(-r --remote)'{-r,--remote}'[remote names]:remote'
|
|
'(-c --cache)'{-c,--cache}'[search in the local cache]'
|
|
'(-g --graph)'{-g,--graph}'[graph json file]:file:_files'
|
|
'(-gb --graph-binaries)'{-gb,--graph-binaries}'[which binaries are listed]:graph_binaries'
|
|
'(-gr --graph-recipes)'{-gr,--graph-recipes}'[which recipes are listed]:graph_recipes'
|
|
'(-gc --graph-context)'{-gc,--graph-context}'[filter the results by the given context]:context:(build host build-only host-only)'
|
|
'--lru[list recipes and binaries that have not been recently used]:lru'
|
|
'1:recipe_or_package_reference:_files'
|
|
)
|
|
|
|
_arguments "$opts[@]" && ret=0
|
|
return ret
|
|
}
|
|
|
|
(( $+functions[_conan_lock] )) ||
|
|
_conan_lock() {
|
|
local curcontext=$curcontext state state_descr line ret=1
|
|
typeset -A opt_args
|
|
|
|
_arguments -C \
|
|
'(- : *)'{-h,--help}'[display help information]' \
|
|
'1:subcommand:->subcommand' \
|
|
'*:: :->args'
|
|
|
|
case $state in
|
|
(subcommand)
|
|
local -a commands=(
|
|
'add:add requires, build-requires or python requires to an existing or new lockfile'
|
|
'create:create a lockfile from a conanfile or a reference'
|
|
'merge:merge 2 or more lockfiles'
|
|
'remove:remove requires, build-requires or python-requires from an existing lockfile'
|
|
'update:update requires'
|
|
'upgrade:upgrade requires, build-requires or python-requires from an exiting lockfile'
|
|
'upgrade-config:upgrade config requires in a lockfile'
|
|
)
|
|
_describe -t 'commands' "command" commands && ret=0
|
|
;;
|
|
(args)
|
|
local -a opts=($_conan_common_options)
|
|
case $words[1] in
|
|
(add)
|
|
opts+=(
|
|
'*--requires[add references to lockfile]:requires'
|
|
'*--build-requires[add build-requires to lockfile]:build_requires'
|
|
'*--python-requires[add python-requires to lockfile]'
|
|
'--lockfile-out[file name of the created lockfile]:filename:_files'
|
|
'--lockfile[file name of the input lockfile]:filename:_files'
|
|
)
|
|
;;
|
|
(create)
|
|
opts+=(
|
|
\*{-b,--build}'[optional, specify which packages to build from source]:build'
|
|
'--requires[directly provide requires instead of a conanfile]:requires'
|
|
'--tool-requires[directly provide tool-requires instead of a conanfile]:tool-requires'
|
|
'--build-require[whether the provided reference is a build-require]'
|
|
$_conan_remote_options[@]
|
|
$conan_profile_options[@]
|
|
$conan_reference_options[@]
|
|
$_conan_lockfile_options[@]
|
|
'1: :_files'
|
|
)
|
|
;;
|
|
(merge)
|
|
opts+=(
|
|
'--lockfile[file name of the input lockfile]:filename:_files'
|
|
'--lockfile-out[file name of the created lockfile]:filename:_files'
|
|
)
|
|
;;
|
|
(remove)
|
|
opts+=(
|
|
'*--build-requires[remove build-requires from lockfile]:build_requires'
|
|
'*--python-requires[remove python-requires from lockfile]'
|
|
'*--config-requires[remove config-requires from lockfile]'
|
|
'--lockfile-out[file name of the created lockfile]:filename:_files'
|
|
'--lockfile[file name of the input lockfile]:filename:_files'
|
|
)
|
|
;;
|
|
(update)
|
|
opts+=(
|
|
'*--requires[update references to lockfile]:requires'
|
|
'*--build-requires[update build-requires from lockfile]:build_requires'
|
|
'*--python-requires[update python-requires from lockfile]'
|
|
'*--config-requires[update config-requires from lockfile]'
|
|
'--lockfile-out[file name of the created lockfile]:filename:_files'
|
|
'--lockfile[file name of the input lockfile]:filename:_files'
|
|
)
|
|
;;
|
|
(upgrade)
|
|
opts+=(
|
|
'--requires[directly provide requires instead of a conanfile]:requires'
|
|
'--tool-requires[directly provide tool-requires instead of a conanfile]:tool-requires'
|
|
\*{-ur,--update-requires}'[update requires from lockfile]:update_requires'
|
|
\*{-ubr,--update-build-requires}'[update build-requires from lockfile]:update_build_requires'
|
|
\*{-upr,--update-python-requires}'[update python-requires from lockfile]:update_python_requires'
|
|
'*--build-requires[update build-requires from lockfile]:build_requires'
|
|
$_conan_remote_options[@]
|
|
$conan_profile_options[@]
|
|
$conan_reference_options[@]
|
|
$_conan_lockfile_options[@]
|
|
)
|
|
;;
|
|
(upgrade-config)
|
|
opts+=(
|
|
'--requires[directly provide requires instead of a conanfile]:requires'
|
|
'--tool-requires[directly provide tool-requires instead of a conanfile]:tool-requires'
|
|
'*--update-config-requires[update config-requires from lockfile]:update_config_requires'
|
|
$_conan_remote_options[@]
|
|
$conan_profile_options[@]
|
|
$conan_reference_options[@]
|
|
$_conan_lockfile_options[@]
|
|
)
|
|
;;
|
|
esac
|
|
|
|
_arguments "$opts[@]" && ret=1
|
|
;;
|
|
esac
|
|
|
|
return ret
|
|
}
|
|
|
|
(( $+functions[_conan_profile] )) ||
|
|
_conan_profile() {
|
|
_arguments -C \
|
|
'(- : *)'{-h,--help}'[display help information]' \
|
|
'1: :_conan_profile_commands' \
|
|
'*:: :->args'
|
|
|
|
case $state in
|
|
(args)
|
|
local opts=($_conan_common_options[@])
|
|
case $words[1] in
|
|
(detect)
|
|
opts+=(
|
|
'--name[profile name, "default" if not specified]::name'
|
|
'(-f --force)'{-f,--force}'[overwrite if exists]'
|
|
)
|
|
;;
|
|
(list)
|
|
opts+=(
|
|
'(-f --format)'{-f,--format}'[select the output format]:format:(json)'
|
|
)
|
|
;;
|
|
(path|show)
|
|
opts+=(
|
|
$conan_profile_options[@]
|
|
)
|
|
;;
|
|
esac
|
|
|
|
_arguments "$opts[@]"
|
|
;;
|
|
esac
|
|
}
|
|
|
|
(( $+functions[_conan_profile_commands] )) ||
|
|
_conan_profile_commands() {
|
|
local -a commands=(
|
|
'detect:generate a profile using auto-detected values'
|
|
'list:list all profiles in the cache'
|
|
'path:show profile path location'
|
|
'show:show aggregated profiles from the passed arguments'
|
|
)
|
|
_describe -t 'commands' "command" commands
|
|
}
|
|
|
|
(( $+functions[_conan_remote] )) ||
|
|
_conan_remote() {
|
|
_arguments -C \
|
|
'(- : *)'{-h,--help}'[display help information]' \
|
|
'1: :_conan_remote_commands' \
|
|
'*:: :->args'
|
|
|
|
case $state in
|
|
(args)
|
|
local -a opts=($_conan_common_options[@])
|
|
case $words[1] in
|
|
(add)
|
|
opts+=(
|
|
'--insecure[allow insecure server connections when using SSL]'
|
|
'--index[insert the remote at a specific position in the remote list]:index'
|
|
'(-f --force)'{-f,--force}'[force the definition of the remote even if duplicated]'
|
|
'1:name'
|
|
'2:url'
|
|
)
|
|
;;
|
|
(auth)
|
|
opts+=(
|
|
'--with-user[only try to auth in those remotes that already have a user name]'
|
|
'1:remote:_conan_remotes'
|
|
)
|
|
;;
|
|
(list|list-users)
|
|
opts+=('(-f --format)'{-f,--format}'[select the output format]:format:(json)')
|
|
;;
|
|
(login)
|
|
opts+=(
|
|
'(-f --format)'{-f,--format}'[select the output format]:format:(json)'
|
|
'(-p --password)'{-p,--password}'[user password]:password'
|
|
'1:remote:_conan_remotes'
|
|
'2:username:'
|
|
)
|
|
;;
|
|
(logout)
|
|
opts+=(
|
|
'(-f --format)'{-f,--format}'[select the output format]:format:(json)'
|
|
'1:remote:_conan_remotes'
|
|
)
|
|
;;
|
|
(remove)
|
|
opts+=('1:remote:_conan_remotes')
|
|
;;
|
|
(rename)
|
|
opts+=(
|
|
'1:remote:_conan_remotes'
|
|
'2:new_name'
|
|
)
|
|
;;
|
|
(set-user)
|
|
opts+=(
|
|
'(-f --format)'{-f,--format}'[select the output format]:format:(json)'
|
|
'1:remote:_conan_remotes'
|
|
'2:user_name'
|
|
)
|
|
;;
|
|
(update)
|
|
opts+=(
|
|
'--url[new url for the remote]'
|
|
'--secure[do not allow insecure server connections when using SSL]'
|
|
'--insecure[allow insecure server connections when using SSL]'
|
|
'--index[insert the remote at a specific position in the remote list]:index'
|
|
'1:remote:_conan_remotes'
|
|
)
|
|
;;
|
|
esac
|
|
|
|
_arguments "${opts[@]}"
|
|
;;
|
|
esac
|
|
}
|
|
|
|
(( $+functions[_conan_remote_commands] )) ||
|
|
_conan_remote_commands() {
|
|
local -a commands=(
|
|
'add:add a remote'
|
|
'auth:authenticate in the defined remotes'
|
|
'disable:disable all the remotes matching a pattern'
|
|
'enable:enable all the remotes matching a pattern'
|
|
'list:list current remotes'
|
|
'list-users:list the users logged into all the remotes'
|
|
'login:login into the specified remotes matching a pattern'
|
|
'logout:clear the existing credentials for the specified remotes matching a pattern'
|
|
'remove:remove a remote'
|
|
'rename:rename a remote'
|
|
'set-user:associate a username with a remote matching pattern without performing the authentication'
|
|
'update:update a remote'
|
|
)
|
|
_describe -t 'commands' "command" commands
|
|
}
|
|
|
|
(( $+functions[_conan_remove] )) ||
|
|
_conan_remove() {
|
|
local -a opts=(
|
|
$_conan_common_options[@]
|
|
'(-c --confirm)'{-c,--confirm}'[remove without requesting a confirmation]'
|
|
\*{-p,--package-query}'[remove only the packages matching a specific query]:query'
|
|
\*{-r,--remote}'[will remove from the specified remote]:remote'
|
|
'*:recipe_or_package_reference:_files'
|
|
)
|
|
|
|
_arguments "$opts[@]"
|
|
}
|
|
|
|
(( $+functions[_conan_search] )) ||
|
|
_conan_search() {
|
|
local -a opts=(
|
|
$_conan_common_options[@]
|
|
\*{-r,--remote}'[will remove from the specified remote]:remote'
|
|
'*:recipe_reference:_files'
|
|
)
|
|
|
|
_arguments "$opts[@]"
|
|
}
|
|
|
|
(( $+functions[_conan_version] )) ||
|
|
_conan_version() {
|
|
local ret=1
|
|
_arguments \
|
|
$_conan_common_options[@] \
|
|
'(-f --format)'{-f,--format}'[select the output format]:format:(json)' \
|
|
&& ret=0
|
|
|
|
return ret
|
|
}
|
|
|
|
#
|
|
# creator commands
|
|
#
|
|
|
|
(( $+functions[_conan_build] )) ||
|
|
_conan_build() {
|
|
local ret=1
|
|
|
|
local -a opts=(
|
|
$_conan_common_options[@]
|
|
\*{-g,--generator}'[generators to use]:generator'
|
|
'(-of --output-folder)'{-of,--output-folder}'[root output folder for generated and build files]:folder:_files -/'
|
|
'(-d --deployer)'{-d,--deployer}'[deploy using the provided deployer to the output folder]:deployer:(full_deploy direct_deploy)'
|
|
'(-df --deployer-folder)'{-df,--deployer-folder}'[deployer output folder]:folder:_files -/'
|
|
'--build-require[whether the provided reference is a build-require]'
|
|
'--envs-generation[generation strategy for virtual environment files for the root]:flag:(false)'
|
|
\*{-b,--build}'[optional, specify which packages to build from source]:build'
|
|
$conan_reference_options[@]
|
|
$_conan_remote_options[@]
|
|
$conan_profile_options[@]
|
|
$_conan_lockfile_options[@]
|
|
'*: :_files'
|
|
)
|
|
|
|
_arguments "$opts[@]" && ret=0
|
|
return ret
|
|
}
|
|
|
|
(( $+functions[_conan_create] )) ||
|
|
_conan_create() {
|
|
local ret=1
|
|
local -a opts=(
|
|
$_conan_common_options[@]
|
|
\*{-b,--build}'[optional, specify which packages to build from source]:build'
|
|
'(-u --update)'{-u,--update}'[will check the remote and in case a newer version]'
|
|
'--build-require[whether the provided reference is a build-require]'
|
|
'(-tf --test-folder)'{-tf,--test-folder}'[alternative test folder name]:folder:_files -/'
|
|
$conan_reference_options[@]
|
|
$_conan_lockfile_options[@]
|
|
$_conan_remote_options[@]
|
|
$conan_profile_options[@]
|
|
'*: :_files -/'
|
|
)
|
|
|
|
_arguments "$opts[@]" && ret=0
|
|
return ret
|
|
}
|
|
|
|
(( $+functions[_conan_download] )) ||
|
|
_conan_download() {
|
|
local ret=1
|
|
local -a opts=(
|
|
$_conan_common_options[@]
|
|
'--only-recipe[download only the recipe, not the binary packages]'
|
|
\*{-p,--package-query}'[only download packages matching a specific query]:query'
|
|
'(-r --remote)'{-r,--remote}'[download from the specific remote]:remote:_conan_remotes'
|
|
'(-m --metadata)'{-m,--metadata}'[download the metadata matching the pattern]:pattern'
|
|
'(-l --list)'{-l,--list}'[package list file]:list:_files'
|
|
'*:recipe_or_package_reference:_files'
|
|
)
|
|
|
|
_arguments "$opts[@]" && ret=0
|
|
return ret
|
|
}
|
|
|
|
(( $+functions[_conan_editable] )) ||
|
|
_conan_editable() {
|
|
local curcontext=$curcontext state state_descr line ret=1
|
|
typeset -A opt_args
|
|
|
|
_arguments -C \
|
|
$_conan_common_options[@] \
|
|
'1:subcommand:->subcommand' \
|
|
'*:: :->args' \
|
|
&& ret=0
|
|
|
|
case $state in
|
|
(subcommand)
|
|
local -a commands=(
|
|
'add:define the given path location as the package reference'
|
|
'list:list all the packages in editable mode'
|
|
'remove:remove the editable mode for this reference'
|
|
)
|
|
_describe -t 'commands' "command" commands && ret=0
|
|
;;
|
|
(args)
|
|
local opts=($_conan_common_options[@])
|
|
case $words[1] in
|
|
(add)
|
|
opts+=(
|
|
'(-of --output-folder)'{-of,--output-folder}'[the root output folder]:folder:_files -/'
|
|
'(-r --remote -nr --no-remote)'{-r,--remote}'[look in the specified remote server]:remote'
|
|
'(-r --remote -nr --no-remote)'{-nr,--no-remote}'[do not use remote]'
|
|
$conan_reference_options[@]
|
|
'*:folder:_files -/'
|
|
)
|
|
;;
|
|
(list)
|
|
opts+=('(-f --format)'{-f,--format}'[select the output format]:format:(json)')
|
|
;;
|
|
(remove)
|
|
opts+=(
|
|
'(-r --refs)'{-r,--refs}'[directly provide reference patterns]:refs'
|
|
'*:folder:_files -/'
|
|
)
|
|
;;
|
|
esac
|
|
|
|
_arguments "$opts[@]" && ret=0
|
|
;;
|
|
esac
|
|
|
|
return ret
|
|
}
|
|
|
|
(( $+functions[_conan_export] )) ||
|
|
_conan_export() {
|
|
local -a opts=(
|
|
$_conan_common_options[@]
|
|
'(-r --remote -nr --no-remote)'{-r,--remote}'[remote names. Accepts wildcards("*")]:remote'
|
|
'(-r --remote -nr --no-remote)'{-nr,--no-remote}'[do not use remote]'
|
|
'(-l --lockfile)'{-l,--lockfile}'[path to a lockfile]:file:_files'
|
|
'--lockfile-out[file name of the updated lockfile]:file:_files'
|
|
'--lockfile-partial[do not raise an error if some dependency is not found in lockfile]'
|
|
'--build-require[whether the provided reference is a build-require]'
|
|
$conan_reference_options[@]
|
|
'*: :_files -/'
|
|
)
|
|
|
|
_arguments "$opts[@]"
|
|
}
|
|
|
|
(( $+functions[_conan_export-pkg] )) ||
|
|
_conan_export-pkg() {
|
|
local ret=1
|
|
local -a opts=(
|
|
$_conan_common_options[@]
|
|
'(-of --output-folder)'{-of,--output-folder}'[root output folder for generated and build files]:folder:_files -/'
|
|
'--build-require[whether the provided reference is a build-require]'
|
|
'(-tf --test-folder)'{-tf,--test-folder}'[alternative test folder name]:folder:_files -/'
|
|
'(-sb --skip-binaries)'{-sb,--skip-binaries}'[skip installing dependencies binaries]'
|
|
'(-r --remote -nr --no-remote)'{-r,--remote}'[look in the specified remote or remote servers]:remote'
|
|
'(-r --remote -nr --no-remote)'{-nr,--no-remote}'[do not use remote]'
|
|
$conan_reference_options[@]
|
|
$_conan_lockfile_options[@]
|
|
$conan_profile_options[@]
|
|
'*: :_files -/'
|
|
)
|
|
|
|
_arguments "$opts[@]" && ret=0
|
|
return ret
|
|
}
|
|
|
|
(( $+functions[_conan_require] )) ||
|
|
_conan_require() {
|
|
local context state state_descr line ret=1
|
|
typeset -A opt_args
|
|
|
|
_arguments -C \
|
|
$_conan_common_options[@] \
|
|
'1: :->subcommand' \
|
|
'*:: :->args' \
|
|
&& ret=1
|
|
|
|
case $state in
|
|
(subcommand)
|
|
local -a commands=(
|
|
'add:add a new requirement to your local conanfile as a version range'
|
|
'remove:removes a requirement from your local conanfile'
|
|
)
|
|
_describe -t 'commands' "command" commands && ret=0
|
|
;;
|
|
(args)
|
|
local -a common_options=(
|
|
'--folder[path to a folder containing a recipe(conanfile.py)]:folder:_files -/'
|
|
'(-tor --tool)'{-tor,--tool}'[tool requirement name]:name'
|
|
'(-ter --test)'{-ter,--test}'[test requirement name]:name'
|
|
)
|
|
|
|
case $words[1] in
|
|
(add)
|
|
_arguments \
|
|
$_conan_common_options[@] \
|
|
$common_options[@] \
|
|
'(-r --remote -nr --no-remote)'{-r,--remote}'[remote names. Accepts wildcards("*")]:remote' \
|
|
'(-r --remote -nr --no-remote)'{-nr,--no-remote}'[do not use remote]' \
|
|
'*::requires' \
|
|
&& ret=0
|
|
;;
|
|
(remove)
|
|
_arguments \
|
|
$_conan_common_options[@] \
|
|
$common_options[@] \
|
|
'*::name' \
|
|
&& ret=0
|
|
;;
|
|
esac
|
|
;;
|
|
esac
|
|
|
|
return ret
|
|
}
|
|
|
|
(( $+functions[_conan_new] )) ||
|
|
_conan_new() {
|
|
local ret=1
|
|
local -a templates=(
|
|
basic cmake_lib cmake_exe header_lib meson_lib meson_exe msbuild_lib msbuild_exe
|
|
bezel_lib bezel_exe autotools_lib autotools_exe premake_lib premake_exe
|
|
local_recipes_index workspace
|
|
)
|
|
local -a opts=(
|
|
$_conan_common_options[@]
|
|
\*{-d,--define}'[define a template argument as key=value]:key_value'
|
|
'(-f --force)'{-f,--force}'[overwrite file if it already exists]'
|
|
'(-o --output)'{-o,--output}'[output folder for the generated files]:folder:_files -/'
|
|
'1:template:($templates)'
|
|
)
|
|
|
|
_arguments "$opts[@]" && ret=0
|
|
return ret
|
|
}
|
|
|
|
(( $+functions[_conan_source] )) ||
|
|
_conan_source() {
|
|
local -a opts=(
|
|
$_conan_common_options[@]
|
|
$conan_reference_options[@]
|
|
'1: :_files'
|
|
)
|
|
|
|
_arguments "$opts[@]"
|
|
}
|
|
|
|
(( $+functions[_conan_test] )) ||
|
|
_conan_test() {
|
|
local -a opts=(
|
|
$_conan_common_options[@]
|
|
\*{-b,--build}'[optional, specify which packages to build from source]:build'
|
|
$_conan_remote_options[@]
|
|
'(-u --update)'{-u,--update}'[will check the remote and in case a newer version]'
|
|
$conan_profile_options[@]
|
|
$_conan_lockfile_options[@]
|
|
'1:path:_files -/'
|
|
'2:reference'
|
|
)
|
|
|
|
_arguments "$opts[@]"
|
|
}
|
|
|
|
(( $+functions[_conan_upload] )) ||
|
|
_conan_upload() {
|
|
local -a opts=(
|
|
$_conan_common_options[@]
|
|
\*{-p,--package-query}'[only upload packages matching a specific query]:query'
|
|
'(-r --remote)'{-r,--remote}'[upload to this specific remote]:remote:_conan_remotes'
|
|
'--only-recipe[upload only the recipe, not the binary packages]'
|
|
'--force[force the upload of the artifacts]'
|
|
'--check[perform an integrity check before upload]'
|
|
'(-c --confirm)'{-c,--confirm}'[upload all matching recipes without confirmation]'
|
|
'--dry-run[do not execute the real upload]'
|
|
'--allow-disabled[allow uploading to disabled remote]'
|
|
'(-l --list)'{-l,--list}'[package list file]:list:_files'
|
|
'(-m --metadata)'{-m,--metadata}'[upload the metadata]:metadata:_files'
|
|
'1::reference'
|
|
)
|
|
|
|
_arguments "$opts[@]"
|
|
}
|
|
|
|
#
|
|
# security commands
|
|
#
|
|
|
|
(( $+functions[_conan_audit] )) ||
|
|
_conan_audit() {
|
|
local curcontext=$curcontext state state_descr line ret=1
|
|
typeset -A opt_args
|
|
|
|
_arguments -C \
|
|
$_conan_common_options[@] \
|
|
'1: :->subcommand' \
|
|
'*:: :->args' \
|
|
&& ret=1
|
|
|
|
case $state in
|
|
(subcommand)
|
|
local -a commands=(
|
|
'list:list the vulnerabilities of the given reference'
|
|
'provider:manage security providers for the "conan audit" command'
|
|
'scan:scan a given recipe for vulnerabilities in its dependencies'
|
|
)
|
|
_describe -t 'commands' "command" commands && ret=0
|
|
;;
|
|
(args)
|
|
case $words[1] in
|
|
(list)
|
|
_arguments \
|
|
$_conan_common_options[@] \
|
|
'(-f --format)'{-f,--format}'[select the output format]:format:(json html)' \
|
|
'(-l --list)'{-l,--list}'[package list file to list vulnerabilities for]:list:_files' \
|
|
'(-s --sbom)'{-s,--sbom}'[SBOM file to list vulnerabilities for]:sbom:_files' \
|
|
'(-l --lockfile)'{-l,--lockfile}'[path to the lockfile to check for vulnerabilities]:file:_files' \
|
|
'(-r --remote)'{-r,--remote}'[remote to use for listing]:remote' \
|
|
'(-p --provider)'{-p,--provider}'[provider to use for scanning]:provider' \
|
|
'*::reference' \
|
|
&& ret=0
|
|
;;
|
|
(provider)
|
|
_arguments \
|
|
$_conan_common_options[@] \
|
|
'(-f --format)'{-f,--format}'[select the output format]:format:(json html)' \
|
|
'--url[provider URL]:url' \
|
|
'--type[provider type]:type:(conan-center-proxy private)' \
|
|
'--token[provider token]:token' \
|
|
'1:action:(add list auth remove)' \
|
|
'*::name' \
|
|
&& ret=0
|
|
;;
|
|
(scan)
|
|
_arguments \
|
|
$_conan_common_options[@] \
|
|
\*{-b,--build}'[specify which packages to build from source]:build:(never missing cascade)' \
|
|
'--requires[directly provide requires instead of a conanfile]:requires' \
|
|
'--tool-requires[directly provide tool-requires instead of a conanfile]:tool-requires' \
|
|
'(-sl --severity-level)'{-sl,--severity-level}'[set threshold for severity level to raise an error]:level' \
|
|
'--context[context to scan]:context:(host build)' \
|
|
'(-p --provider)'{-p,--provider}'[provider to use for scanning]' \
|
|
$_conan_remote_options[@] \
|
|
$conan_profile_options[@] \
|
|
$conan_reference_options[@] \
|
|
$_conan_lockfile_options[@] \
|
|
&& ret=0
|
|
;;
|
|
esac
|
|
;;
|
|
esac
|
|
|
|
return ret
|
|
}
|
|
|
|
(( $+functions[_conan_report] )) ||
|
|
_conan_report() {
|
|
local curcontext=$curcontext state state_descr line ret=1
|
|
typeset -A opt_args
|
|
|
|
_arguments -C \
|
|
$_conan_common_options[@] \
|
|
'1: :->subcommand' \
|
|
'*:: :->args' \
|
|
&& ret=1
|
|
|
|
case $state in
|
|
(subcommand)
|
|
local -a commands=(
|
|
'diff:get the difference between two recipes with their sources'
|
|
)
|
|
_describe -t 'commands' "command" commands && ret=0
|
|
;;
|
|
(args)
|
|
case $words[1] in
|
|
(diff)
|
|
_arguments \
|
|
$_conan_common_options[@] \
|
|
'(-op --old-path)'{-op,--old-path}'[path to the old recipe]:path:_files' \
|
|
'(-or --old-reference)'{-or,--old-reference}'[old reference]:reference' \
|
|
'(-np --new-path)'{-np,--new-path}'[path to the new recipe]:path:_files' \
|
|
'(-nr --new-reference)'{-nr,--new-reference}'[new reference]:reference' \
|
|
'(-r --remote)'{-r,--remote}'[look in the specified remote or remotes server]:remote' \
|
|
&& ret=0
|
|
;;
|
|
esac
|
|
;;
|
|
esac
|
|
|
|
return ret
|
|
}
|
|
|
|
#
|
|
# Utilities
|
|
#
|
|
(( $+functions[_conan_remotes] )) ||
|
|
_conan_remotes() {
|
|
local -a remotes=(${(f)"$(_call_program remotes $service remote list)"})
|
|
_describe -t remotes 'remote' remotes "$@"
|
|
}
|
|
|
|
(( $+functions[_conan_profiles] )) ||
|
|
_conan_profiles() {
|
|
local -a profiles=(${(f)"$(_call_program profiles $service profile list 2>/dev/null)"})
|
|
_describe -t profiles 'profile' profiles "$@"
|
|
}
|
|
|
|
_conan "$@"
|
|
|
|
# Local Variables:
|
|
# mode: Shell-Script
|
|
# sh-indentation: 2
|
|
# indent-tabs-mode: nil
|
|
# sh-basic-offset: 2
|
|
# End:
|
|
# vim: ft=zsh sw=2 ts=2 et
|