aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--.zim/.latest_version1
-rw-r--r--.zim/init.zsh17
-rw-r--r--.zim/init.zsh.old16
-rw-r--r--.zim/login_init.zsh1
-rw-r--r--.zim/login_init.zsh.old1
m---------.zim/modules/asciiship0
m---------.zim/modules/completion0
m---------.zim/modules/duration-info0
m---------.zim/modules/environment0
m---------.zim/modules/git0
m---------.zim/modules/git-info0
m---------.zim/modules/input0
m---------.zim/modules/oblong0
m---------.zim/modules/prompt-pwd0
m---------.zim/modules/termtitle0
m---------.zim/modules/utility0
m---------.zim/modules/zsh-autosuggestions0
m---------.zim/modules/zsh-completions0
m---------.zim/modules/zsh-history-substring-search0
m---------.zim/modules/zsh-syntax-highlighting0
-rw-r--r--.zim/zimfw.zsh1222
-rw-r--r--.zimrc56
22 files changed, 1314 insertions, 0 deletions
diff --git a/.zim/.latest_version b/.zim/.latest_version
new file mode 100644
index 0000000..3989355
--- /dev/null
+++ b/.zim/.latest_version
@@ -0,0 +1 @@
+1.20.0
diff --git a/.zim/init.zsh b/.zim/init.zsh
new file mode 100644
index 0000000..7cb35e5
--- /dev/null
+++ b/.zim/init.zsh
@@ -0,0 +1,17 @@
+# FILE AUTOMATICALLY GENERATED FROM /home/dacc/.zimrc
+# EDIT THE SOURCE FILE AND THEN RUN zimfw build. DO NOT DIRECTLY EDIT THIS FILE!
+
+if [[ -e ${ZIM_CONFIG_FILE:-${ZDOTDIR:-${HOME}}/.zimrc} ]] zimfw() { source "${HOME}/.zim/zimfw.zsh" "${@}" }
+fpath=("${HOME}/.zim/modules/git/functions" "${HOME}/.zim/modules/utility/functions" "${HOME}/.zim/modules/duration-info/functions" "${HOME}/.zim/modules/git-info/functions" "${HOME}/.zim/modules/prompt-pwd/functions" "${HOME}/.zim/modules/zsh-completions/src" "${HOME}/.zim/modules/completion/functions" ${fpath})
+autoload -Uz -- git-alias-lookup git-branch-current git-branch-delete-interactive git-branch-remote-tracking git-dir git-ignore-add git-root git-stash-clear-interactive git-stash-recover git-submodule-move git-submodule-remove mkcd mkpw duration-info-precmd duration-info-preexec coalesce git-action git-info prompt-pwd
+source "${HOME}/.zim/modules/environment/init.zsh"
+source "${HOME}/.zim/modules/git/init.zsh"
+source "${HOME}/.zim/modules/input/init.zsh"
+source "${HOME}/.zim/modules/termtitle/init.zsh"
+source "${HOME}/.zim/modules/utility/init.zsh"
+source "${HOME}/.zim/modules/duration-info/init.zsh"
+source "${HOME}/.zim/modules/oblong/oblong.zsh-theme"
+source "${HOME}/.zim/modules/completion/init.zsh"
+source "${HOME}/.zim/modules/zsh-syntax-highlighting/zsh-syntax-highlighting.zsh"
+source "${HOME}/.zim/modules/zsh-history-substring-search/zsh-history-substring-search.zsh"
+source "${HOME}/.zim/modules/zsh-autosuggestions/zsh-autosuggestions.zsh"
diff --git a/.zim/init.zsh.old b/.zim/init.zsh.old
new file mode 100644
index 0000000..cc33b0a
--- /dev/null
+++ b/.zim/init.zsh.old
@@ -0,0 +1,16 @@
+# FILE AUTOMATICALLY GENERATED FROM /home/dacc/.zimrc
+# EDIT THE SOURCE FILE AND THEN RUN zimfw build. DO NOT DIRECTLY EDIT THIS FILE!
+
+if [[ -e ${ZIM_CONFIG_FILE:-${ZDOTDIR:-${HOME}}/.zimrc} ]] zimfw() { source "${HOME}/.zim/zimfw.zsh" "${@}" }
+fpath=("${HOME}/.zim/modules/git/functions" "${HOME}/.zim/modules/utility/functions" "${HOME}/.zim/modules/duration-info/functions" "${HOME}/.zim/modules/git-info/functions" "${HOME}/.zim/modules/prompt-pwd/functions" "${HOME}/.zim/modules/zsh-completions/src" "${HOME}/.zim/modules/completion/functions" ${fpath})
+autoload -Uz -- git-alias-lookup git-branch-current git-branch-delete-interactive git-branch-remote-tracking git-dir git-ignore-add git-root git-stash-clear-interactive git-stash-recover git-submodule-move git-submodule-remove mkcd mkpw duration-info-precmd duration-info-preexec coalesce git-action git-info prompt-pwd
+source "${HOME}/.zim/modules/environment/init.zsh"
+source "${HOME}/.zim/modules/git/init.zsh"
+source "${HOME}/.zim/modules/input/init.zsh"
+source "${HOME}/.zim/modules/termtitle/init.zsh"
+source "${HOME}/.zim/modules/utility/init.zsh"
+source "${HOME}/.zim/modules/duration-info/init.zsh"
+source "${HOME}/.zim/modules/completion/init.zsh"
+source "${HOME}/.zim/modules/zsh-syntax-highlighting/zsh-syntax-highlighting.zsh"
+source "${HOME}/.zim/modules/zsh-history-substring-search/zsh-history-substring-search.zsh"
+source "${HOME}/.zim/modules/zsh-autosuggestions/zsh-autosuggestions.zsh"
diff --git a/.zim/login_init.zsh b/.zim/login_init.zsh
new file mode 100644
index 0000000..0cf3b1b
--- /dev/null
+++ b/.zim/login_init.zsh
@@ -0,0 +1 @@
+# Do nothing. This file is deprecated.
diff --git a/.zim/login_init.zsh.old b/.zim/login_init.zsh.old
new file mode 100644
index 0000000..0cf3b1b
--- /dev/null
+++ b/.zim/login_init.zsh.old
@@ -0,0 +1 @@
+# Do nothing. This file is deprecated.
diff --git a/.zim/modules/asciiship b/.zim/modules/asciiship
new file mode 160000
+Subproject c600119d5e0e386085dd039e33d767448ed427b
diff --git a/.zim/modules/completion b/.zim/modules/completion
new file mode 160000
+Subproject 8d3e0f4e6272f4d3bad659eaa13929f9dd96f12
diff --git a/.zim/modules/duration-info b/.zim/modules/duration-info
new file mode 160000
+Subproject c887236aa21e2b070e128d2182c9576972697ba
diff --git a/.zim/modules/environment b/.zim/modules/environment
new file mode 160000
+Subproject d4bceaa3da89cd819843334dba1a5bf7dc137e1
diff --git a/.zim/modules/git b/.zim/modules/git
new file mode 160000
+Subproject fff448c0b89a4885f4ace90e2f37893a078b0c8
diff --git a/.zim/modules/git-info b/.zim/modules/git-info
new file mode 160000
+Subproject 7146812f56185fc0ac614def3cfb71b6e7bbacb
diff --git a/.zim/modules/input b/.zim/modules/input
new file mode 160000
+Subproject 0f7efb3f659e1d68743a6c2c06c962ba9e05ae6
diff --git a/.zim/modules/oblong b/.zim/modules/oblong
new file mode 160000
+Subproject 947e0b370a9b505af07b6bb9ad0d83000d48402
diff --git a/.zim/modules/prompt-pwd b/.zim/modules/prompt-pwd
new file mode 160000
+Subproject ce102a9e74a569563e8b3a514572baf1f45974d
diff --git a/.zim/modules/termtitle b/.zim/modules/termtitle
new file mode 160000
+Subproject b0de7783181804d21cc73fbb109fb89e8b02132
diff --git a/.zim/modules/utility b/.zim/modules/utility
new file mode 160000
+Subproject e1d1c23f578420e285cbea41dbd5cef75b35ca5
diff --git a/.zim/modules/zsh-autosuggestions b/.zim/modules/zsh-autosuggestions
new file mode 160000
+Subproject 85919cd1ffa7d2d5412f6d3fe437ebdbeeec4fc
diff --git a/.zim/modules/zsh-completions b/.zim/modules/zsh-completions
new file mode 160000
+Subproject d4d30592c2e5e81c052ce4fec29a8a1ea23383f
diff --git a/.zim/modules/zsh-history-substring-search b/.zim/modules/zsh-history-substring-search
new file mode 160000
+Subproject 14c8d2e0ffaee98f2df9850b19944f32546fdea
diff --git a/.zim/modules/zsh-syntax-highlighting b/.zim/modules/zsh-syntax-highlighting
new file mode 160000
+Subproject 1d85c692615a25fe2293bdd44b34c217d5d2bf0
diff --git a/.zim/zimfw.zsh b/.zim/zimfw.zsh
new file mode 100644
index 0000000..76d18c9
--- /dev/null
+++ b/.zim/zimfw.zsh
@@ -0,0 +1,1222 @@
+# AUTOMATICALLY GENERATED FILE. EDIT ONLY THE SOURCE FILES AND THEN COMPILE.
+# DO NOT DIRECTLY EDIT THIS FILE!
+
+# MIT License
+#
+# Copyright (c) 2015-2016 Matt Hamilton and contributors
+# Copyright (c) 2016-2025 Eric Nielsen, Matt Hamilton and contributors
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+autoload -Uz is-at-least && if ! is-at-least 5.2; then
+ print -u2 -R "${_zred}${0}: Error starting zimfw. You're using Zsh version ${_zbold}${ZSH_VERSION}${_znormalred} and versions < ${_zbold}5.2${_znormalred} are not supported. Update your Zsh.${_znormal}"
+ return 1
+fi
+
+# Define zimfw location
+typeset -g __ZIMFW_FILE=${0:a}
+
+_zimfw_print() {
+ if (( _zprintlevel > 0 )) print "${@}"
+}
+
+_zimfw_mv() {
+ local -a cklines
+ if cklines=(${(f)"$(command cksum ${1} ${2} 2>/dev/null)"}) && \
+ [[ ${${(z)cklines[1]}[1,2]} == ${${(z)cklines[2]}[1,2]} ]]; then
+ _zimfw_print -R "${_zokay}${_zbold}${2}:${_znormal} Already up to date"
+ else
+ if [[ -e ${2} ]]; then
+ command mv -f ${2}{,.old} || return 1
+ fi
+ command mv -f ${1} ${2} && command chmod a+r ${2} && _zimfw_print -R "${_zokay}${_zbold}${2}:${_znormal} Updated"
+ fi
+}
+
+_zimfw_build_init() {
+ local -r ztarget=${ZIM_HOME}/init.zsh
+ # Force update of init.zsh if it's older than .zimrc
+ if [[ ${ztarget} -ot ${_zconfig} ]]; then
+ command mv -f ${ztarget}{,.old} || return 1
+ fi
+ _zimfw_mv =(
+ print -R '# FILE AUTOMATICALLY GENERATED FROM '${_zconfig}
+ print '# EDIT THE SOURCE FILE AND THEN RUN zimfw build. DO NOT DIRECTLY EDIT THIS FILE!'
+ print
+ print -R 'if [[ -e ${ZIM_CONFIG_FILE:-${ZDOTDIR:-${HOME}}/.zimrc} ]] zimfw() { source '${${(qqq)__ZIMFW_FILE}/${HOME}/\${HOME}}' "${@}" }'
+ local zroot_dir zpre
+ local -a zif_functions zif_cmds zroot_functions zroot_cmds
+ local -a zfunctions=(${_zfunctions}) zcmds=(${_zcmds})
+ # Keep fpath constant regardless of "if" root dirs, to avoid confusing compinit.
+ # Move all from zfunctions and zcmds with "if" root dirs prefixes.
+ for zroot_dir in ${_zroot_dirs}; do
+ if (( ${+_zifs[${zroot_dir}]} )); then
+ zpre=${zroot_dir}$'\0'
+ zif_functions+=(${(M)zfunctions:#${zpre}*})
+ zif_cmds+=(${(M)zcmds:#${zpre}*})
+ zfunctions=(${zfunctions:#${zpre}*})
+ zcmds=(${zcmds:#${zpre}*})
+ fi
+ done
+ zpre=$'*\0'
+ if (( ${#_zfpaths} )) print -R 'fpath=('${_zfpaths#${~zpre}}' ${fpath})'
+ if (( ${#zfunctions} )) print -R 'autoload -Uz -- '${zfunctions#${~zpre}}
+ for zroot_dir in ${_zroot_dirs}; do
+ zpre=${zroot_dir}$'\0'
+ if (( ${+_zifs[${zroot_dir}]} )); then
+ zroot_functions=(${${(M)zif_functions:#${zpre}*}#${zpre}})
+ zroot_cmds=(${${(M)zif_cmds:#${zpre}*}#${zpre}})
+ if (( ${#zroot_functions} || ${#zroot_cmds} )); then
+ print -R 'if '${_zifs[${zroot_dir}]}'; then'
+ if (( ${#zroot_functions} )) print -R ' autoload -Uz -- '${zroot_functions}
+ if (( ${#zroot_cmds} )) print -R ${(F):- ${^zroot_cmds}}
+ print fi
+ fi
+ else
+ zroot_cmds=(${${(M)zcmds:#${zpre}*}#${zpre}})
+ if (( ${#zroot_cmds} )) print -R ${(F)zroot_cmds}
+ fi
+ done
+ ) ${ztarget}
+}
+
+_zimfw_build_login_init() {
+ local -r ztarget=${ZIM_HOME}/login_init.zsh
+ # Force update of login_init.zsh if it's older than .zimrc
+ if [[ ${ztarget} -ot ${_zconfig} ]]; then
+ command mv -f ${ztarget}{,.old} || return 1
+ fi
+ _zimfw_mv =(
+ print '# Do nothing. This file is deprecated.'
+ ) ${ztarget}
+}
+
+_zimfw_build() {
+ _zimfw_build_init && _zimfw_build_login_init && _zimfw_print "Done with build.${_zrestartmsg}"
+}
+
+_zimfw_source_zimrc() {
+zmodule() {
+ local -r zusage="Usage: ${_zbold}${0}${_znormal} <url> [${_zbold}-n${_znormal}|${_zbold}--name${_znormal} <module_name>] [${_zbold}-r${_znormal}|${_zbold}--root${_znormal} <path>] [options]
+
+Add ${_zbold}zmodule${_znormal} calls to your ${_zbold}${_zconfig}${_znormal} 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 are equiva-
+ lent: ${_zbold}'foo'${_znormal}, ${_zbold}'zimfw/foo'${_znormal}, ${_zbold}'https://github.com/zimfw/foo.git${_znormal}'.
+ If an absolute path is given, the module is considered externally
+ installed and won't be installed or updated by zimfw.
+ ${_zbold}-n${_znormal}, ${_zbold}--name${_znormal} <module_name> Set a custom module name. Default: the last component in <url>.
+ Slashes can be used inside <module_name> to organize the module
+ into subdirectories. The module will be installed at
+ ${_zbold}${ZIM_HOME}/${_znormal}<module_name>.
+ ${_zbold}-r${_znormal}, ${_zbold}--root${_znormal} <path> Relative path to the module root.
+
+Per-module options:
+ ${_zbold}-b${_znormal}, ${_zbold}--branch${_znormal} <branch_name>
+ Use specified branch when installing and updating the module.
+ Overrides the tag option. Default: the repository default branch.
+ ${_zbold}-t${_znormal}, ${_zbold}--tag${_znormal} <tag_name> Use specified tag when installing and updating the module. Over-
+ rides the branch option.
+ ${_zbold}-u${_znormal}, ${_zbold}--use${_znormal} <tool_name> Install and update the module using the defined tool. Default is
+ either defined using ${_zbold}zstyle ':zim:zmodule' use '${_znormal}<tool_name>${_zbold}'${_znormal} or
+ set to ${_zbold}'auto'${_znormal}. The tools available are:
+ ${_zbold}'auto'${_znormal} tries to auto detect the tool to be used. When installing
+ a new module, ${_zbold}'git'${_znormal} will be used if the git command is available,
+ otherwise ${_zbold}'degit'${_znormal} will be used.
+ ${_zbold}'git'${_znormal} uses the git command. Local changes are preserved on up-
+ dates.
+ ${_zbold}'degit'${_znormal} 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.
+ ${_zbold}'mkdir'${_znormal} creates an empty directory. The <url> is only used to set
+ the module name. Use the ${_zbold}-c${_znormal}, ${_zbold}--cmd${_znormal} option or ${_zbold}--on-pull${_znormal} option to
+ execute the desired command to generate the module files.
+ ${_zbold}--no-submodules${_znormal} Don't install or update git submodules.
+ ${_zbold}-z${_znormal}, ${_zbold}--frozen${_znormal} 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:
+ ${_zbold}--if${_znormal} <test> Will only initialize module root if specified test returns a zero
+ exit status. The test is evaluated at every new terminal startup.
+ ${_zbold}--if-command${_znormal} <command_name>
+ Will only initialize module root if specified external command is
+ available. This is evaluated at every new terminal startup.
+ Equivalent to ${_zbold}--if '(( \${+commands[${_znormal}<command_name>${_zbold}]} ))'${_znormal}.
+ ${_zbold}--if-ostype${_znormal} <ostype> Will only initialize module root if ${_zbold}OSTYPE${_znormal} is equal to the given
+ expression. This is evaluated at every new terminal startup.
+ Equivalent to ${_zbold}--if '[[ \${OSTYPE} == ${_znormal}<ostype>${_zbold} ]]'${_znormal}.
+ ${_zbold}--on-pull${_znormal} <command> Execute command after installing or updating the module. The com-
+ mand is executed in the module root directory.
+ ${_zbold}-d${_znormal}, ${_zbold}--disabled${_znormal} 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:
+ ${_zbold}-f${_znormal}, ${_zbold}--fpath${_znormal} <path> Will add specified path to fpath. The path is relative to the
+ module root directory. Default: ${_zbold}'functions'${_znormal}, if the subdirectory
+ exists and is non-empty.
+ ${_zbold}-a${_znormal}, ${_zbold}--autoload${_znormal} <function_name>
+ Will autoload specified function. Default: all valid names inside
+ the ${_zbold}functions${_znormal} subdirectory, if any.
+ ${_zbold}-s${_znormal}, ${_zbold}--source${_znormal} <file_path> Will source specified file. The path is relative to the module
+ root directory. Default: ${_zbold}'init.zsh'${_znormal}, if a non-empty ${_zbold}functions${_znormal}
+ subdirectory exists, else the largest of the files matching the
+ glob ${_zbold}(init.zsh|${_znormal}<name>${_zbold}.(zsh|plugin.zsh|zsh-theme|sh))${_znormal}, if any. The
+ <name> in the glob is resolved to the last component of the mod-
+ ule name and the last component of the path to the module root.
+ ${_zbold}-c${_znormal}, ${_zbold}--cmd${_znormal} <command> Will execute specified command. Occurrences of the ${_zbold}{}${_znormal} placeholder
+ in the command are substituted by the module root directory path.
+ I.e., ${_zbold}-s 'foo.zsh'${_znormal} and ${_zbold}-c 'source {}/foo.zsh'${_znormal} 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 (( ! # )); then
+ print -u2 -lR "${_zerror}${funcfiletrace[1]}: Missing zmodule url${_znormal}" '' ${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 "${_zerror}${funcfiletrace[1]}:${_zbold}${zname}:${_znormalred} Missing argument for zmodule option ${_zbold}${1}${_znormal}" '' ${zusage}
+ _zfailed=1
+ return 2
+ fi
+ case ${1} in
+ -n|--name)
+ shift
+ zname=${${1%%/##}##/##}
+ ;;
+ -r|--root)
+ shift
+ zroot=${${1%%/##}##/##}
+ ;;
+ esac
+ shift
+ done
+ zname=modules/${zname}
+ _znames+=(${zname})
+ if [[ ${zurl} == /* ]]; then
+ _zpaths[${zname}]=${zurl%%/##}
+ zurl=
+ else
+ _zpaths[${zname}]=${ZIM_HOME}/${zname}
+ fi
+ if [[ ${+_zurls[${zname}]} -ne 0 && ${_zurls[${zname}]} != ${zurl} ]]; then
+ print -u2 -lR "${_zerror}${funcfiletrace[1]}:${_zbold}${zname}:${_znormalred} Module already defined with a different URL. Expected ${_zbold}${_zurls[${zname}]}${_znormal}" '' ${zusage}
+ _zfailed=1
+ return 2
+ fi
+ _zurls[${zname}]=${zurl}
+ local -r zroot_dir=${_zpaths[${zname}]}${zroot:+/${zroot}}
+ _zroot_dirs+=(${zroot_dir})
+ # Set default values
+ if (( ! ${+_ztools[${zname}]} )); then
+ zstyle -s ':zim:zmodule' use "_ztools[${zname}]" || _ztools[${zname}]=auto
+ 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|--if-ostype|-f|--fpath|-a|--autoload|-s|--source|-c|--cmd)
+ if (( # < 2 )); then
+ print -u2 -lR "${_zerror}${funcfiletrace[1]}:${_zbold}${zname}:${_znormalred} Missing argument for zmodule option ${_zbold}${1}${_znormal}" '' ${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 "${_zwarn}${funcfiletrace[1]}:${_zbold}${zname}:${_znormalyellow} The zmodule option ${_zbold}${1}${_znormalyellow} has no effect for external modules${_znormal}"
+ ;;
+ 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}]} ))"
+ ;;
+ --if-ostype)
+ shift
+ _zifs[${zroot_dir}]="[[ \${OSTYPE} == ${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 '${(qqq)zarg:a})
+ ;;
+ -c|--cmd)
+ shift
+ zcmds+=(${1//{}/${(qqq)zroot_dir:a}})
+ ;;
+ -d|--disabled) _zdisabled_paths+=(${zroot_dir}) ;;
+ *)
+ print -u2 -lR "${_zerror}${funcfiletrace[1]}:${_zbold}${zname}:${_znormalred} Unknown zmodule option ${_zbold}${1}${_znormal}" '' ${zusage}
+ _zfailed=1
+ return 2
+ ;;
+ esac
+ shift
+ done
+ # Detect tool if auto and not external and not frozen module
+ if [[ ${_ztools[${zname}]} == auto && -n ${_zurls[${zname}]} && _zfrozens[${zname}] -eq 0 ]]; then
+ if [[ -e ${_zpaths[${zname}]} ]]; then
+ if [[ -r ${_zpaths[${zname}]}/.git ]]; then
+ _ztools[${zname}]=git
+ elif [[ -r ${_zpaths[${zname}]}/.zdegit ]]; then
+ _ztools[${zname}]=degit
+ else
+ _zimfw_print -u2 -lR "${_zwarn}${funcfiletrace[1]}:${_zbold}${zname}:${_znormalyellow} Could not auto detect tool, will default to ${_zbold}mkdir${_znormalyellow}. Use zmodule option ${_zbold}-u${_znormalyellow}|${_zbold}--use${_znormalyellow} to stop this warning.${_znormal}"
+ _ztools[${zname}]=mkdir
+ fi
+ else
+ if [[ ${+commands[git]} -ne 0 && -x ${commands[git]} ]]; then
+ _ztools[${zname}]=git
+ else
+ _ztools[${zname}]=degit
+ fi
+ fi
+ fi
+ if (( ! ${_zdisabled_paths[(I)${zroot_dir}]} && _zeager )); then
+ if [[ ! -e ${zroot_dir} ]]; then
+ print -u2 -R "${_zerror}${funcfiletrace[1]}:${_zbold}${zname}: ${zroot_dir}${_znormalred} not found${_znormal}"
+ _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 '${(qqq)^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 '${(qqq)^zscripts:a})
+ fi
+ fi
+ if (( ! ${#zfpaths} && ! ${#zfunctions} && ! ${#zcmds} )); then
+ _zimfw_print -u2 -lR "${_zwarn}${funcfiletrace[1]}:${_zbold}${zname}:${_znormalyellow} Nothing found to be initialized. Customize the module name, root or initialization with ${_zbold}zmodule${_znormalyellow} options.${_znormal}" '' ${zusage}
+ fi
+ # Prefix is added to all _zfpaths, _zfunctions and _zcmds to distinguish the originating root dir
+ local -r zpre=${zroot_dir}$'\0'
+ zfpaths=(${${(@qqq)zfpaths:a}/${HOME}/\${HOME}})
+ _zfpaths+=(${zpre}${^zfpaths})
+ _zfunctions+=(${zpre}${^zfunctions})
+ zcmds=(${zcmds//${HOME}/\${HOME}})
+ _zcmds+=(${zpre}${^zcmds})
+ fi
+}
+
+ {
+ local -ri _zeager=${1}
+ local -i _zfailed=0
+ if [[ ! -e ${_zconfig} ]]; then
+ _zimfw_print -u2 "${_zyellow}Config file not found, will create ${_zbold}${_zconfig}${_znormal}"
+ command mkdir -p ${_zconfig:h} || return 1
+ print -Rn "#
+# This is not sourced during shell startup and is only used to configure zimfw.
+#
+
+#
+# Modules
+#
+
+# Sets sane Zsh built-in environment options.
+zmodule environment
+# Provides handy git aliases and functions.
+zmodule git
+# Applies correct bindkeys for input events.
+zmodule input
+# Sets a custom terminal title.
+zmodule termtitle
+# Utility aliases and functions. Adds colour to ls, grep and less.
+zmodule utility
+
+# <-- Normally new modules should be added here. Check each module documentation
+# for any caveats.
+
+#
+# Prompt
+#
+
+# Exposes how long the last command took to run to prompts.
+zmodule duration-info
+# Exposes git repository status information to prompts.
+zmodule git-info
+# A heavily reduced, ASCII-only version of the Spaceship and Starship prompts.
+zmodule asciiship
+
+#
+# Completion
+#
+
+# Additional completion definitions for Zsh.
+zmodule zsh-users/zsh-completions --fpath src
+# Enables and configures smart and extensive tab completion, must be sourced
+# after all modules that add completion definitions.
+zmodule completion
+
+#
+# Modules that must be initialized last
+#
+
+# Fish-like syntax highlighting for Zsh, must be sourced after completion.
+zmodule zsh-users/zsh-syntax-highlighting
+# Fish-like history search for Zsh, must be sourced after
+# zsh-users/zsh-syntax-highlighting.
+zmodule zsh-users/zsh-history-substring-search
+# Fish-like autosuggestions for Zsh. Add the following to your ~/.zshrc to boost
+# performance: ZSH_AUTOSUGGEST_MANUAL_REBIND=1
+zmodule zsh-users/zsh-autosuggestions
+" >${_zconfig} || return 1
+ fi
+ if ! source ${_zconfig} || (( _zfailed )); then
+ print -u2 -R "${_zred}Failed to source ${_zbold}${_zconfig}${_znormal}"
+ return 1
+ fi
+ if (( ${#_znames} == 0 )); then
+ print -u2 -R "${_zred}No modules defined in ${_zbold}${_zconfig}${_znormal}"
+ return 1
+ fi
+ # Remove all from _zfpaths, _zfunctions and _zcmds with disabled paths prefixes
+ local zpath zpre
+ for zpath in ${_zdisabled_paths}; do
+ zpre=${zpath}$'\0'
+ _zfpaths=(${_zfpaths:#${zpre}*})
+ _zfunctions=(${_zfunctions:#${zpre}*})
+ _zcmds=(${_zcmds:#${zpre}*})
+ done
+ } always {
+ unfunction zmodule
+ }
+}
+
+_zimfw_list_unused_paths() {
+ local -i i=1
+ local zinstalled=(${ZIM_HOME}/modules/*(N/))
+ local -r zpaths=(${(v)_zpaths})
+ # Search into subdirectories
+ while (( i <= ${#zinstalled} )); do
+ if (( zpaths[(I)${zinstalled[i]}/*] )); then
+ zinstalled+=(${zinstalled[i]}/*(N/))
+ zinstalled[i]=()
+ else
+ (( i++ ))
+ fi
+ done
+ # Unused = all installed dirs not in zpaths
+ _zunused_paths=(${zinstalled:|zpaths})
+ local zunused
+ for zunused (${_zunused_paths}) _zimfw_print -R "${_zbold}${zunused##${ZIM_HOME}/}${_znormal}${1}"
+}
+
+_zimfw_check_dumpfile() {
+ _zimfw_print -u2 "${_zyellow}Deprecated action. This is now handled by the completion module alone.${_znormal}"
+}
+
+_zimfw_check_version() {
+ if (( ${1} )); then
+ if (( ${2} )); then
+ # background check
+ if [[ -w ${_zversion_target:h} ]]; then
+ print -R ${${${(f)"$(GIT_HTTP_LOW_SPEED_LIMIT=1000 GIT_HTTP_LOW_SPEED_TIME=30 command git ls-remote --tags --refs --sort=-v:refname \
+ https://github.com/zimfw/zimfw.git 'v*' 2>/dev/null)"}##*v}[1]} >! ${_zversion_target} &!
+ fi
+ else
+ # foreground check
+ local tags
+ tags=$(command git ls-remote --tags --refs --sort=-v:refname https://github.com/zimfw/zimfw.git 'v*') || return 1
+ >! ${_zversion_target} <<<${${${(f)tags}##*v}[1]} || return 1
+ fi
+ fi
+ if [[ -f ${_zversion_target} ]]; then
+ local -r zlatest_version=$(<${_zversion_target})
+ if [[ -n ${zlatest_version} && ${_zversion} != ${zlatest_version} ]]; then
+ _zimfw_print -u2 -R "${_zyellow}Latest zimfw version is ${_zbold}${zlatest_version}${_znormalyellow}. You're using version ${_zbold}${_zversion}${_znormalyellow}. Run ${_zbold}zimfw upgrade${_znormalyellow} to upgrade.${_znormal}"
+ return 4
+ fi
+ fi
+}
+
+_zimfw_clean_compiled() {
+ # Array with unique dirs. ${ZIM_HOME} or any subdirectory should only occur once.
+ local -Ur zscriptdirs=(${ZIM_HOME:A} ${${(v)_zpaths##${ZIM_HOME}/*}:A})
+ local zopt
+ if (( _zprintlevel > 0 )) zopt=-v
+ command rm -f ${zopt} ${^zscriptdirs}/**/*.zwc(|.old)(N) && \
+ _zimfw_print "Done with clean-compiled. Restart your terminal or run ${_zbold}zimfw compile${_znormal} to re-compile."
+}
+
+_zimfw_clean_dumpfile() {
+ local zdumpfile zopt
+ zstyle -s ':zim:completion' dumpfile 'zdumpfile' || zdumpfile=${ZDOTDIR:-${HOME}}/.zcompdump
+ if (( _zprintlevel > 0 )) zopt=-v
+ command rm -f ${zopt} ${zdumpfile}(|.dat|.zwc(|.old))(N) && \
+ _zimfw_print -R "Done with clean-dumpfile.${_zrestartmsg}"
+}
+
+_zimfw_compile() {
+ # Compile zimfw scripts
+ local zroot_dir zfile
+ for zroot_dir in ${_zroot_dirs:|_zdisabled_paths}; do
+ if [[ ! -w ${zroot_dir} ]]; then
+ _zimfw_print -R "${_zwarn}${_zbold}${zroot_dir}:${_znormalyellow} No write permission, unable to compile.${_znormal}"
+ continue
+ fi
+ for zfile in ${zroot_dir}/(^*test*/)#*.zsh(|-theme)(N-.); do
+ if [[ ! ${zfile}.zwc -nt ${zfile} ]]; then
+ zcompile -R ${zfile} && _zimfw_print -R "${_zokay}${_zbold}${zfile}.zwc:${_znormal} Compiled"
+ fi
+ done
+ done
+ _zimfw_print 'Done with compile.'
+}
+
+_zimfw_info() {
+ _zimfw_info_print_symlink ZIM_HOME ${ZIM_HOME}
+ _zimfw_info_print_symlink 'zimfw config' ${_zconfig}
+ _zimfw_info_print_symlink 'zimfw script' ${__ZIMFW_FILE}
+ print -R 'zimfw version: '${_zversion}' (built at 2025-12-19 13:42:11 UTC, previous commit is 88af323)'
+ local zparam
+ for zparam in LANG ${(Mk)parameters:#LC_*} OSTYPE TERM TERM_PROGRAM TERM_PROGRAM_VERSION ZSH_VERSION; do
+ print -R ${(r.22....:.)zparam}${(P)zparam}
+ done
+}
+
+_zimfw_info_print_symlink() {
+ print -Rn ${(r.22....:.)1}${2}
+ if [[ -L ${2} ]] print -Rn ' -> '${2:A}
+ print
+}
+
+_zimfw_uninstall() {
+ if (( _zprintlevel <= 0 )); then
+ command rm -rf ${_zunused_paths} || return 1
+ else
+ local zunused_path
+ print "Found ${_zbold}${#_zunused_paths}${_znormal} unused module(s)."
+ for zunused_path in ${_zunused_paths}; do
+ if read -q "?Uninstall ${zunused_path} [y/N]? "; then
+ print
+ command rm -rfv ${zunused_path} || return 1
+ else
+ print
+ fi
+ done
+ print 'Done with uninstall.'
+ fi
+}
+
+_zimfw_upgrade() {
+ local -r ztarget=${__ZIMFW_FILE:A} zurl=https://github.com/zimfw/zimfw/releases/latest/download/zimfw.zsh.gz
+ if [[ ! -w ${ztarget:h} ]]; then
+ print -u2 -R "${_zred}No write permission to ${_zbold}${ztarget:h}${_znormalred}. Will not try to upgrade.${_znormal}"
+ return 1
+ fi
+ {
+ if [[ ${+commands[curl]} -ne 0 && -x ${commands[curl]} ]]; then
+ command curl -fsSL -o ${ztarget}.new.gz ${zurl} || return 1
+ else
+ local zopt
+ if (( _zprintlevel <= 1 )) zopt=-q
+ if ! command wget -nv ${zopt} -O ${ztarget}.new.gz ${zurl}; then
+ if (( _zprintlevel <= 1 )); then
+ print -u2 -R "${_zred}Failed to download ${_zbold}${zurl}${_znormalred}. Use ${_zbold}-v${_znormalred} option to see details.${_znormal}"
+ fi
+ return 1
+ fi
+ fi
+ command gunzip -f ${ztarget}.new.gz || return 1
+ # .latest_version can be outdated and will yield a false warning if zimfw is
+ # upgraded before .latest_version is refreshed. Bad thing about having a cache.
+ _zimfw_mv ${ztarget}{.new,} && command rm -f ${ZIM_HOME}/.latest_version && \
+ _zimfw_print "Done with upgrade.${_zrestartmsg}"
+ } always {
+ command rm -f ${ztarget}.new{,.gz}
+ }
+}
+
+_zimfw_run_list() {
+ local -r zname=${1}
+ local -r zpath=${_zpaths[${zname}]}
+ local -r zroot_dirs=(${(M)_zroot_dirs:#${zpath}(|/*)})
+ print -nR ${_zbold}${zname}${_znormal}
+ if [[ ! -e ${zpath} ]] print -n ' (not installed)'
+ if [[ -z ${_zurls[${zname}]} ]] print -n ' (external)'
+ if (( _zfrozens[${zname}] )) print -n ' (frozen)'
+ if [[ ${_zdisabled_paths[(I)${zpath}]} -ne 0 && ${zroot_dirs} == (${zpath}) ]] print -n ' (disabled)'
+ print
+ if (( _zprintlevel > 1 )); then
+ if [[ -z ${_zurls[${zname}]} ]]; then
+ print -R ' From: '${zpath}
+ elif (( ! _zfrozens[${zname}] )); then
+ if [[ ${_ztools[${zname}]} == mkdir ]]; then
+ print ' From: mkdir'
+ else
+ print -nR " From: ${_zurls[${zname}]}, "
+ if [[ -z ${_zrevs[${zname}]} ]]; then
+ print -n 'default branch'
+ else
+ print -nR "${_ztypes[${zname}]} ${_zrevs[${zname}]}"
+ fi
+ print -nR ", using ${_ztools[${zname}]}"
+ if (( ! _zsubmodules[${zname}] )) print -n ', no git submodules'
+ print
+ fi
+ if [[ -n ${_zonpulls[${zname}]} ]] print -R " On-pull: ${_zonpulls[${zname}]}"
+ fi
+ local zroot_dir zindent zpre
+ local -a zfpaths zfunctions zcmds
+ for zroot_dir in ${zroot_dirs}; do
+ if [[ ${zroot_dirs} == (${zpath}) ]]; then
+ zindent=' '
+ else
+ if [[ ${zroot_dir} == ${zpath} ]]; then
+ print -n ' Root: .'
+ else
+ print -nR ' Root: '${zroot_dir##${zpath}/}
+ fi
+ if (( _zdisabled_paths[(I)${zroot_dir}] )) print -n ' (disabled)'
+ print
+ zindent=' '
+ fi
+ if (( ${+_zifs[${zroot_dir}]} )) print -R ${zindent}'if: '${_zifs[${zroot_dir}]}
+ zpre=${zroot_dir}$'\0'
+ zfpaths=(${${(M)_zfpaths:#${zpre}*}#${zpre}})
+ zfunctions=(${${(M)_zfunctions:#${zpre}*}#${zpre}})
+ zcmds=(${${(M)_zcmds:#${zpre}*}#${zpre}})
+ if (( ${#zfpaths} )) print -R ${zindent}'fpath: '${zfpaths}
+ if (( ${#zfunctions} )) print -R ${zindent}'autoload: '${zfunctions}
+ if (( ${#zcmds} )) print -R ${zindent}'cmd: '${(j:; :)zcmds}
+ done
+ fi
+}
+
+_zimfw_create_dir() {
+ if ! ERR=$(command mkdir -p ${1} 2>&1); then
+ _zimfw_print_error "Error creating ${1}" ${ERR}
+ return 1
+ fi
+}
+
+_zimfw_print_error() {
+ print -u2 -lR "${_zerror}${_zbold}${_zname}:${_znormalred} ${1}${_znormal}" ${2:+${(F):- ${(f)^2}}}
+}
+
+_zimfw_print_okay() {
+ if (( _zprintlevel > ${2:-0} )) print -lR "${_zokay}${_zbold}${_zname}:${_znormal} ${1}" ${3:+${(F):- ${(f)^3}}}
+}
+
+_zimfw_print_warn() {
+ _zimfw_print -u2 -R "${_zwarn}${_zbold}${_zname}:${_znormalyellow} ${1}${_znormal}"
+}
+
+_zimfw_pull_print_okay() {
+ # Useb by tools, which run in a subshell
+ if [[ -n ${ONPULL} ]]; then
+ if ! ERR=$(builtin cd -q ${DIR} 2>&1 && builtin eval ${ONPULL} 2>&1); then
+ _zimfw_print_error 'Error during on-pull' ${ERR}
+ return 1
+ elif [[ ${_zprintlevel} -gt 1 && -n ${ERR} ]]; then
+ # Overrides ${3} to include the on-pull output, to be used by _zimfw_print_okay below.
+ builtin set ${1} ${2:-0} ${3:+${3}$'\n'}'On-pull output:'$'\n'${ERR}
+ fi
+ fi
+ _zimfw_print_okay "${@}"
+}
+
+_zimfw_download_tarball() {
+ if [[ ${URL} =~ ^([^:@/]+://)?([^@]+@)?([^:/]+)[:/]([^/]+/[^/]+)/?$ ]]; then
+ readonly HOST=${match[3]}
+ readonly REPO=${match[4]%.git}
+ fi
+ if [[ ${HOST} != github.com || -z ${REPO} ]]; then
+ _zimfw_print_error "${URL} is not a valid URL. Will not try to ${ACTION}. The zimfw degit tool only supports GitHub URLs. Use zmodule option ${_zbold}--use git${_znormalred} to use git instead."
+ return 1
+ fi
+ readonly HEADERS_TARGET=${DIR}/${TEMP}_headers
+ {
+ if [[ ${ACTION} != install ]]; then
+ readonly INFO=("${(@f)"$(<${INFO_TARGET})"}")
+ # Previous REV is in line 2, reserved for future use.
+ readonly INFO_HEADER=${INFO[3]}
+ fi
+ readonly TARBALL_URL=https://api.github.com/repos/${REPO}/tarball/${REV}
+ if [[ ${ACTION} == check ]]; then
+ if [[ -z ${INFO_HEADER} ]] return 0
+ if [[ ${+commands[curl]} -ne 0 && -x ${commands[curl]} ]]; then
+ command curl -IfsL -H ${INFO_HEADER} ${TARBALL_URL} >${HEADERS_TARGET}
+ else
+ command wget --spider -qS --header=${INFO_HEADER} ${TARBALL_URL} 2>${HEADERS_TARGET}
+ fi
+ else
+ if [[ ${+commands[curl]} -ne 0 && -x ${commands[curl]} ]]; then
+ if ! ERR=$(command curl -fsSL ${INFO_HEADER:+-H} ${INFO_HEADER} -o ${TARBALL_TARGET} -D ${HEADERS_TARGET} ${TARBALL_URL} 2>&1); then
+ _zimfw_print_error "Error downloading ${TARBALL_URL} with curl" ${ERR}
+ return 1
+ fi
+ else
+ # wget returns 8 when 304 Not Modified, so we cannot use wget's error codes
+ command wget -qS ${INFO_HEADER:+--header=${INFO_HEADER}} -O ${TARBALL_TARGET} ${TARBALL_URL} 2>${HEADERS_TARGET}
+ fi
+ fi
+ while IFS= read -r HEADER; do
+ HEADER=${${HEADER## ##}%%$'\r'##}
+ if [[ ${HEADER} == HTTP/* ]]; then
+ HTTP_CODE=${${(s: :)HEADER}[2]}
+ elif [[ ${${(L)HEADER%%:*}%% ##} == etag ]]; then
+ ETAG=${${HEADER#*:}## ##}
+ fi
+ done < ${HEADERS_TARGET}
+ if (( HTTP_CODE == 304 )); then
+ # Not Modified
+ command rm -f ${TARBALL_TARGET} 2>/dev/null
+ return 0
+ elif (( HTTP_CODE != 200 )); then
+ _zimfw_print_error "Error downloading ${TARBALL_URL}, HTTP code ${HTTP_CODE}"
+ return 1
+ fi
+ if [[ -z ${ETAG} ]]; then
+ _zimfw_print_error "Error downloading ${TARBALL_URL}, no ETag header found in response"
+ return 1
+ fi
+ if [[ ${ACTION} == check ]]; then
+ command touch ${TARBALL_TARGET} # Update available
+ else
+ if ! print -lR "${URL}" "${REV}" "If-None-Match: ${ETAG}" >! ${INFO_TARGET} 2>/dev/null; then
+ _zimfw_print_error "Error creating or updating ${INFO_TARGET}"
+ return 1
+ fi
+ fi
+ } always {
+ command rm -f ${HEADERS_TARGET} 2>/dev/null
+ }
+}
+
+_zimfw_untar_tarball() {
+ if ! ERR=$(command tar -C ${1} -xzf ${TARBALL_TARGET} 2>&1); then
+ _zimfw_print_error "Error extracting ${TARBALL_TARGET}" ${ERR}
+ return 1
+ fi
+ local zsubdir
+ for zsubdir in ${1}/*(/); do
+ if ! ERR=$(command mv -f ${zsubdir}/*(DN) ${1} 2>&1 && command rmdir ${zsubdir} 2>&1); then
+ _zimfw_print_error "Error moving ${zsubdir}" ${ERR}
+ return 1
+ fi
+ done
+}
+
+_zimfw_tool_degit() {
+ # This runs in a subshell
+ readonly -i SUBMODULES=${6}
+ readonly ACTION=${1} DIR=${2} URL=${3} REV=${5} ONPULL=${7} TEMP=.zdegit_${sysparams[pid]}_${RANDOM}
+ readonly TARBALL_TARGET=${DIR}/${TEMP}_tarball.tar.gz INFO_TARGET=${DIR}/.zdegit
+ case ${ACTION} in
+ pre|prereinstall)
+ local premsg
+ if [[ ${ACTION} == pre ]] premsg=" Use zmodule option ${_zbold}-z${_znormalred}|${_zbold}--frozen${_znormalred} to disable this error or run ${_zbold}zimfw reinstall${_znormalred} to reinstall."
+ if [[ -e ${DIR} ]]; then
+ if [[ ! -r ${INFO_TARGET} ]]; then
+ _zimfw_print_error $'Module was not installed using zimfw\'s degit.'${premsg}
+ return 1
+ fi
+ readonly INFO=("${(@f)"$(<${INFO_TARGET})"}")
+ if [[ ${URL} != ${INFO[1]} ]]; then
+ _zimfw_print_error 'The zimfw degit URL does not match. Expected '${URL}.${premsg}
+ return 1
+ fi
+ fi
+ return 0
+ ;;
+ install)
+ {
+ _zimfw_create_dir ${DIR} && _zimfw_download_tarball && _zimfw_untar_tarball ${DIR} && _zimfw_pull_print_okay Installed || return 1
+ } always {
+ # return 1 does not change ${TRY_BLOCK_ERROR}, only changes ${?}
+ (( TRY_BLOCK_ERROR = ? ))
+ command rm -f ${TARBALL_TARGET} 2>/dev/null
+ if (( TRY_BLOCK_ERROR )) command rm -rf ${DIR} 2>/dev/null
+ }
+ ;;
+ check|update)
+ readonly DIR_NEW=${DIR}${TEMP}
+ {
+ _zimfw_download_tarball || return 1
+ if [[ ${ACTION} == check ]]; then
+ if [[ -e ${TARBALL_TARGET} ]]; then
+ _zimfw_print_okay 'Update available'
+ return 4
+ fi
+ _zimfw_print_okay 'Already up to date' 1
+ return 0
+ else
+ if [[ -e ${TARBALL_TARGET} ]]; then
+ _zimfw_create_dir ${DIR_NEW} && _zimfw_untar_tarball ${DIR_NEW} || return 1
+ if [[ ${+commands[diff]} -ne 0 && -x ${commands[diff]} ]]; then
+ LOG=$(command diff -x '.zdegit*' -x '*.zwc' -x '*.zwc.old' -qr ${DIR} ${DIR_NEW} 2>/dev/null)
+ LOG=${${LOG//${DIR_NEW}/new}//${DIR}/old}
+ fi
+ if ! ERR=$({ command cp -f ${INFO_TARGET} ${DIR_NEW} && \
+ command rm -rf ${DIR} && command mv -f ${DIR_NEW} ${DIR} } 2>&1); then
+ _zimfw_print_error "Error updating ${DIR}" ${ERR}
+ return 1
+ fi
+ _zimfw_pull_print_okay Updated 0 ${LOG} || return 1
+ else
+ _zimfw_pull_print_okay 'Already up to date' || return 1
+ fi
+ fi
+ } always {
+ command rm -f ${TARBALL_TARGET} 2>/dev/null
+ command rm -rf ${DIR_NEW} 2>/dev/null
+ }
+ ;;
+ esac
+ # Check after successful install or update
+ if [[ ${SUBMODULES} -ne 0 && -e ${DIR}/.gitmodules ]]; then
+ _zimfw_print_warn "Module contains git submodules, which are not supported by zimfw's degit. Use zmodule option ${_zbold}--no-submodules${_znormalyellow} to stop this warning."
+ fi
+}
+
+_zimfw_tool_git() {
+ # This runs in a subshell
+ readonly -i SUBMODULES=${6}
+ readonly ACTION=${1} DIR=${2} URL=${3} TYPE=${4} ONPULL=${7}
+ REV=${5}
+ case ${ACTION} in
+ pre|prereinstall)
+ local premsg
+ if [[ ${ACTION} == pre ]] premsg=" Use zmodule option ${_zbold}-z${_znormalred}|${_zbold}--frozen${_znormalred} to disable this error or run ${_zbold}zimfw reinstall${_znormalred} to reinstall."
+ if [[ -e ${DIR} ]]; then
+ if [[ ! -r ${DIR}/.git ]]; then
+ _zimfw_print_error 'Module was not installed using git.'${premsg}
+ return 1
+ fi
+ if [[ ${URL} != $(command git -C ${DIR} config --get remote.origin.url) ]]; then
+ _zimfw_print_error 'The git URL does not match. Expected '${URL}.${premsg}
+ return 1
+ fi
+ if [[ ${TYPE} == branch ]]; then
+ if [[ -z ${REV} ]]; then
+ if REV=$(command git -C ${DIR} symbolic-ref --short refs/remotes/origin/HEAD 2>&1); then
+ REV=${REV#origin/}
+ else
+ _zimfw_print_error 'Error during git symbolic-ref.'${premsg} ${REV}
+ return 1
+ fi
+ fi
+ readonly AHEAD_AND_BEHIND=$(command git -C ${DIR} rev-list --count --left-right ${REV}...${REV}@{u} -- 2>/dev/null)
+ readonly -i AHEAD=${AHEAD_AND_BEHIND[(w)1]}
+ readonly -i BEHIND=${AHEAD_AND_BEHIND[(w)2]}
+ if (( AHEAD && BEHIND )); then
+ _zimfw_print_error "Diverged [ahead ${AHEAD}, behind ${BEHIND}]."${premsg}
+ return 1
+ fi
+ fi
+ fi
+ ;;
+ install)
+ if ERR=$(command git clone ${REV:+-b} ${REV} -q --config core.autocrlf=false ${${SUBMODULES:#0}:+--recursive} -- ${URL} ${DIR} 2>&1); then
+ _zimfw_pull_print_okay Installed
+ else
+ _zimfw_print_error 'Error during git clone' ${ERR}
+ return 1
+ fi
+ ;;
+ check|update)
+ if ! ERR=$(command git -C ${DIR} fetch -pqt origin 2>&1); then
+ _zimfw_print_error 'Error during git fetch' ${ERR}
+ return 1
+ fi
+ if [[ ${TYPE} == branch ]]; then
+ if [[ -z ${REV} ]]; then
+ # Get HEAD remote branch
+ if ! ERR=$(command git -C ${DIR} remote set-head origin -a 2>&1); then
+ _zimfw_print_error 'Error during git remote set-head' ${ERR}
+ return 1
+ fi
+ if REV=$(command git -C ${DIR} symbolic-ref --short refs/remotes/origin/HEAD 2>&1); then
+ REV=${REV#origin/}
+ else
+ _zimfw_print_error 'Error during git symbolic-ref' ${REV}
+ return 1
+ fi
+ fi
+ if [[ ${ACTION} == check ]]; then
+ readonly -i BEHIND=$(command git -C ${DIR} rev-list --count ${REV}..${REV}@{u} -- 2>/dev/null)
+ if (( BEHIND )); then
+ _zimfw_print_okay "Update available [behind ${BEHIND}]"
+ return 4
+ else
+ _zimfw_print_okay 'Already up to date' 1
+ return 0
+ fi
+ fi
+ TO_REV=${REV}@{u}
+ else
+ if [[ ${REV} == $(command git -C ${DIR} describe --tags --exact-match 2>/dev/null) ]]; then
+ if [[ ${ACTION} == check ]]; then
+ _zimfw_print_okay 'Already up to date' 1
+ return 0
+ else
+ _zimfw_pull_print_okay 'Already up to date'
+ return ${?}
+ fi
+ fi
+ if [[ ${ACTION} == check ]]; then
+ _zimfw_print_okay 'Update available'
+ return 4
+ fi
+ TO_REV=${REV}
+ fi
+ if [[ -z ${NO_COLOR} && -t 1 ]]; then
+ LOG=$(command git -C ${DIR} log --graph --color --format='%C(yellow)%h%C(reset) %s %C(cyan)(%cr)%C(reset)' ..${TO_REV} -- 2>/dev/null)
+ else
+ LOG=$(command git -C ${DIR} log --graph --format='%h %s (%cr)' ..${TO_REV} -- 2>/dev/null)
+ fi
+ if ! ERR=$(command git -C ${DIR} checkout -q ${REV} -- 2>&1); then
+ _zimfw_print_error 'Error during git checkout' ${ERR}
+ return 1
+ fi
+ if [[ ${TYPE} == branch ]]; then
+ if ! OUT=$(command git -C ${DIR} merge --ff-only --no-progress -n 2>&1); then
+ _zimfw_print_error 'Error during git merge' ${OUT}
+ return 1
+ fi
+ # keep just first line of OUT
+ OUT=${OUT%%($'\n'|$'\r')*}
+ else
+ OUT="Updating to ${TYPE} ${REV}"
+ fi
+ if (( SUBMODULES )); then
+ if ! ERR=$(command git -C ${DIR} submodule update --init --recursive -q -- 2>&1); then
+ _zimfw_print_error 'Error during git submodule update' ${ERR}
+ return 1
+ fi
+ fi
+ _zimfw_pull_print_okay ${OUT} 0 ${LOG}
+ ;;
+ esac
+}
+
+_zimfw_tool_mkdir() {
+ # This runs in a subshell
+ readonly -i SUBMODULES=${6}
+ readonly ACTION=${1} DIR=${2} TYPE=${4} REV=${5} ONPULL=${7}
+ if [[ ${ACTION} == (pre|prereinstall) ]] return 0
+ if [[ ${ACTION} == check ]]; then
+ _zimfw_print_okay 'Skipping mkdir module' 1
+ return 0
+ fi
+ if [[ -n ${REV} ]]; then
+ _zimfw_print_warn "The zmodule option ${_zbold}-${TYPE[1]}${_znormalyellow}|${_zbold}--${TYPE}${_znormalyellow} has no effect when using the mkdir tool"
+ fi
+ if (( ! SUBMODULES )); then
+ _zimfw_print_warn "The zmodule option ${_zbold}--no-submodules${_znormalyellow} has no effect when using the mkdir tool"
+ fi
+ if [[ ! -d ${DIR} || -n ${ONPULL} ]]; then
+ local -r zroot_dirs=(${(M)_zroot_dirs:#${DIR}(|/*)})
+ local zroot_dir
+ for zroot_dir in ${zroot_dirs}; do
+ _zimfw_create_dir ${zroot_dir} || return 1
+ done
+ _zimfw_pull_print_okay Created || return 1
+ fi
+}
+
+_zimfw_run_tool() {
+ local zaction=${1}
+ local -r _zname=${2}
+ if [[ -z ${_zurls[${_zname}]} ]]; then
+ _zimfw_print_okay 'Skipping external module' 1
+ return 0
+ fi
+ if (( _zfrozens[${_zname}] )); then
+ _zimfw_print_okay 'Skipping frozen module' 1
+ return 0
+ fi
+ local -r ztool=${_ztools[${_zname}]}
+ if [[ ${ztool} != (degit|git|mkdir) ]]; then
+ _zimfw_print_error "Unknown tool ${ztool}"
+ return 1
+ fi
+ set "${_zpaths[${_zname}]}" "${_zurls[${_zname}]}" "${_ztypes[${_zname}]}" "${_zrevs[${_zname}]}" "${_zsubmodules[${_zname}]}" "${_zonpulls[${_zname}]}"
+ if [[ ${zaction} == reinstall ]]; then
+ _zimfw_tool_${ztool} prereinstall "${@}" && return 0
+ if (( _zprintlevel > 0 )); then
+ if read -q "?Reinstall ${_zname} [y/N]? "; then
+ print
+ else
+ print
+ return 0
+ fi
+ fi
+ local -r zpath_new=.${_zpaths[${_zname}]}_${sysparams[pid]}_${RANDOM}
+ {
+ _zimfw_tool_${ztool} install ${zpath_new} "${@:2}" || return 1
+ if ! ERR=$({ command rm -rf ${_zpaths[${_zname}]} && command mv -f ${zpath_new} ${_zpaths[${_zname}]} } 2>&1); then
+ _zimfw_print_error "Error reinstalling ${_zpaths[${_zname}]}" ${ERR}
+ return 1
+ fi
+ } always {
+ command rm -rf ${zpath_new} 2>/dev/null
+ }
+ return 0
+ else
+ _zimfw_tool_${ztool} pre "${@}" || return 1
+ fi
+ case ${zaction} in
+ install)
+ if [[ -e ${_zpaths[${_zname}]} ]]; then
+ _zimfw_print_okay 'Skipping already installed module' 1
+ return 0
+ fi
+ ;;
+ check|update)
+ if [[ ! -d ${_zpaths[${_zname}]} ]]; then
+ _zimfw_print_error "Not installed. Run ${_zbold}zimfw install${_znormalred} to install."
+ return 1
+ fi
+ ;;
+ *)
+ _zimfw_print_error "Unknown action ${zaction}"
+ return 1
+ ;;
+ esac
+ _zimfw_tool_${ztool} ${zaction} "${@}"
+}
+
+_zimfw_run_tool_action() {
+ local -i zmaxprocs=0
+ if [[ ${1} == reinstall ]] zmaxprocs=1
+ _zimfw_source_zimrc 0 || return 1
+ zargs -n 2 -P ${zmaxprocs} -- "${_znames[@]}" -- _zimfw_run_tool ${1}
+ return 0
+}
+
+zimfw() {
+ builtin emulate -L zsh -o EXTENDED_GLOB
+ if [[ -z ${NO_COLOR} && -t 1 ]]; then
+ local -r _znormal=$'\E[0m' _zbold=$'\E[1m' _zred=$'\E[31m' _znormalred=$'\E[0;31m' _zgreen=$'\E[32m' _zyellow=$'\E[33m' _znormalyellow=$'\E[0;33m'
+ else
+ local -r _znormal= _zbold= _zred= _znormalred= _zgreen= _zyellow= _znormalyellow=
+ fi
+ local -r _zerror="${_zred}x " _zokay="${_zgreen}) ${_znormal}" _zwarn="${_zyellow}! "
+ local -r _zconfig=${ZIM_CONFIG_FILE:-${ZDOTDIR:-${HOME}}/.zimrc} _zversion='1.20.0'
+ local -r zusage="Usage: ${_zbold}${0}${_znormal} <action> [option]
+
+Actions:
+ ${_zbold}build${_znormal} Build ${_zbold}${ZIM_HOME}/init.zsh${_znormal} and ${_zbold}${ZIM_HOME}/login_init.zsh${_znormal}.
+ Also does ${_zbold}compile${_znormal}. Use ${_zbold}-v${_znormal} to also see its output.
+ ${_zbold}clean${_znormal} Clean all. Does both ${_zbold}clean-compiled${_znormal} and ${_zbold}clean-dumpfile${_znormal}.
+ ${_zbold}clean-compiled${_znormal} Clean Zsh compiled files.
+ ${_zbold}clean-dumpfile${_znormal} Clean completion dumpfile.
+ ${_zbold}compile${_znormal} Compile Zsh files.
+ ${_zbold}info${_znormal} Print zimfw and system info.
+ ${_zbold}list${_znormal} List all modules defined in ${_zbold}${_zconfig}${_znormal}.
+ Use ${_zbold}-v${_znormal} to also see their initialization details.
+ ${_zbold}init${_znormal} Same as ${_zbold}install${_znormal}, but with output tailored for the terminal startup.
+ ${_zbold}install${_znormal} Install new modules. Also does ${_zbold}build${_znormal}, ${_zbold}compile${_znormal}. Use ${_zbold}-v${_znormal} to also see their
+ output, any on-pull output and skipped modules.
+ ${_zbold}update${_znormal} Update current modules. Also does ${_zbold}build${_znormal}, ${_zbold}compile${_znormal}. Use ${_zbold}-v${_znormal} to also see
+ their output, any on-pull output and skipped modules.
+ ${_zbold}reinstall${_znormal} Reinstall modules that failed check. Prompts for confirmation, unless ${_zbold}-q${_znormal}
+ is used. Also does ${_zbold}build${_znormal}, ${_zbold}compile${_znormal}. Use ${_zbold}-v${_znormal} to also see their output, any
+ on-pull output and skipped modules.
+ ${_zbold}uninstall${_znormal} Delete unused modules. Prompts for confirmation, unless ${_zbold}-q${_znormal} is used. Also
+ does ${_zbold}build${_znormal}. Use ${_zbold}-v${_znormal} to also see its output.
+ ${_zbold}check${_znormal} Check if updates for current modules are available. Use ${_zbold}-v${_znormal} to also see
+ skipped and up to date modules.
+ ${_zbold}check-version${_znormal} Check if a new version of zimfw is available.
+ ${_zbold}upgrade${_znormal} Upgrade zimfw. Also does ${_zbold}compile${_znormal}. Use ${_zbold}-v${_znormal} to also see its output.
+ ${_zbold}help${_znormal}, ${_zbold}--help${_znormal} Print this help.
+ ${_zbold}version${_znormal}, ${_zbold}--version${_znormal} Print zimfw version.
+
+Options:
+ ${_zbold}-q${_znormal} Quiet (yes to prompts and only output errors)
+ ${_zbold}-v${_znormal} Verbose (output more details)"
+ local -i _zprintlevel=1
+ if (( # > 2 )); then
+ print -u2 -lR "${_zred}${0}: Too many options${_znormal}" '' ${zusage}
+ return 2
+ elif (( # > 1 )); then
+ case ${2} in
+ -q) _zprintlevel=0 ;;
+ -v) _zprintlevel=2 ;;
+ *)
+ print -u2 -lR "${_zred}${0}: Unknown option ${2}${_znormal}" '' ${zusage}
+ return 2
+ ;;
+ esac
+ fi
+ case ${1} in
+ help|--help)
+ print -R ${zusage}
+ return
+ ;;
+ version|--version)
+ print -R ${_zversion}
+ return
+ ;;
+ esac
+
+ if (( ! ${+ZIM_HOME} )); then
+ print -u2 -R "${_zred}${0}: ${_zbold}ZIM_HOME${_znormalred} not defined${_znormal}"
+ return 1
+ fi
+ if [[ ! -e ${ZIM_HOME} ]]; then
+ command mkdir -p ${ZIM_HOME} || return 1
+ fi
+
+ local -r _zversion_target=${ZIM_HOME}/.latest_version
+ if ! zstyle -t ':zim' disable-version-check && \
+ [[ ${1} != check-version && -w ${ZIM_HOME} && -w ${__ZIMFW_FILE:A:h} ]]
+ then
+ # If .latest_version does not exist or was not modified in the last 30 days
+ [[ -f ${_zversion_target}(#qNm-30) ]]; local -r zversion_check_force=${?}
+ _zimfw_check_version ${zversion_check_force} 1
+ fi
+
+ if [[ ! -w ${ZIM_HOME} && ${1} == (build|check|init|install|update|reinstall|check-version) ]]; then
+ print -u2 -R "${_zred}${0}: No write permission to ${_zbold}${ZIM_HOME}${_znormalred}. Will not try to ${1}.${_znormal}"
+ return 1
+ fi
+ local -Ua _znames _zroot_dirs _zdisabled_paths
+ local -A _zfrozens _ztools _zpaths _zurls _ztypes _zrevs _zsubmodules _zonpulls _zifs
+ local -a _zfpaths _zfunctions _zcmds _zunused_paths
+ local _zrestartmsg=' Restart your terminal for changes to take effect.'
+ autoload -Uz zargs
+ case ${1} in
+ build)
+ _zimfw_source_zimrc 1 && _zimfw_build || return 1
+ (( _zprintlevel-- ))
+ _zimfw_compile
+ ;;
+ check-dumpfile) _zimfw_check_dumpfile ;;
+ clean) _zimfw_source_zimrc 0 && _zimfw_clean_compiled && _zimfw_clean_dumpfile ;;
+ clean-compiled) _zimfw_source_zimrc 0 && _zimfw_clean_compiled ;;
+ clean-dumpfile) _zimfw_clean_dumpfile ;;
+ compile) _zimfw_source_zimrc 0 && _zimfw_compile ;;
+ info) _zimfw_info ;;
+ list)
+ _zimfw_source_zimrc $(( _zprintlevel > 1 )) && \
+ zargs -n 1 -- "${_znames[@]}" -- _zimfw_run_list && \
+ _zimfw_list_unused_paths ' (unused)'
+ ;;
+ check)
+ _zimfw_run_tool_action ${1} || return 1
+ (( _zprintlevel-- ))
+ _zimfw_print -R "Done with ${1}. Run ${_zbold}zimfw update${_znormal} to update modules." # Only printed in verbose mode
+ ;;
+ init)
+ _zrestartmsg=
+ _zimfw_run_tool_action install || return 1
+ (( _zprintlevel-- ))
+ _zimfw_print 'Done with install.' # Only printed in verbose mode
+ _zimfw_source_zimrc 1 && _zimfw_build && _zimfw_compile
+ ;;
+ install|update|reinstall)
+ _zimfw_run_tool_action ${1} || return 1
+ _zimfw_print -R "Done with ${1}.${_zrestartmsg}"
+ (( _zprintlevel-- ))
+ _zimfw_source_zimrc 1 && _zimfw_build && _zimfw_compile
+ ;;
+ uninstall)
+ _zimfw_source_zimrc 0 && _zimfw_list_unused_paths && _zimfw_uninstall || return 1
+ (( _zprintlevel-- ))
+ _zimfw_source_zimrc 1 && _zimfw_build
+ ;;
+ check-version)
+ _zimfw_check_version 1
+ (( _zprintlevel-- ))
+ _zimfw_print -R "Done with ${1}." # Only printed in verbose mode
+ ;;
+ upgrade)
+ _zimfw_upgrade || return 1
+ (( _zprintlevel-- ))
+ _zimfw_source_zimrc 0 && _zimfw_compile
+ ;;
+ *)
+ print -u2 -lR "${_zred}${0}: Unknown action ${1}${_znormal}" '' ${zusage}
+ return 2
+ ;;
+ esac
+}
+
+zimfw "${@}"
diff --git a/.zimrc b/.zimrc
new file mode 100644
index 0000000..c1002f7
--- /dev/null
+++ b/.zimrc
@@ -0,0 +1,56 @@
+#
+# This is not sourced during shell startup and is only used to configure zimfw.
+#
+
+#
+# Modules
+#
+
+# Sets sane Zsh built-in environment options.
+zmodule environment
+# Provides handy git aliases and functions.
+zmodule git
+# Applies correct bindkeys for input events.
+zmodule input
+# Sets a custom terminal title.
+zmodule termtitle
+# Utility aliases and functions. Adds colour to ls, grep and less.
+zmodule utility
+
+# <-- Normally new modules should be added here. Check each module documentation
+# for any caveats.
+
+#
+# Prompt
+#
+
+# Exposes how long the last command took to run to prompts.
+zmodule duration-info
+# Exposes git repository status information to prompts.
+zmodule git-info
+# A heavily reduced, ASCII-only version of the Spaceship and Starship prompts.
+zmodule prompt-pwd
+zmodule oblong
+
+#
+# Completion
+#
+
+# Additional completion definitions for Zsh.
+zmodule zsh-users/zsh-completions --fpath src
+# Enables and configures smart and extensive tab completion, must be sourced
+# after all modules that add completion definitions.
+zmodule completion
+
+#
+# Modules that must be initialized last
+#
+
+# Fish-like syntax highlighting for Zsh, must be sourced after completion.
+zmodule zsh-users/zsh-syntax-highlighting
+# Fish-like history search for Zsh, must be sourced after
+# zsh-users/zsh-syntax-highlighting.
+zmodule zsh-users/zsh-history-substring-search
+# Fish-like autosuggestions for Zsh. Add the following to your ~/.zshrc to boost
+# performance: ZSH_AUTOSUGGEST_MANUAL_REBIND=1
+zmodule zsh-users/zsh-autosuggestions
generated by cgit v1.2.3 (git 2.25.1) at 2026-07-30 07:54:04 +0000