241 lines
12 KiB
Plaintext
241 lines
12 KiB
Plaintext
zmodule() {
|
|
local -r ztarget=${ZIM_CONFIG_FILE:-<%= home %>/.zimrc}
|
|
local -r zusage=$'Usage: <%= bold %>'${0}$'<%= normal %> <url> [<%= bold %>-n<%= normal %>|<%= bold %>--name<%= normal %> <module_name>] [<%= bold %>-r<%= normal %>|<%= bold %>--root<%= normal %> <path>] [options]
|
|
|
|
Add <%= bold %>zmodule<%= normal %> calls to your <%= bold %>'${ztarget}$'<%= normal %> file to define the modules to be initialized.
|
|
The initialization will be done in the same order it\'s defined.
|
|
|
|
<url> Module absolute path or repository URL. The following URL formats
|
|
are equivalent: <%= bold %>foo<%= normal %>, <%= bold %>zimfw/foo<%= normal %>, <%= bold %>https://github.com/zimfw/foo.git<%= normal %>.
|
|
If an absolute path is given, the module is considered externally
|
|
installed and won\'t be installed or updated by zimfw.
|
|
<%= bold %>-n<%= normal %>|<%= bold %>--name<%= normal %> <module_name> Set a custom module name. Default: the last component in <url>.
|
|
Slashes can be used inside the name to organize the module into
|
|
subdirectories. The module will be installed at
|
|
<%= bold %>'${ZIM_HOME}$'/<%= normal %><module_name>.
|
|
<%= bold %>-r<%= normal %>|<%= bold %>--root<%= normal %> <path> Relative path to the module root.
|
|
|
|
Per-module options:
|
|
<%= bold %>-b<%= normal %>|<%= bold %>--branch<%= normal %> <branch_name> Use specified branch when installing and updating the module.
|
|
Overrides the tag option. Default: the repository default branch.
|
|
<%= bold %>-t<%= normal %>|<%= bold %>--tag<%= normal %> <tag_name> Use specified tag when installing and updating the module. Over-
|
|
rides the branch option.
|
|
<%= bold %>-u<%= normal %>|<%= bold %>--use<%= normal %> <tool_name> Install and update the module using the defined tool. Default is
|
|
either defined by <%= bold %>zstyle \':zim:zmodule\' use \'<%= normal %><tool_name><%= bold %>\'<%= normal %>, or <%= bold %>git<%= normal %>
|
|
if none is provided. The tools available are:
|
|
<%= bold %>git<%= normal %> uses the git command. Local changes are preserved on updates.
|
|
<%= bold %>degit<%= normal %> uses curl or wget, and currently only works with GitHub
|
|
URLs. Modules install faster and take less disk space. Local
|
|
changes are lost on updates. Git submodules are not supported.
|
|
<%= bold %>mkdir<%= normal %> creates an empty directory. The <url> is only used to set
|
|
the module name. Use the <%= bold %>-c<%= normal %>|<%= bold %>--cmd<%= normal %> or <%= bold %>--on-pull<%= normal %> options to execute
|
|
the desired command to generate the module files.
|
|
<%= bold %>--no-submodules<%= normal %> Don\'t install or update git submodules.
|
|
<%= bold %>-z<%= normal %>|<%= bold %>--frozen<%= normal %> Don\'t install or update the module.
|
|
|
|
The per-module options above are carried over multiple zmodule calls for the same module.
|
|
Modules are uniquely identified by their name.
|
|
|
|
Per-module-root options:
|
|
<%= bold %>--if<%= normal %> <test> Will only initialize module root if specified test returns a zero
|
|
exit status. The test is evaluated at every new terminal startup.
|
|
<%= bold %>--if-command<%= normal %> <cmd_name> Will only initialize module root if specified external command is
|
|
available. This is evaluated at every new terminal startup.
|
|
Equivalent to <%= bold %>--if \'(( \${+commands[<%= normal %><cmd_name><%= bold %>]} ))\'<%= normal %>.
|
|
<%= bold %>--on-pull<%= normal %> <command> Execute command after installing or updating the module. The com-
|
|
mand is executed in the module root directory.
|
|
<%= bold %>-d<%= normal %>|<%= bold %>--disabled<%= normal %> Don\'t initialize the module root or uninstall the module.
|
|
|
|
The per-module-root options above are carried over multiple zmodule calls for the same mod-
|
|
ule root.
|
|
|
|
Per-call initialization options:
|
|
<%= bold %>-f<%= normal %>|<%= bold %>--fpath<%= normal %> <path> Will add specified path to fpath. The path is relative to the
|
|
module root directory. Default: <%= bold %>functions<%= normal %>, if the subdirectory
|
|
exists and is non-empty.
|
|
<%= bold %>-a<%= normal %>|<%= bold %>--autoload<%= normal %> <func_name> Will autoload specified function. Default: all valid names inside
|
|
the <%= bold %>functions<%= normal %> subdirectory, if any.
|
|
<%= bold %>-s<%= normal %>|<%= bold %>--source<%= normal %> <file_path> Will source specified file. The path is relative to the module
|
|
root directory. Default: <%= bold %>init.zsh<%= normal %>, if a non-empty <%= bold %>functions<%= normal %> sub-
|
|
directory exists, else the largest of the files matching the glob
|
|
<%= bold %>(init.zsh|<%= normal %><name><%= bold %>.(zsh|plugin.zsh|zsh-theme|sh))<%= normal %>, if any.
|
|
<name> in the glob is resolved to the last component of the mod-
|
|
ule name, or the last component of the path to the module root.
|
|
<%= bold %>-c<%= normal %>|<%= bold %>--cmd<%= normal %> <command> Will execute specified command. Occurrences of the <%= bold %>{}<%= normal %> placeholder
|
|
in the command are substituted by the module root directory path.
|
|
I.e., <%= bold %>-s \'foo.zsh\'<%= normal %> and <%= bold %>-c \'source {}/foo.zsh\'<%= normal %> are equivalent.
|
|
|
|
Setting any per-call initialization option above will disable the default values from the
|
|
other per-call initialization options, so only your provided values will be used. I.e. these
|
|
values are either all automatic, or all manual in each zmodule call. To use default values
|
|
and also provided values, use separate zmodule calls.'
|
|
if [[ ${${funcfiletrace[1]%:*}:A} != ${ztarget:A} ]]; then
|
|
print -u2 -lR $'<%= red %>'${0}$': Must be called from <%= bold %>'${ztarget}$'<%= normal %>' '' ${zusage}
|
|
return 2
|
|
fi
|
|
if (( ! # )); then
|
|
print -u2 -lR $'<%= red %><%= error %>'${funcfiletrace[1]}$': Missing zmodule url<%= normal %>' '' ${zusage}
|
|
_zfailed=1
|
|
return 2
|
|
fi
|
|
local zurl=${1} zname=${1:t} zroot zarg
|
|
local -a zfpaths zfunctions zcmds
|
|
if [[ ${zurl} =~ ^[^:/]+: ]]; then
|
|
zname=${zname%.git}
|
|
elif [[ ${zurl} != /* ]]; then
|
|
# Count number of slashes
|
|
case ${#zurl//[^\/]/} in
|
|
0) zurl=https://github.com/zimfw/${zurl}.git ;;
|
|
1) zurl=https://github.com/${zurl}.git ;;
|
|
esac
|
|
fi
|
|
shift
|
|
while [[ ${1} == (-n|--name|-r|--root) ]]; do
|
|
if (( # < 2 )); then
|
|
print -u2 -lR $'<%= red %><%= error %>'${funcfiletrace[1]}$':<%= bold %>'${zname}$':<%= normalred %> Missing argument for zmodule option <%= bold %>'${1}$'<%= normal %>' '' ${zusage}
|
|
_zfailed=1
|
|
return 2
|
|
fi
|
|
case ${1} in
|
|
-n|--name)
|
|
shift
|
|
zname=${${1%%/##}##/##}
|
|
;;
|
|
-r|--root)
|
|
shift
|
|
zroot=${${1%%/##}##/##}
|
|
;;
|
|
esac
|
|
shift
|
|
done
|
|
if [[ ${zurl} == /* ]]; then
|
|
_zdirs[${zname}]=${zurl%%/##}
|
|
zurl=
|
|
else
|
|
_zdirs[${zname}]=${ZIM_HOME}/modules/${zname}
|
|
fi
|
|
if [[ ${+_zurls[${zname}]} -ne 0 && ${_zurls[${zname}]} != ${zurl} ]]; then
|
|
print -u2 -lR $'<%= red %><%= error %>'${funcfiletrace[1]}$':<%= bold %>'${zname}$':<%= normalred %> Module already defined with a different URL. Expected <%= bold %>'${_zurls[${zname}]}$'<%= normal %>' '' ${zusage}
|
|
_zfailed=1
|
|
return 2
|
|
fi
|
|
_zurls[${zname}]=${zurl}
|
|
local -r zroot_dir=${_zdirs[${zname}]}${zroot:+/${zroot}}
|
|
_zroot_dirs+=(${zroot_dir})
|
|
# Set default values
|
|
if (( ! ${+_ztools[${zname}]} )); then
|
|
zstyle -s ':zim:zmodule' use "_ztools[${zname}]" || _ztools[${zname}]=git
|
|
fi
|
|
if (( ! ${+_ztypes[${zname}]} )) _ztypes[${zname}]=branch
|
|
if (( ! ${+_zsubmodules[${zname}]} )) _zsubmodules[${zname}]=1
|
|
# Set values from options
|
|
while (( # > 0 )); do
|
|
case ${1} in
|
|
-b|--branch|-t|--tag|-u|--use|--on-pull|--if|--if-command|-f|--fpath|-a|--autoload|-s|--source|-c|--cmd)
|
|
if (( # < 2 )); then
|
|
print -u2 -lR $'<%= red %><%= error %>'${funcfiletrace[1]}$':<%= bold %>'${zname}$':<%= normalred %> Missing argument for zmodule option <%= bold %>'${1}$'<%= normal %>' '' ${zusage}
|
|
_zfailed=1
|
|
return 2
|
|
fi
|
|
;;
|
|
esac
|
|
case ${1} in
|
|
-b|--branch|-t|--tag|-u|--use|--no-submodules)
|
|
if [[ -z ${zurl} ]] _zimfw_print -u2 -R $'<%= yellow %><%= warn %>'${funcfiletrace[1]}$':<%= bold %>'${zname}$':<%= normalyellow %> The zmodule option <%= bold %>'${1}$'<%= normalyellow %> has no effect for external modules<%= normal %>'
|
|
;;
|
|
esac
|
|
case ${1} in
|
|
-b|--branch)
|
|
shift
|
|
_ztypes[${zname}]=branch
|
|
_zrevs[${zname}]=${1}
|
|
;;
|
|
-t|--tag)
|
|
shift
|
|
_ztypes[${zname}]=tag
|
|
_zrevs[${zname}]=${1}
|
|
;;
|
|
-u|--use)
|
|
shift
|
|
_ztools[${zname}]=${1}
|
|
;;
|
|
--no-submodules) _zsubmodules[${zname}]=0 ;;
|
|
-z|--frozen) _zfrozens[${zname}]=1 ;;
|
|
--on-pull)
|
|
shift
|
|
zarg=${1}
|
|
if [[ -n ${zroot} ]] zarg="(builtin cd -q ${zroot}; ${zarg})"
|
|
_zonpulls[${zname}]="${_zonpulls[${zname}]+${_zonpulls[${zname}]}; }${zarg}"
|
|
;;
|
|
--if)
|
|
shift
|
|
_zifs[${zroot_dir}]=${1}
|
|
;;
|
|
--if-command)
|
|
shift
|
|
_zifs[${zroot_dir}]="(( \${+commands[${1}]} ))"
|
|
;;
|
|
-f|--fpath)
|
|
shift
|
|
zarg=${1}
|
|
if [[ ${zarg} != /* ]] zarg=${zroot_dir}/${zarg}
|
|
zfpaths+=(${zarg})
|
|
;;
|
|
-a|--autoload)
|
|
shift
|
|
zfunctions+=(${1})
|
|
;;
|
|
-s|--source)
|
|
shift
|
|
zarg=${1}
|
|
if [[ ${zarg} != /* ]] zarg=${zroot_dir}/${zarg}
|
|
zcmds+=("source ${(q-)zarg:a}")
|
|
;;
|
|
-c|--cmd)
|
|
shift
|
|
zcmds+=(${1//{}/${(q-)zroot_dir:a}})
|
|
;;
|
|
-d|--disabled) _zdisabled_root_dirs+=(${zroot_dir}) ;;
|
|
*)
|
|
print -u2 -lR $'<%= red %><%= error %>'${funcfiletrace[1]}$':<%= bold %>'${zname}$':<%= normalred %> Unknown zmodule option <%= bold %>'${1}$'<%= normal %>' '' ${zusage}
|
|
_zfailed=1
|
|
return 2
|
|
;;
|
|
esac
|
|
shift
|
|
done
|
|
if (( _zflags & 1 )); then
|
|
_znames+=(${zname})
|
|
fi
|
|
if (( _zflags & 2 )); then
|
|
if [[ ! -e ${zroot_dir} ]]; then
|
|
print -u2 -R $'<%= red %><%= error %>'${funcfiletrace[1]}$':<%= bold %>'${zname}': '${zroot_dir}$'<%= normalred %> not found<%= normal %>'
|
|
_zfailed=1
|
|
return 1
|
|
fi
|
|
if (( ! ${#zfpaths} && ! ${#zfunctions} && ! ${#zcmds} )); then
|
|
zfpaths=(${zroot_dir}/functions(NF))
|
|
# _* functions are autoloaded by compinit
|
|
# prompt_*_setup functions are autoloaded by promptinit
|
|
zfunctions=(${^zfpaths}/^(*~|*.zwc(|.old)|_*|prompt_*_setup)(N-.:t))
|
|
local -ra prezto_scripts=(${zroot_dir}/init.zsh(N))
|
|
if (( ${#zfpaths} && ${#prezto_scripts} )); then
|
|
# this follows the prezto module format, no need to check for other scripts
|
|
zcmds=('source '${(q-)^prezto_scripts:a})
|
|
else
|
|
# get script with largest size (descending `O`rder by `L`ength, and return only `[1]` first)
|
|
local -ra zscripts=(${zroot_dir}/(init.zsh|(${zname:t}|${zroot_dir:t}).(zsh|plugin.zsh|zsh-theme|sh))(NOL[1]))
|
|
zcmds=('source '${(q-)^zscripts:a})
|
|
fi
|
|
fi
|
|
if (( ! ${#zfpaths} && ! ${#zfunctions} && ! ${#zcmds} )); then
|
|
_zimfw_print -u2 -lR $'<%= yellow %><%= warn %>'${funcfiletrace[1]}$':<%= bold %>'${zname}$':<%= normalyellow %> Nothing found to be initialized. Customize the module name, root or initialization with <%= bold %>zmodule<%= normalyellow %> options.<%= normal %>' '' ${zusage}
|
|
fi
|
|
# Prefix is added to all _zfpaths, _zfunctions and _zcmds to distinguish the originating root dir
|
|
local -r zpre=${zroot_dir}$'\0'
|
|
_zfpaths+=(${zpre}${^zfpaths})
|
|
_zfunctions+=(${zpre}${^zfunctions})
|
|
_zcmds+=(${zpre}${^zcmds})
|
|
fi
|
|
}
|