├── .gitignore
├── LICENSE
├── README.md
├── _zgen
└── zgen.zsh


/.gitignore:
--------------------------------------------------------------------------------
1 | *
2 | !.gitignore
3 | !LICENSE
4 | !README.md
5 | !_zgen
6 | !zgen.zsh
7 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2014, Eero-Antero Säisä
 2 | All rights reserved.
 3 | 
 4 | Redistribution and use in source and binary forms, with or without
 5 | modification, are permitted provided that the following conditions are met:
 6 | 
 7 | 1. Redistributions of source code must retain the above copyright notice, this
 8 |    list of conditions and the following disclaimer.
 9 | 
10 | 2. Redistributions in binary form must reproduce the above copyright notice,
11 |    this list of conditions and the following disclaimer in the documentation
12 |    and/or other materials provided with the distribution.
13 | 
14 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
15 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
18 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
20 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
21 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
22 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | ## zgen
  2 | 
  3 | A lightweight plugin manager for Zsh inspired by [Antigen](https://github.com/zsh-users/antigen). Keep your `.zshrc` clean and simple.
  4 | 
  5 | Zgen provides you a few simple commands for managing plugins. It installs your plugins and generates a static init script that will source them for you every time you run the shell. We do this to save some startup time by not having to execute time consuming logic (plugin checking, updates, etc). This means that you have to manually check for updates (`zgen update`) and reset the init script (`zgen reset`) whenever you add or remove plugins.
  6 | 
  7 | The motive for creating zgen was to have plugins quickly installed on a new machine without getting the startup lag that Antigen used to give me.
  8 | 
  9 | ## Installation
 10 | 
 11 | Clone the zgen repository
 12 | 
 13 |     git clone https://github.com/tarjoilija/zgen.git "${HOME}/.zgen"
 14 | 
 15 | Edit your .zshrc file to load zgen
 16 | 
 17 |     # load zgen
 18 |     source "${HOME}/.zgen/zgen.zsh"
 19 | 
 20 | Place the following code after the one above to load oh-my-zsh for example, see Usage for more details
 21 | 
 22 |     # if the init script doesn't exist
 23 |     if ! zgen saved; then
 24 | 
 25 |       # specify plugins here
 26 |       zgen oh-my-zsh
 27 | 
 28 |       # generate the init script from plugins above
 29 |       zgen save
 30 |     fi
 31 | 
 32 | ## Usage
 33 | 
 34 | ### oh-my-zsh
 35 | 
 36 | This is a handy shortcut for installing oh-my-zsh plugins. They can be loaded using `zgen load` too with a significantly longer format.
 37 | #### Load oh-my-zsh base
 38 | It's a good idea to load the base components before specifying any plugins.
 39 | 
 40 |     zgen oh-my-zsh
 41 | 
 42 | #### Load oh-my-zsh plugins
 43 | 
 44 |     zgen oh-my-zsh <location>
 45 | 
 46 | #### Example
 47 | 
 48 |     zgen oh-my-zsh
 49 |     zgen oh-my-zsh plugins/git
 50 |     zgen oh-my-zsh plugins/sudo
 51 |     zgen oh-my-zsh plugins/command-not-found
 52 |     zgen oh-my-zsh themes/arrow
 53 | 
 54 | ### Prezto
 55 | 
 56 | #### Load Prezto
 57 | 
 58 |     zgen prezto
 59 | 
 60 | This will create a symlink in the `ZSHDOT` or `HOME` directory. This is needed by prezto.
 61 | 
 62 | #### Load prezto plugins
 63 | 
 64 |     zgen prezto <modulename>
 65 | 
 66 | This uses the Prezto method for loading modules.
 67 | 
 68 | #### Load a repo as Prezto plugins
 69 | 
 70 |     zgen pmodule <reponame> <branch>
 71 | 
 72 | This uses the Prezto method for loading the module. It creates a symlink and calls `pmodule`.
 73 | 
 74 | #### Set prezto options
 75 | 
 76 |     zgen prezto <modulename> <option> <value(s)>
 77 | 
 78 | This must be used before the module is loaded. Or if the default modules should be loaded (default) these settings must be done before the `zgen prezto` command. `module` is prepended if the name does not start with `module`, `prezto` or a `*`, `prezto` is prepended if it does not start with `prezto`.
 79 | 
 80 | ### General zgen functions
 81 | 
 82 | #### Load plugins and completions
 83 | 
 84 |     zgen load <repo> [location] [branch]
 85 | 
 86 | Zgen tries to source any scripts from `location` using a "very smart matching logic". If it fails to find any, it will appends `location` to `$fpath`.
 87 | 
 88 | - `repo`
 89 |     - github `user/repository` or path to a repository
 90 |     - currently supported formats for a repository path:
 91 |         - any local repository
 92 |         - `git://*`
 93 |         - `https://*`
 94 |         - `http://*`
 95 |         - `ssh://*`
 96 |         - `git@*:*/*`
 97 | - `location`
 98 |     - relative path to a script/folder
 99 |     - useful for repositories that don't have proper plugin support like `zsh-users/zsh-completions`
100 | - `branch`
101 |     - specifies the git branch to use
102 | 
103 | #### Bulk load plugins
104 | 
105 |     zgen loadall <plugins>
106 | 
107 | Please see example `.zshrc` for usage.
108 | 
109 | #### Generate init script
110 |     zgen save
111 | 
112 | It is recommended to save the plugin sourcing part to a static init script so we don't have to go through the time consuming installing/updating part every time we start the shell (or source .zshrc)
113 | 
114 | #### Remove init script
115 |     zgen reset
116 | 
117 | Removes the init script so it will be created next time you start the shell. You must run this every time you add or remove plugins to trigger the changes.
118 | 
119 | This will not remove the plugins physically from disk.
120 | 
121 | #### Check for an init script
122 |     zgen saved
123 | Returns 0 if an init script exists.
124 | 
125 | #### Update all plugins and reset
126 |     zgen update
127 | 
128 | Pulls updates on every plugin repository and removes the init script.
129 | 
130 | #### Update zgen
131 |     zgen selfupdate
132 | 
133 | #### Watch files for modifications
134 | You can automate the process of running `zgen reset` by specifying a list of files to `ZGEN_RESET_ON_CHANGE`. These files will be checked and if a change is detected zgen reset is called.
135 | 
136 | ```zsh
137 | ZGEN_RESET_ON_CHANGE=(${HOME}/.zshrc ${HOME}/.zshrc.local)
138 | ```
139 | 
140 | ## Notes
141 | Be aware that `zgen` tries to handle [`compinit`][compinit] for you to allow for the fastest possible initialization times. However, this functionality will be disabled if you've already called `compinit` yourself before sourcing `zgen.zsh`. Alternatively, you can disable it yourself by disabling `$ZGEN_AUTOLOAD_COMPINIT`.
142 | 
143 |   [compinit]: <http://zsh.sourceforge.net/Doc/Release/Completion-System.html#Use-of-compinit> "Zsh manual 20.2.1: Use of compinit"
144 | 
145 | ## Example .zshrc
146 | 
147 | ```zsh
148 | # load zgen
149 | source "${HOME}/.zgen/zgen.zsh"
150 | 
151 | # if the init scipt doesn't exist
152 | if ! zgen saved; then
153 |     echo "Creating a zgen save"
154 | 
155 |     zgen oh-my-zsh
156 | 
157 |     # plugins
158 |     zgen oh-my-zsh plugins/git
159 |     zgen oh-my-zsh plugins/sudo
160 |     zgen oh-my-zsh plugins/command-not-found
161 |     zgen load zsh-users/zsh-syntax-highlighting
162 |     zgen load /path/to/super-secret-private-plugin
163 | 
164 |     # bulk load
165 |     zgen loadall <<EOPLUGINS
166 |         zsh-users/zsh-history-substring-search
167 |         /path/to/local/plugin
168 | EOPLUGINS
169 |     # ^ can't indent this EOPLUGINS
170 | 
171 |     # completions
172 |     zgen load zsh-users/zsh-completions src
173 | 
174 |     # theme
175 |     zgen oh-my-zsh themes/arrow
176 | 
177 |     # save all to init script
178 |     zgen save
179 | fi
180 | ```
181 | 
182 | ### Example .zshrc for prezto use
183 | Here is a partial example how to work with prezto
184 | 
185 | ```zsh
186 | ...
187 |     echo "Creating a zgen save"
188 | 
189 |     # prezto options
190 |     zgen prezto editor key-bindings 'emacs'
191 |     zgen prezto prompt theme 'sorin'
192 | 
193 |     # prezto and modules
194 |     zgen prezto
195 |     zgen prezto git
196 |     zgen prezto command-not-found
197 |     zgen prezto syntax-highlighting
198 | 
199 |     # plugins
200 |     zgen load /path/to/super-secret-private-plugin
201 | ....
202 | 
203 | ```
204 | 
205 | ## Other resources
206 | 
207 | The [awesome-zsh-plugins](https://github.com/unixorn/awesome-zsh-plugins) list contains many zgen-compatible zsh plugins & themes that you may find useful.
208 | 
209 | There's a quickstart kit for using zsh and zgen at [zsh-quickstart-kit](https://github.com/unixorn/zsh-quickstart-kit) that guides you through setting up zgen and includes a sampler of useful plugins.
210 | 
211 | The [autoupdate-zgen](https://github.com/unixorn/autoupdate-zgen) plugin will enable your zgen to periodically update itself and your list of plugins.
212 | 
213 | ## Alternatives
214 | 
215 | - [antigen](https://github.com/zsh-users/antigen) - popular and mature
216 | - [zplug](https://github.com/b4b4r07/zplug) - well performing and has a fancy UI
217 | 


--------------------------------------------------------------------------------
/_zgen:
--------------------------------------------------------------------------------
 1 | #compdef zgen
 2 | # ------------------------------------------------------------------------------
 3 | # Description
 4 | # -----------
 5 | #
 6 | #  Completion script for Zgen (https://github.com/tarjoilija/zgen)
 7 | #
 8 | # ------------------------------------------------------------------------------
 9 | # Authors
10 | # -------
11 | #
12 | #  * Martin Zeman (https://github.com/N4M3Z)
13 | #
14 | # ------------------------------------------------------------------------------
15 | 
16 | local -a _zgen_commands
17 | _zgen_commands=(
18 |     "clone:clone plugin from repository"
19 |     "completions:deprecated, please use load instead"
20 |     "list:print init.zsh"
21 |     "load:clone and load plugin"
22 |     "oh-my-zsh:load oh-my-zsh base"
23 |     "prezto:load prezto base"
24 |     "reset:delete the init.zsh script"
25 |     "save:check for init.zsh script"
26 |     "selfupdate:update zgen framework from repository"
27 |     "update:update all repositories and remove the init script"
28 | )
29 | 
30 | _describe -t commands "zgen subcommand" _zgen_commands
31 | return 0
32 | 


--------------------------------------------------------------------------------
/zgen.zsh:
--------------------------------------------------------------------------------
  1 | #!/bin/zsh
  2 | # vim: set ft=zsh fenc=utf-8 noai ts=8 et sts=4 sw=0 tw=80 nowrap :
  3 | local ZGEN_SOURCE="$0:A:h"
  4 | 
  5 | -zgputs() { printf %s\\n "$@" ;}
  6 | -zgpute() { printf %s\\n "-- zgen: $*" >&2 ;}
  7 | 
  8 | -zginit() { -zgputs "$*" >> "${ZGEN_INIT}" ;}
  9 | 
 10 | 
 11 | if [[ -z "${ZGEN_DIR}" ]]; then
 12 |     ZGEN_DIR="${HOME}/.zgen"
 13 | fi
 14 | 
 15 | if [[ -z "${ZGEN_INIT}" ]]; then
 16 |     ZGEN_INIT="${ZGEN_DIR}/init.zsh"
 17 | fi
 18 | 
 19 | # The user can explicitly disable Zgen attempting to invoke `compinit`, or it
 20 | # will be automatically disabled if `compinit` appears to have already been
 21 | # invoked.
 22 | if [[ -z "${ZGEN_AUTOLOAD_COMPINIT}" && -z "${(t)_comps}" ]]; then
 23 |     ZGEN_AUTOLOAD_COMPINIT=1
 24 | fi
 25 | 
 26 | if [[ -n "${ZGEN_CUSTOM_COMPDUMP}" ]]; then
 27 |     ZGEN_COMPINIT_DIR_FLAG="-d ${(q)ZGEN_CUSTOM_COMPDUMP}"
 28 |     ZGEN_COMPINIT_FLAGS="${ZGEN_COMPINIT_DIR_FLAG} ${ZGEN_COMPINIT_FLAGS}"
 29 | fi
 30 | 
 31 | if [[ -z "${ZGEN_LOADED}" ]]; then
 32 |     ZGEN_LOADED=()
 33 | fi
 34 | 
 35 | if [[ -z "${ZGEN_PREZTO_OPTIONS}" ]]; then
 36 |     ZGEN_PREZTO_OPTIONS=()
 37 | fi
 38 | 
 39 | if [[ -z "${ZGEN_PREZTO_LOAD}" ]]; then
 40 |     ZGEN_PREZTO_LOAD=()
 41 | fi
 42 | 
 43 | if [[ -z "${ZGEN_COMPLETIONS}" ]]; then
 44 |     ZGEN_COMPLETIONS=()
 45 | fi
 46 | 
 47 | if [[ -z "${ZGEN_USE_PREZTO}" ]]; then
 48 |     ZGEN_USE_PREZTO=0
 49 | fi
 50 | 
 51 | if [[ -z "${ZGEN_PREZTO_LOAD_DEFAULT}" ]]; then
 52 |     ZGEN_PREZTO_LOAD_DEFAULT=1
 53 | fi
 54 | 
 55 | if [[ -z "${ZGEN_OH_MY_ZSH_REPO}" ]]; then
 56 |     ZGEN_OH_MY_ZSH_REPO=robbyrussell
 57 | fi
 58 | 
 59 | if [[ "${ZGEN_OH_MY_ZSH_REPO}" != */* ]]; then
 60 |     ZGEN_OH_MY_ZSH_REPO="${ZGEN_OH_MY_ZSH_REPO}/oh-my-zsh"
 61 | fi
 62 | 
 63 | if [[ -z "${ZGEN_OH_MY_ZSH_BRANCH}" ]]; then
 64 |     ZGEN_OH_MY_ZSH_BRANCH=master
 65 | fi
 66 | 
 67 | if [[ -z "${ZGEN_PREZTO_REPO}" ]]; then
 68 |     ZGEN_PREZTO_REPO=sorin-ionescu
 69 | fi
 70 | 
 71 | if [[ "${ZGEN_PREZTO_REPO}" != */* ]]; then
 72 |     ZGEN_PREZTO_REPO="${ZGEN_PREZTO_REPO}/prezto"
 73 | fi
 74 | 
 75 | if [[ -z "${ZGEN_PREZTO_BRANCH}" ]]; then
 76 |     ZGEN_PREZTO_BRANCH=master
 77 | fi
 78 | 
 79 | -zgen-encode-url () {
 80 |     # Remove characters from a url that don't work well in a filename.
 81 |     # Inspired by -anti-get-clone-dir() method from antigen.
 82 |     local url="${1}"
 83 |     url="${url//\//-SLASH-}"
 84 |     url="${url//\:/-COLON-}"
 85 |     url="${url//\|/-PIPE-}"
 86 |     url="${url//~/-TILDE-}"
 87 |     -zgputs "$url"
 88 | }
 89 | 
 90 | -zgen-get-clone-dir() {
 91 |     local repo="${1}"
 92 |     local branch="${2:-master}"
 93 | 
 94 |     if [[ -e "${repo}/.git" ]]; then
 95 |         -zgputs "${ZGEN_DIR}/local/${repo:t}-${branch}"
 96 |     else
 97 |         # Repo directory will be location/reponame
 98 |         local reponame="${repo:t}"
 99 |         # Need to encode incase it is a full url with characters that don't
100 |         # work well in a filename.
101 |         local location="$(-zgen-encode-url ${repo:h})"
102 |         repo="${location}/${reponame}"
103 |         -zgputs "${ZGEN_DIR}/${repo}-${branch}"
104 |     fi
105 | }
106 | 
107 | -zgen-get-clone-url() {
108 |     local repo="${1}"
109 | 
110 |     if [[ -e "${repo}/.git" ]]; then
111 |         -zgputs "${repo}"
112 |     else
113 |         # Sourced from antigen url resolution logic.
114 |         # https://github.com/zsh-users/antigen/blob/master/antigen.zsh
115 |         # Expand short github url syntax: `username/reponame`.
116 |         if [[ $repo != git://* &&
117 |               $repo != https://* &&
118 |               $repo != http://* &&
119 |               $repo != ssh://* &&
120 |               $repo != git@*:*/*
121 |               ]]; then
122 |             repo="https://github.com/${repo%.git}.git"
123 |         fi
124 |         -zgputs "${repo}"
125 |     fi
126 | }
127 | 
128 | zgen-clone() {
129 |     local repo="${1}"
130 |     local branch="${2:-master}"
131 |     local url="$(-zgen-get-clone-url ${repo})"
132 |     local dir="$(-zgen-get-clone-dir ${repo} ${branch})"
133 | 
134 |     if [[ ! -d "${dir}" ]]; then
135 |         mkdir -p "${dir}"
136 |         git clone --depth=1 --recursive -b "${branch}" "${url}" "${dir}"
137 |     fi
138 | }
139 | 
140 | -zgen-add-to-fpath() {
141 |     local completion_path="${1}"
142 | 
143 |     # Add the directory to ZGEN_COMPLETIONS array if not present
144 |     if [[ ! "${ZGEN_COMPLETIONS[@]}" =~ ${completion_path} ]]; then
145 |         ZGEN_COMPLETIONS+=("${completion_path}")
146 |     fi
147 | }
148 | 
149 | -zgen-source() {
150 |     local file="${1}"
151 | 
152 |     if [[ ! "${ZGEN_LOADED[@]}" =~ "${file}" ]]; then
153 |         ZGEN_LOADED+=("${file}")
154 |         source "${file}"
155 | 
156 |         completion_path="${file:h}"
157 | 
158 |         -zgen-add-to-fpath "${completion_path}"
159 |     fi
160 | }
161 | 
162 | -zgen-prezto-option(){
163 |     local module=${1}
164 |     shift
165 |     local option=${1}
166 |     shift
167 |     local params
168 |     params=${@}
169 |     if [[ ${module} =~ "^:" ]]; then
170 |         module=${module[1,]}
171 |     fi
172 |     if [[ ! $module =~ "^(\*|module|prezto:module):" ]]; then
173 |         module="module:$module"
174 |     fi
175 |     if [[ ! $module =~ "^(prezto):" ]]; then
176 |         module="prezto:$module"
177 |     fi
178 |     local cmd="zstyle ':${module}' $option ${params}"
179 | 
180 |     # execute in place
181 |     eval $cmd
182 | 
183 |     if [[ ! "${ZGEN_PREZTO_OPTIONS[@]}" =~ "${cmd}" ]]; then
184 |         ZGEN_PREZTO_OPTIONS+=("${cmd}")
185 |     fi
186 | }
187 | 
188 | -zgen-prezto-load(){
189 |     local params="$*"
190 |     local cmd="pmodload ${params[@]}"
191 | 
192 |     # execute in place
193 |     eval $cmd
194 | 
195 |     if [[ ! "${ZGEN_PREZTO[@]}" =~ "${cmd}" ]]; then
196 |         ZGEN_PREZTO_LOAD+=("${params[@]}")
197 |     fi
198 | }
199 | 
200 | zgen-init() {
201 |     if [[ -f "${ZGEN_INIT}" ]]; then
202 |         source "${ZGEN_INIT}"
203 |     fi
204 | }
205 | 
206 | zgen-reset() {
207 |     -zgpute 'Deleting `'"${ZGEN_INIT}"'` ...'
208 |     if [[ -f "${ZGEN_INIT}" ]]; then
209 |         rm "${ZGEN_INIT}"
210 |     fi
211 |     if [[ -f "${ZGEN_CUSTOM_COMPDUMP}" ]] || [[ -d "${ZGEN_CUSTOM_COMPDUMP}" ]]; then
212 |         -zgpute 'Deleting `'"${ZGEN_CUSTOM_COMPDUMP}"'` ...'
213 |         rm -r "${ZGEN_CUSTOM_COMPDUMP}"
214 |     fi
215 | }
216 | 
217 | zgen-update() {
218 |     setopt localoptions extended_glob
219 |     for repo in "${ZGEN_DIR}"/(^.git)/*; do
220 |         -zgpute "Updating '${repo}' ..."
221 |         (cd "${repo}" \
222 |             && git pull \
223 |             && git submodule update --init --recursive)
224 |     done
225 |     zgen-reset
226 | }
227 | 
228 | zgen-save() {
229 |     -zgpute 'Creating `'"${ZGEN_INIT}"'` ...'
230 | 
231 |     -zgputs "# {{{" >! "${ZGEN_INIT}"
232 |     -zginit "# Generated by zgen."
233 |     -zginit "# This file will be overwritten the next time you run zgen save!"
234 |     -zginit ""
235 |     -zginit "ZSH=$(-zgen-get-zsh)"
236 |     if [[ ${ZGEN_USE_PREZTO} == 1 ]]; then
237 |         -zginit ""
238 |         -zginit "# ### Prezto initialization"
239 |         for option in "${ZGEN_PREZTO_OPTIONS[@]}"; do
240 |             -zginit "${option}"
241 |         done
242 |     fi
243 | 
244 |     -zginit ""
245 |     -zginit "# ### General modules"
246 |     for file in "${ZGEN_LOADED[@]}"; do
247 |         -zginit 'source "'"${(q)file}"\"
248 |     done
249 | 
250 |     # Set up fpath, load completions
251 |     # NOTE: This *intentionally* doesn't use ${ZGEN_COMPINIT_FLAGS}; the only
252 |     #       available flags are meaningless in the presence of `-C`.
253 |     -zginit ""
254 |     -zginit "# ### Plugins & Completions"
255 |     -zginit 'fpath=('"${(@q)ZGEN_COMPLETIONS}"' ${fpath})'
256 |     if [[ ${ZGEN_AUTOLOAD_COMPINIT} == 1 ]]; then
257 |         -zginit ""
258 |         -zginit 'autoload -Uz compinit && \'
259 |         -zginit '   compinit -C '"${ZGEN_COMPINIT_DIR_FLAG}"
260 |     fi
261 | 
262 |     # Check for file changes
263 |     if [[ ! -z "${ZGEN_RESET_ON_CHANGE}" ]]; then
264 |         -zginit ""
265 |         -zginit "# ### Recompilation triggers"
266 | 
267 |         local ages="$(stat -Lc "%Y" 2>/dev/null $ZGEN_RESET_ON_CHANGE || \
268 |                       stat -Lf "%m" 2>/dev/null $ZGEN_RESET_ON_CHANGE)"
269 |         local shas="$(cksum ${ZGEN_RESET_ON_CHANGE})"
270 | 
271 |         -zginit "read -rd '' ages <<AGES; read -rd '' shas <<SHAS"
272 |         -zginit "$ages"
273 |         -zginit "AGES"
274 |         -zginit "$shas"
275 |         -zginit "SHAS"
276 | 
277 |         -zginit 'if [[ -n "$ZGEN_RESET_ON_CHANGE" \'
278 |         -zginit '   && "$(stat -Lc "%Y" 2>/dev/null $ZGEN_RESET_ON_CHANGE || \'
279 |         -zginit '         stat -Lf "%m"             $ZGEN_RESET_ON_CHANGE)" != "$ages" \'
280 |         -zginit '   && "$(cksum                     $ZGEN_RESET_ON_CHANGE)" != "$shas" ]]; then'
281 |         -zginit '   printf %s\\n '\''-- zgen: Files in $ZGEN_RESET_ON_CHANGE changed; resetting `init.zsh`...'\'
282 |         -zginit '   zgen reset'
283 |         -zginit 'fi'
284 |     fi
285 | 
286 |     # load prezto modules
287 |     if [[ ${ZGEN_USE_PREZTO} == 1 ]]; then
288 |         -zginit ""
289 |         -zginit "# ### Prezto modules"
290 |         printf %s "pmodload" >> "${ZGEN_INIT}"
291 |         for module in "${ZGEN_PREZTO_LOAD[@]}"; do
292 |             printf %s " ${module}" >> "${ZGEN_INIT}"
293 |         done
294 |     fi
295 | 
296 |     -zginit ""
297 |     -zginit "# }}}"
298 | 
299 |     zgen-apply
300 | }
301 | 
302 | zgen-apply() {
303 |     fpath=(${(q)ZGEN_COMPLETIONS[@]} ${fpath})
304 | 
305 |     if [[ ${ZGEN_AUTOLOAD_COMPINIT} == 1 ]]; then
306 |         -zgpute "Initializing completions ..."
307 | 
308 |         autoload -Uz compinit && \
309 |             compinit $ZGEN_COMPINIT_FLAGS
310 |     fi
311 | }
312 | 
313 | -zgen-path-contains() {
314 |     setopt localoptions nonomatch nocshnullglob nonullglob;
315 |     [ -e "$1"/*"$2"(.,@[1]) ]
316 | }
317 | 
318 | -zgen-get-zsh(){
319 |     if [[ ${ZGEN_USE_PREZTO} == 1 ]]; then
320 |         -zgputs "$(-zgen-get-clone-dir "$ZGEN_PREZTO_REPO" "$ZGEN_PREZTO_BRANCH")"
321 |     else
322 |         -zgputs "$(-zgen-get-clone-dir "$ZGEN_OH_MY_ZSH_REPO" "$ZGEN_OH_MY_ZSH_BRANCH")"
323 |     fi
324 | }
325 | 
326 | zgen-load() {
327 |     if [[ "$#" == 0 ]]; then
328 |         -zgpute '`load` requires at least one parameter:'
329 |         -zgpute '`zgen load <repo> [location] [branch]`'
330 |     elif [[ "$#" == 1 && ("${1[1]}" == '/' || "${1[1]}" == '.' ) ]]; then
331 |         local location="${1}"
332 |     else
333 |         local repo="${1}"
334 |         local file="${2}"
335 |         local branch="${3:-master}"
336 |         local dir="$(-zgen-get-clone-dir ${repo} ${branch})"
337 |         local location="${dir}/${file}"
338 |         location=${location%/}
339 | 
340 |         # clone repo if not present
341 |         if [[ ! -d "${dir}" ]]; then
342 |             zgen-clone "${repo}" "${branch}"
343 |         fi
344 |     fi
345 | 
346 |     # source the file
347 |     if [[ -f "${location}" ]]; then
348 |         -zgen-source "${location}"
349 | 
350 |     # Prezto modules have init.zsh files
351 |     elif [[ -f "${location}/init.zsh" ]]; then
352 |         -zgen-source "${location}/init.zsh"
353 | 
354 |     elif [[ -f "${location}.zsh-theme" ]]; then
355 |         -zgen-source "${location}.zsh-theme"
356 | 
357 |     elif [[ -f "${location}.theme.zsh" ]]; then
358 |         -zgen-source "${location}.theme.zsh"
359 | 
360 |     elif [[ -f "${location}.zshplugin" ]]; then
361 |         -zgen-source "${location}.zshplugin"
362 | 
363 |     elif [[ -f "${location}.zsh.plugin" ]]; then
364 |         -zgen-source "${location}.zsh.plugin"
365 | 
366 |     # Classic oh-my-zsh plugins have foo.plugin.zsh
367 |     elif -zgen-path-contains "${location}" ".plugin.zsh" ; then
368 |         for script (${location}/*\.plugin\.zsh(N)) -zgen-source "${script}"
369 | 
370 |     elif -zgen-path-contains "${location}" ".zsh" ; then
371 |         for script (${location}/*\.zsh(N)) -zgen-source "${script}"
372 | 
373 |     elif -zgen-path-contains "${location}" ".sh" ; then
374 |         for script (${location}/*\.sh(N)) -zgen-source "${script}"
375 | 
376 |     # Completions
377 |     elif [[ -d "${location}" ]]; then
378 |         -zgen-add-to-fpath "${location}"
379 | 
380 |     else
381 |       if [[ -d ${dir:-$location} ]]; then
382 |         -zgpute "Failed to load ${dir:-$location} -- ${file}"
383 |       else
384 |         -zgpute "Failed to load ${dir:-$location}"
385 |       fi
386 |     fi
387 | }
388 | 
389 | zgen-loadall() {
390 |     # shameless copy from antigen
391 | 
392 |     # Bulk add many bundles at one go. Empty lines and lines starting with a `#`
393 |     # are ignored. Everything else is given to `zgen-load` as is, no
394 |     # quoting rules applied.
395 | 
396 |     local line
397 | 
398 |     grep '^[[:space:]]*[^[:space:]#]' | while read line; do
399 |         # Using `eval` so that we can use the shell-style quoting in each line
400 |         # piped to `antigen-bundles`.
401 |         eval "zgen-load $line"
402 |     done
403 | }
404 | 
405 | zgen-saved() {
406 |     [[ -f "${ZGEN_INIT}" ]] && return 0 || return 1
407 | }
408 | 
409 | zgen-list() {
410 |     if [[ -f "${ZGEN_INIT}" ]]; then
411 |         cat "${ZGEN_INIT}"
412 |     else
413 |         -zgpute '`init.zsh` missing, please use `zgen save` and then restart your shell.'
414 |         return 1
415 |     fi
416 | }
417 | 
418 | zgen-selfupdate() {
419 |     if [[ -e "${ZGEN_SOURCE}/.git" ]]; then
420 |         (cd "${ZGEN_SOURCE}" \
421 |             && git pull) \
422 |             && zgen reset
423 |     else
424 |         -zgpute "Not running from a git repository; cannot automatically update."
425 |         return 1
426 |     fi
427 | }
428 | 
429 | zgen-oh-my-zsh() {
430 |     local repo="$ZGEN_OH_MY_ZSH_REPO"
431 |     local file="${1:-oh-my-zsh.sh}"
432 | 
433 |     zgen-load "${repo}" "${file}"
434 | }
435 | 
436 | zgen-prezto() {
437 |     local repo="$ZGEN_PREZTO_REPO"
438 |     local file="${1:-init.zsh}"
439 | 
440 |     # load prezto itself
441 |     if [[ $# == 0 ]]; then
442 |         ZGEN_USE_PREZTO=1
443 |         zgen-load "${repo}" "${file}"
444 |         if [[ ${ZGEN_PREZTO_LOAD_DEFAULT} != 0 ]]; then
445 |             -zgen-prezto-load "'environment' 'terminal' 'editor' 'history' 'directory' 'spectrum' 'utility' 'completion' 'prompt'"
446 |         fi
447 | 
448 |     # this is a prezto module
449 |     elif [[ $# == 1 ]]; then
450 |         local module=${file}
451 |         if [[ -z ${file} ]]; then
452 |             -zgpute 'Please specify which module to load using `zgen prezto <name of module>`'
453 |             return 1
454 |         fi
455 |         -zgen-prezto-load "'$module'"
456 | 
457 |     # this is a prezto option
458 |     else
459 |         shift
460 |         -zgen-prezto-option ${file} ${(qq)@}
461 |     fi
462 | 
463 | }
464 | 
465 | zgen-pmodule() {
466 |     local repo="${1}"
467 |     local branch="${2:-master}"
468 | 
469 |     local dir="$(-zgen-get-clone-dir ${repo} ${branch})"
470 | 
471 |     # clone repo if not present
472 |     if [[ ! -d "${dir}" ]]; then
473 |         zgen-clone "${repo}" "${branch}"
474 |     fi
475 | 
476 |     local module="${repo:t}"
477 |     -zgen-prezto-load "'${module}'"
478 | }
479 | 
480 | zgen() {
481 |     local cmd="${1}"
482 |     if [[ -z "${cmd}" ]]; then
483 |         -zgputs 'usage: `zgen [command | instruction] [options]`'
484 |         -zgputs "    commands: list, saved, reset, clone, update, selfupdate"
485 |         -zgputs "    instructions: load, oh-my-zsh, pmodule, prezto, save, apply"
486 |         return 1
487 |     fi
488 | 
489 |     shift
490 | 
491 |     if functions "zgen-${cmd}" > /dev/null ; then
492 |         "zgen-${cmd}" "${@}"
493 |     else
494 |         -zgpute 'Command not found: `'"${cmd}"\`
495 |         return 1
496 |     fi
497 | }
498 | 
499 | ZSH=$(-zgen-get-zsh)
500 | fpath=($ZGEN_SOURCE $fpath)
501 | zgen-init
502 | 


--------------------------------------------------------------------------------