v1.13.1

as it's not compatible with BSD distributions.
Fixes #534

CHANGELOG.md

@@ -9,6 +9,162 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 _No unreleased changes._
 
+## [1.13.1] - 2024-04-28
+
+### Fixed
+
+- The `--strip` option in tar command is not BSD compatible.
+
+## [1.13.0] - 2024-02-17
+
+### Added
+
+- `--if-command` option to zmodule. This option is equivalent to
+  `--if "(( \${+commands[${1}]} ))"`.
+- `mkdir` tool option in `zmodule` that creates an empty directory. This allows
+  creating modules that contain only externally generated files.
+
+## [1.12.1] - 2023-09-16
+
+### Fixed
+
+- Expansion of prompt sequences in print statements causing text between
+  backticks to be executed by the shell.
+
+## [1.12.0] - 2023-07-17
+
+### Added
+
+- `check-version` action, that immediately checks if a new version of `zimfw` is
+  available and returns code 4 if there is one.
+- `check` action, that checks if there are updates available for current modules.
+- Output of `LANG` and `LC_*` parameters in `info` action.
+
+### Changed
+
+- Don't resolve symlinks when building init.zsh.
+
+### Fixed
+
+- Show warning when there's no write permission to compile Zsh scripts.
+
+## [1.11.3] - 2023-02-26
+
+### Deprecated
+
+- `check-dumpfile` action. The [completion] module alone now handles
+  checking the dumpfile. (See
+  [zimfw/completion#12](https://github.com/zimfw/completion/pull/12))
+
+## [1.11.2] - 2023-02-16
+
+### Fixed
+
+- Quote path names in init.zsh to properly handle path names with spaces.
+
+## [1.11.1] - 2023-02-04
+
+### Fixed
+
+- Use `_zim_dumpfile_fpath` defined by the completion module
+  [here](https://github.com/zimfw/completion/blob/33737e8c15fa8dba9af47bef8408b1af2599c21b/init.zsh#L11),
+  right before `compinit` is run, to more accurately do `zimfw check-dumpfile`.
+
+## [1.11.0] - 2022-12-18
+
+### Added
+
+- `--if` option to `zmodule` that will only initialize the module root if the
+  specified test returns a zero exit status. The test is evaluated at every new
+  terminal startup.
+- Ability to customize the .zimrc file name and path with the `ZIM_CONFIG_FILE`
+  environment variable.
+
+## [1.10.0] - 2022-09-27
+
+### Added
+
+- `--root` option to `zmodule`. Combined with the ability to call `zmodule`
+  multiple times for the same module, this allows initializing from multiple
+  roots in repositories like prezto or ohmyzsh. Also, `--on-pull` and `--disable`
+  now work on a per-module-root basis.
+
+### Changed
+
+- Show `OSTYPE`, `TERM`, `TERM_PROGRAM` and `TERM_PROGRAM_VERSION` environment
+  variables instead of calling the `uname -a` command to show system info in the
+  `zimfw info` action.
+
+## [1.9.1] - 2022-05-24
+
+### Fixed
+
+- Override repository options along multiple `zmodule` calls with the same
+  module name.
+- Show already installed modules skipped with install action and `-v`.
+- Consider external module directory paths when calling compile action directly.
+- Ignore return value from `zargs` with `-P`.
+  (See https://www.zsh.org/mla/workers/2022/msg00611.html)
+
+## [1.9.0] - 2022-05-09
+
+### Added
+
+- `--on-pull` option to `zmodule`, which allows setting a command that is always
+  triggered after the module is installed or updated.
+
+## [1.8.0] - 2022-01-25
+
+### Added
+
+- `check-dumpfile` action. It runs in the build, install and update actions, and
+  checks if a new completion configuration needs to be dumped. It's intended to
+  be used with `compinit -C`, so no checks are done during the shell startup.
+  (See [zimfw/completion#8](https://github.com/zimfw/completion/pull/8))
+- `--no-submodules` option to `zmodule`, which disables installing or updating
+  git submodules.
+
+## [1.7.0] - 2022-01-12
+
+### Changed
+
+- The output of `zimfw init` to be friendlier to the terminal startup screen
+  when called without `-q`.
+- Only compile scripts via the `zimfw` tool after actions where scripts can
+  change (build, install, update, upgrade).
+- Move compilation of the completion dumpfile to the completion module,
+  [here](https://github.com/zimfw/completion/blob/9386a76eac3f55b1c04d57d26238f725b4b3ba25/init.zsh#L10-L11).
+- Don't compile user Zsh startup scripts anymore
+  (See [#450](https://github.com/zimfw/zimfw/pull/450)). This means you can:
+  - either manually delete the compiled files, as they won't be updated by Zim
+    anymore (recommended):
+    ```
+    for zfile in ${ZDOTDIR:-${HOME}}/.z(shenv|profile|shrc|login|logout); do
+      rm -f ${zfile}.zwc(|.old)(N)
+    done
+    ```
+  - or add the following to your .zlogin so Zsh startup scripts continue to be
+    compiled:
+    ```diff
+    +for zfile in ${ZDOTDIR:-${HOME}}/.z(shenv|profile|shrc|login|logout); do
+    +  if [[ ! ${zfile}.zwc -nt ${zfile} ]] zcompile -R ${zfile}
+    +done
+    +unset zfile
+    ```
+
+### Deprecated
+- The login_init.zsh script, which is now empty. This means you can safely
+  remove the following line from your .zlogin:
+  ```diff
+  -source ${ZIM_HOME}/login_init.zsh -q &!
+  ```
+
+## [1.6.2] - 2021-11-21
+
+### Fixed
+- Force local zsh emulation options, so the code is not broken by unexpected
+  option changes by the user.
+
 ## [1.6.1] - 2021-11-08
 
 ### Fixed
@@ -212,6 +368,7 @@ Take your time to review the updated [README.md] and the changes listed below.
 - `ZIM_HOME` is set in .zshenv instead of .zshrc. The issue was that the
   variable was not available in .zlogin in non-interactive login shells.
 
+[completion]: https://github.com/zimfw/completion
 [README.md]: https://github.com/zimfw/zimfw/blob/master/README.md
 [environment]: https://github.com/zimfw/environment
 [input]: https://github.com/zimfw/input
@@ -219,7 +376,20 @@ Take your time to review the updated [README.md] and the changes listed below.
 [termtitle]: https://github.com/zimfw/termtitle
 [s1ck94]: https://github.com/zimfw/s1ck94
 
-[Unreleased]: https://github.com/zimfw/zimfw/compare/v1.6.1...HEAD
+[Unreleased]: https://github.com/zimfw/zimfw/compare/v1.13.0...HEAD
+[1.13.0]: https://github.com/zimfw/zimfw/compare/v1.12.1...v1.13.0
+[1.12.1]: https://github.com/zimfw/zimfw/compare/v1.12.0...v1.12.1
+[1.12.0]: https://github.com/zimfw/zimfw/compare/v1.11.3...v1.12.0
+[1.11.3]: https://github.com/zimfw/zimfw/compare/v1.11.2...v1.11.3
+[1.11.2]: https://github.com/zimfw/zimfw/compare/v1.11.1...v1.11.2
+[1.11.1]: https://github.com/zimfw/zimfw/compare/v1.11.0...v1.11.1
+[1.11.0]: https://github.com/zimfw/zimfw/compare/v1.10.0...v1.11.0
+[1.10.0]: https://github.com/zimfw/zimfw/compare/v1.9.1...v1.10.0
+[1.9.1]: https://github.com/zimfw/zimfw/compare/v1.9.0...v1.9.1
+[1.9.0]: https://github.com/zimfw/zimfw/compare/v1.8.0...v1.9.0
+[1.8.0]: https://github.com/zimfw/zimfw/compare/v1.7.0...v1.8.0
+[1.7.0]: https://github.com/zimfw/zimfw/compare/v1.6.2...v1.7.0
+[1.6.2]: https://github.com/zimfw/zimfw/compare/v1.6.1...v1.6.2
 [1.6.1]: https://github.com/zimfw/zimfw/compare/v1.6.0...v1.6.1
 [1.6.0]: https://github.com/zimfw/zimfw/compare/v1.5.0...v1.6.0
 [1.5.0]: https://github.com/zimfw/zimfw/compare/v1.4.3...v1.5.0

LICENSE

@@ -1,7 +1,7 @@
 MIT License
 
 Copyright (c) 2015-2016 Matt Hamilton and contributors
-Copyright (c) 2016-2021 Eric Nielsen, Matt Hamilton and contributors
+Copyright (c) 2016-2024 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

README.md

@@ -1,3 +1,13 @@
+<p align="center">
+  <a href="https://github.com/zimfw/zimfw/releases"><img src="https://img.shields.io/github/v/release/zimfw/zimfw"></a>
+  <a href="https://github.com/zimfw/zimfw/issues"><img src="https://img.shields.io/github/issues/zimfw/zimfw.svg"></a>
+  <a href="https://github.com/zimfw/zimfw/network/members"><img src="https://img.shields.io/github/forks/zimfw/zimfw.svg"></a>
+  <a href="https://github.com/zimfw/zimfw/stargazers"><img src="https://img.shields.io/github/stars/zimfw/zimfw.svg"></a>
+  <a href="https://github.com/zimfw/zimfw/releases"><img src="https://img.shields.io/github/downloads/zimfw/zimfw/total.svg"></a>
+  <a href="https://github.com/zimfw/zimfw/discussions"><img src="https://img.shields.io/badge/forum-online-green.svg"></a>
+  <a href="https://github.com/zimfw/zimfw/blob/master/LICENSE"><img alt="GitHub" src="https://img.shields.io/github/license/zimfw/zimfw"></a>
+</p>
+
 <div align="center">
   <a href="https://github.com/zimfw/zimfw">
     <img width="600" src="https://zimfw.github.io/images/zimfw-banner@2.jpg">
@@ -6,169 +16,305 @@
 
 What is Zim?
 ------------
-Zim is a Zsh configuration framework with [blazing speed] and modular extensions.
+Zim is a Zsh configuration framework that bundles a [plugin manager](#usage),
+useful [modules], and a wide variety of [themes], without compromising on [speed].
 
-Zim bundles useful [modules], a wide variety of [themes], and plenty of
-customizability without compromising on speed.
+Check how Zim compares to other frameworks and plugin managers:
 
-What does Zim offer?
---------------------
-Below is a brief showcase of Zim's features.
-
-### Speed
 <a href="https://github.com/zimfw/zimfw/wiki/Speed">
   <img src="https://zimfw.github.io/images/results.svg">
 </a>
 
-For more details, see [this wiki entry][blazing speed].
-
-### Modules
-
-Zim has many [modules available][modules]. Enable as many or as few as you'd like.
-
-### Themes
-
-To preview some of the available themes, check the [themes page][themes].
-
-### Degit
-
-Install modules without requiring `git` using our degit tool. It's faster and
-lighter than `git`. See the [zmodule](#zmodule-usage) usage below.
+Table of Contents
+-----------------
+* [Installation](#installation)
+  * [Automatic installation](#automatic-installation)
+  * [Manual installation](#manual-installation)
+    * [Set up `~/.zshrc`](#set-up-zshrc)
+    * [Create `~/.zimrc`](#create-zimrc)
+* [Usage](#usage)
+  * [`zmodule`](#zmodule)
+  * [`zimfw`](#zimfw)
+* [Settings](#settings)
+* [Uninstalling](#uninstalling)
 
 Installation
 ------------
-Installing Zim is easy:
+Installing Zim is easy. You can choose either the automatic or manual method below:
 
-  * With curl:
+### Automatic installation
 
-        curl -fsSL https://raw.githubusercontent.com/zimfw/install/master/install.zsh | zsh
+This will install a predefined set of modules and a theme for you.
 
-  * With wget:
+* With `curl`:
 
-        wget -nv -O - https://raw.githubusercontent.com/zimfw/install/master/install.zsh | zsh
+      curl -fsSL https://raw.githubusercontent.com/zimfw/install/master/install.zsh | zsh
 
-Open a new terminal and you're done. Enjoy your Zsh IMproved! Take some time to
-tweak your `~/.zshrc` file, and to also check the available [modules] and [themes]
-you can add to your `~/.zimrc`.
+* With `wget`:
 
-<details>
-<summary>Prefer to install manually?</summary>
+      wget -nv -O - https://raw.githubusercontent.com/zimfw/install/master/install.zsh | zsh
+
+Restart your terminal and you're done. Enjoy your Zsh IMproved! Take some time
+to tweak your [`~/.zshrc`](#set-up-zshrc) file, and to also check the available
+[modules] and [themes] you can add to your [`~/.zimrc`](#create-zimrc).
 
 ### Manual installation
 
-1. Set Zsh as the default shell:
+1. Set Zsh as the default shell, if you haven't done so already:
+    ```zsh
+    chsh -s $(which zsh)
+    ````
 
-       chsh -s $(which zsh)
+2. [Set up your `~/.zshrc` file](#set-up-zshrc)
 
-2. Prepend the lines in the following templates to the respective dot files:
-   * [~/.zshenv](https://raw.githubusercontent.com/zimfw/install/master/src/templates/zshenv)
-   * [~/.zshrc](https://raw.githubusercontent.com/zimfw/install/master/src/templates/zshrc)
-   * [~/.zlogin](https://raw.githubusercontent.com/zimfw/install/master/src/templates/zlogin)
-   * [~/.zimrc](https://raw.githubusercontent.com/zimfw/install/master/src/templates/zimrc)
+3. [Create your `~/.zimrc` file](#create-zimrc)
 
-3. Restart your terminal to automatically install the modules defined in `~/.zimrc`
-   and build the initialization scripts.
+4. Restart your terminal and you're done. Enjoy your Zsh IMproved!
 
-</details>
+#### Set up `~/.zshrc`
+
+Add the lines below to your `~/.zshrc` file, in the following order:
+
+1. To use our `degit` tool by default to install modules:
+   ```zsh
+   zstyle ':zim:zmodule' use 'degit'
+   ````
+   This is optional, and only required if you don't have `git` installed (yes,
+   Zim works even without `git`!)
+
+2. To set where the directory used by Zim will be located:
+   ```zsh
+   ZIM_HOME=~/.zim
+   ```
+   The value of `ZIM_HOME` can be any directory your user has write access to.
+   You can even set it to a cache directory like `${XDG_CACHE_HOME}/zim` or
+   `~/.cache/zim` if you also include the step below, that automatically
+   downloads the `zimfw` plugin manager.
+
+3. To automatically download the `zimfw` plugin manager if missing:
+   ```zsh
+   # Download zimfw plugin manager if missing.
+   if [[ ! -e ${ZIM_HOME}/zimfw.zsh ]]; then
+     curl -fsSL --create-dirs -o ${ZIM_HOME}/zimfw.zsh \
+         https://github.com/zimfw/zimfw/releases/latest/download/zimfw.zsh
+   fi
+   ```
+   Or if you use `wget` instead of `curl`:
+   ```zsh
+   # Download zimfw plugin manager if missing.
+   if [[ ! -e ${ZIM_HOME}/zimfw.zsh ]]; then
+     mkdir -p ${ZIM_HOME} && wget -nv -O ${ZIM_HOME}/zimfw.zsh \
+         https://github.com/zimfw/zimfw/releases/latest/download/zimfw.zsh
+   fi
+   ```
+   This is optional. If you choose to not include this step, you should manually
+   download the `zimfw.zsh` script once and keep it at `${ZIM_HOME}`.
+
+4. To automatically install missing modules and update the static initialization
+   script if missing or outdated:
+   ```zsh
+   # Install missing modules, and update ${ZIM_HOME}/init.zsh if missing or outdated.
+   if [[ ! ${ZIM_HOME}/init.zsh -nt ${ZDOTDIR:-${HOME}}/.zimrc ]]; then
+     source ${ZIM_HOME}/zimfw.zsh init -q
+   fi
+   ```
+   This step is optional, but highly recommended. If you choose to not include
+   it, you must remember to manually run `zimfw install` every time after you
+   update your [`~/.zimrc`](#create-zimrc) file.
+
+5. To source the static script, that will initialize your modules:
+   ```zsh
+   # Initialize modules.
+   source ${ZIM_HOME}/init.zsh
+   ```
+
+#### Create `~/.zimrc`
+
+You must create your `.zimrc` file at `~/.zimrc`, if the `ZDOTDIR` environment
+variable is not defined. Otherwise, it must be at `${ZDOTDIR}/.zimrc`. It's
+referred to as `~/.zimrc` in the documentation for the sake of simplicity.
+
+You can start with just:
+```zsh
+zmodule zsh-users/zsh-syntax-highlighting
+zmodule zsh-users/zsh-autosuggestions
+```
+
+If you also want one of our prompt [themes]:
+```
+zmodule asciiship
+zmodule zsh-users/zsh-syntax-highlighting
+zmodule zsh-users/zsh-autosuggestions
+```
+
+If you want to use our [completion] module too, instead of using `compinit` directly:
+```zsh
+zmodule asciiship
+zmodule zsh-users/zsh-completions --fpath src
+zmodule completion
+zmodule zsh-users/zsh-syntax-highlighting
+zmodule zsh-users/zsh-autosuggestions
+```
+The [completion] module calls `compinit` for you. You should remove any
+`compinit` calls from your `~/.zshrc` when you use this module. The modules will
+be initialized in the order they are defined, and [completion] must be
+initialized *after* all modules that add completion definitions, so it must come
+after [zsh-users/zsh-completions].
+
+Check the [`zmodule` usage](#zmodule) below for more examples on how to use it to
+define the modules you want to use.
 
 Usage
 -----
+The `zimfw` plugin manager installs your modules at `${ZIM_HOME}/modules`, and
+builds a static script at `${ZIM_HOME}/init.zsh` that will initialize them. Your
+modules are defined in your `~/.zimrc` file.
 
-Add `zmodule` calls to your `~/.zimrc` file to define the modules to be
-initialized, then run `zimfw install` to install them.
+The `~/.zimrc` file must contain `zmodule` calls to define the modules to be
+initialized. The initialization will be done in the same order it's defined.
+
+The `~/.zimrc` file is not sourced during Zsh startup, and it's only used to
+configure the `zimfw` plugin manager.
+
+Check [examples of `~/.zimrc` files](#create-zimrc) above.
 
 ### zmodule
 
-Below are some usage examples.
+Below are some usage examples:
 
-A module from the [zimfw] organization: `zmodule archive`
-
-A module from another GitHub organization: `zmodule StackExchange/blackbox`
-
-A module not from GitHub: `zmodule https://gitlab.com/Spriithy/basher.git`
-
-A module at an absolute path, that is already installed:
-`zmodule /usr/local/share/zsh-autosuggestions`
-
-A module with a custom fpath: `zmodule zsh-users/zsh-completions --fpath src`
-
-A module with a custom initialization file name:
-`zmodule spaceship-prompt/spaceship-prompt --source spaceship.zsh` or
-`zmodule spaceship-prompt/spaceship-prompt --name spaceship`
-
-A module with two custom initialization files:
-`zmodule sindresorhus/pure --source async.zsh --source pure.zsh`
-
-A module with custom initialization commands:
-`zmodule skywind3000/z.lua --cmd 'export _ZL_HYPHEN=1' --cmd 'eval "$(lua {}/z.lua --init zsh enhanced once)"'`
-
-A module with a big git repository: `zmodule romkatv/powerlevel10k --use degit`
-<!-- As of 2021-11-06, the complete repo had 83M and took 1m59s to be cloned,
-and the degit'ed module had 2.9M and took 3s to be installed. -->
+  * A module from the [@zimfw] organization: `zmodule archive`
+  * A module from another GitHub organization: `zmodule StackExchange/blackbox`
+  * A module with a custom URL: `zmodule https://gitlab.com/Spriithy/basher.git`
+  * A module at an absolute path, that is already installed:
+    `zmodule /usr/local/share/zsh-autosuggestions`
+  * A module with a custom fpath: `zmodule zsh-users/zsh-completions --fpath src`
+  * A module with a custom initialization file, and with git submodules disabled:
+    `zmodule spaceship-prompt/spaceship-prompt --source spaceship.zsh --no-submodules` or
+    `zmodule spaceship-prompt/spaceship-prompt --name spaceship --no-submodules`
+  * A module with two custom initialization files:
+    `zmodule sindresorhus/pure --source async.zsh --source pure.zsh`. Separate
+    zmodule calls can also be used. In this equivalent example, the second call
+    automatically discovers the second file to be sourced:
+    ```
+    zmodule sindresorhus/pure --source async.zsh
+    zmodule sindresorhus/pure
+    ```
+  * A module with a custom initialization command:
+    `zmodule skywind3000/z.lua --cmd 'eval "$(lua {}/z.lua --init zsh enhanced once)"'`
+  * A module with an on-pull command. It can be used to create a cached initialization script:
+    `zmodule skywind3000/z.lua --on-pull 'lua z.lua --init zsh enhanced once >! init.zsh'`
+  * A module with a big git repository: `zmodule romkatv/powerlevel10k --use degit`
+  * A module with a custom root subdirectory: `zmodule ohmyzsh/ohmyzsh --root plugins/vim-interaction`
+  * A module with multiple roots:
+    ```
+    zmodule sorin-ionescu/prezto --root modules/command-not-found
+    zmodule sorin-ionescu/prezto --root modules/gnu-utility
+    ```
+    or
+    ```
+    zmodule ohmyzsh/ohmyzsh --root plugins/perl
+    zmodule ohmyzsh/ohmyzsh --root plugins/vim-interaction
+    ```
 
 <details id="zmodule-usage">
 <summary>Want help with the complete <code>zmodule</code> usage?</summary>
 
-<pre>Usage: <b>zmodule</b> &lt;url&gt; [<b>-n</b>|<b>--name</b> &lt;module_name&gt;] [options]
+<pre>Usage: <b>zmodule</b> &lt;url&gt; [<b>-n</b>|<b>--name</b> &lt;module_name&gt;] [<b>-r</b>|<b>--root</b> &lt;path&gt;] [options]
 
-Add <b>zmodule</b> calls to your <b>~/.zimrc</b> file to define the modules to be initialized. The modules are
-initialized in the same order they are defined.
+Add <b>zmodule</b> calls to your <b>~/.zimrc</b> file to define the modules to be initialized. The initiali-
+zation will be done in the same order it&apos;s defined.
 
   &lt;url&gt;                      Module absolute path or repository URL. The following URL formats
-                             are equivalent: <b>name</b>, <b>zimfw/name</b>, <b>https://github.com/zimfw/name.git</b>.
-  <b>-n</b>|<b>--name</b> &lt;module_name&gt;    Set a custom module name. Default: the last component in the &lt;url&gt;.
-                             Use slashes inside the name to organize the module into subdirecto-
-                             ries.
+                             are equivalent: <b>foo</b>, <b>zimfw/foo</b>, <b>https://github.com/zimfw/foo.git</b>.
+                             If an absolute path is given, the module is considered externally
+                             installed and won&apos;t be installed or updated by zimfw.
+  <b>-n</b>|<b>--name</b> &lt;module_name&gt;    Set a custom module name. Default: the last component in &lt;url&gt;.
+                             Slashes can be used inside the name to organize the module into
+                             subdirectories. The module will be installed at
+                             <b>${ZIM_HOME}/</b>&lt;module_name&gt;.
+  <b>-r</b>|<b>--root</b> &lt;path&gt;           Relative path to the module root.
 
-Repository options:
+Per-module options:
   <b>-b</b>|<b>--branch</b> &lt;branch_name&gt;  Use specified branch when installing and updating the module.
-                             Overrides the tag option. Default: the repository&apos;s default branch.
-  <b>-t</b>|<b>--tag</b> &lt;tag_name&gt;        Use specified tag when installing and updating the module.
-                             Overrides the branch option.
-  <b>-u</b>|<b>--use</b> &lt;<b>git</b>|<b>degit</b>&gt;       Install and update the module using the defined tool. Default is
-                             defined by <b>zstyle &apos;:zim:zmodule&apos; use &apos;</b>&lt;<b>git</b>|<b>degit</b>&gt;<b>&apos;</b>, or <b>git</b> if none
-                             is provided.
-                             <b>git</b> requires git itself. Local changes are preserved during updates.
-                             <b>degit</b> requires curl or wget, and currently only works with GitHub
-                             URLs. Modules install faster and take less disk space. Local changes
-                             are lost during updates. Git submodules are not supported.
+                             Overrides the tag option. Default: the repository default branch.
+  <b>-t</b>|<b>--tag</b> &lt;tag_name&gt;        Use specified tag when installing and updating the module. Over-
+                             rides the branch option.
+  <b>-u</b>|<b>--use</b> &lt;tool_name&gt;       Install and update the module using the defined tool. Default is
+                             either defined by <b>zstyle &apos;:zim:zmodule&apos; use &apos;</b>&lt;tool_name&gt;<b>&apos;</b>, or <b>git</b>
+                             if none is provided. The tools available are:
+                             <b>git</b> uses the git command. Local changes are preserved on updates.
+                             <b>degit</b> 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.
+                             <b>mkdir</b> creates an empty directory. The &lt;url&gt; is only used to set
+                             the module name. Use the <b>-c</b>|<b>--cmd</b> or <b>--on-pull</b> options to execute
+                             the desired command to generate the module files.
+  <b>--no-submodules</b>            Don&apos;t install or update git submodules.
   <b>-z</b>|<b>--frozen</b>                Don&apos;t install or update the module.
 
-Initialization options:
-  <b>-f</b>|<b>--fpath</b> &lt;path&gt;          Add specified path to fpath. The path is relative to the module
-                             root directory. Default: <b>functions</b>, if the subdirectory exists.
-  <b>-a</b>|<b>--autoload</b> &lt;func_name&gt;  Autoload specified function. Default: all valid names inside the
-                             module&apos;s specified fpath paths.
-  <b>-s</b>|<b>--source</b> &lt;file_path&gt;    Source specified file. The file path is relative to the module root
-                             directory. Default: <b>init.zsh</b>, if the <b>functions</b> subdirectory also
-                             exists, or the file with largest size matching
-                             <b>{init.zsh,module_name.{zsh,plugin.zsh,zsh-theme,sh}}</b>, if any exist.
-  <b>-c</b>|<b>--cmd</b> &lt;command&gt;         Execute specified command. Occurrences of the <b>{}</b> placeholder in the
-                             command are substituted by the module root directory path.
-                             I.e., <b>-s &apos;script.zsh&apos;</b> and <b>-c &apos;source {}/script.zsh&apos;</b> are equivalent.
-  <b>-d</b>|<b>--disabled</b>              Don&apos;t initialize or uninstall the module.
+  The per-module options above are carried over multiple zmodule calls for the same module.
+  Modules are uniquely identified by their name.
 
-  Setting any initialization option above will disable all the default values from the other ini-
-  tialization options, so only your provided values are used. I.e. these values are either all
-  automatic, or all manual.
+Per-module-root options:
+  <b>--if</b> &lt;test&gt;                Will only initialize module root if specified test returns a zero
+                             exit status. The test is evaluated at every new terminal startup.
+  <b>--if-command</b> &lt;cmd_name&gt;    Will only initialize module root if specified external command is
+                             available. This is evaluated at every new terminal startup.
+                             Equivalent to <b>--if &apos;(( ${+commands[</b>&lt;cmd_name&gt;<b>]} ))&apos;</b>.
+  <b>--on-pull</b> &lt;command&gt;        Execute command after installing or updating the module. The com-
+                             mand is executed in the module root directory.
+  <b>-d</b>|<b>--disabled</b>              Don&apos;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:
+  <b>-f</b>|<b>--fpath</b> &lt;path&gt;          Will add specified path to fpath. The path is relative to the
+                             module root directory. Default: <b>functions</b>, if the subdirectory
+                             exists and is non-empty.
+  <b>-a</b>|<b>--autoload</b> &lt;func_name&gt;  Will autoload specified function. Default: all valid names inside
+                             the <b>functions</b> subdirectory, if any.
+  <b>-s</b>|<b>--source</b> &lt;file_path&gt;    Will source specified file. The path is relative to the module
+                             root directory. Default: <b>init.zsh</b>, if a non-empty <b>functions</b> sub-
+                             directory exists, else the largest of the files matching the glob
+                             <b>(init.zsh|</b>&lt;name&gt;<b>.(zsh|plugin.zsh|zsh-theme|sh))</b>, if any.
+                             &lt;name&gt; 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.
+  <b>-c</b>|<b>--cmd</b> &lt;command&gt;         Will execute specified command. Occurrences of the <b>{}</b> placeholder
+                             in the command are substituted by the module root directory path.
+                             I.e., <b>-s &apos;foo.zsh&apos;</b> and <b>-c &apos;source {}/foo.zsh&apos;</b> 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.
 </pre>
 
 </details>
 
 ### zimfw
 
-Added new modules to `~/.zimrc`? Run `zimfw install`.
+The Zim plugin manager:
 
-Removed modules from `~/.zimrc`? Run `zimfw uninstall`.
-
-Want to update your modules to their latest revisions? Run `zimfw update`.
-
-Want to upgrade `zimfw` to its latest version? Run `zimfw upgrade`.
-
-For more information about the `zimfw` tool, run `zimfw help`.
+  * Added new modules to `~/.zimrc`? Run `zimfw install`.
+  * Removed modules from `~/.zimrc`? Run `zimfw uninstall`.
+  * Want to update your modules to their latest revisions? Run `zimfw update`.
+  * Want to upgrade `zimfw` to its latest version? Run `zimfw upgrade`.
+  * For more information about the `zimfw` plugin manager, run `zimfw help`.
 
 Settings
 --------
+Customize path of the directory used by Zim with the `ZIM_HOME` environment
+variable:
+
+    ZIM_HOME=~/.zim
+
+By default, the `zimfw` plugin manager configuration file must be at `~/.zimrc`,
+if the `ZDOTDIR` environment variable is not defined. Otherwise, it must be at
+`${ZDOTDIR}/.zimrc`. You can customize its full path and name with the
+`ZIM_CONFIG_FILE` environment variable:
+
+    ZIM_CONFIG_FILE=~/.config/zsh/zimrc
 
 Modules are installed using `git` by default. If you don't have `git`
 installed, or if you want to take advantage of our degit tool for faster and
@@ -183,11 +329,12 @@ This can be disabled with:
 
 Uninstalling
 ------------
-
 The best way to remove Zim is to manually delete `~/.zim`, `~/.zimrc`, and
 remove the initialization lines from your `~/.zshenv`, `~/.zshrc` and `~/.zlogin`.
 
-[blazing speed]: https://github.com/zimfw/zimfw/wiki/Speed
 [modules]: https://zimfw.sh/docs/modules/
 [themes]: https://zimfw.sh/docs/themes/
-[zimfw]: https://github.com/zimfw
+[speed]: https://github.com/zimfw/zimfw/wiki/Speed
+[@zimfw]: https://github.com/zimfw
+[completion]: https://github.com/zimfw/completion
+[zsh-users/zsh-completions]: https://github.com/zsh-users/zsh-completions

src/stage2/20_guard.zsh.erb

@@ -1,8 +1,8 @@
 autoload -Uz is-at-least && if ! is-at-least <%= min_zsh_version %>; then
-  print -u2 -PR "%F{red}${0}: Error starting Zim. You're using Zsh version %B${ZSH_VERSION}%b and versions < %B<%= min_zsh_version %>%b are not supported. Upgrade your Zsh.%f"
+  print -u2 -R $'<%= red %>'${0}$': Error starting zimfw. You\'re using Zsh version <%= bold %>'${ZSH_VERSION}$'<%= normalred %> and versions < <%= bold %><%= min_zsh_version %><%= normalred %> are not supported. Upgrade your Zsh.<%= normal %>'
   return 1
 fi
 autoload -Uz zargs
 
-# Define Zim location
-if (( ! ${+ZIM_HOME} )) typeset -g ZIM_HOME=${0:A:h}
+# Define zimfw location
+if (( ! ${+ZIM_HOME} )) typeset -g ZIM_HOME=${0:h}

src/stage2/28_zimfw_mv.zsh.erb

@@ -2,12 +2,11 @@ _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 -PR "<%= okay %>%B${2}:%b Already up to date"
+    _zimfw_print -R $'<%= okay %><%= bold %>'${2}$':<%= normal %> Already up to date'
   else
     if [[ -e ${2} ]]; then
       command mv -f ${2}{,.old} || return 1
     fi
-    command mv -f ${1} ${2} && \
-        _zimfw_print -PR "<%= okay %>%B${2}:%b Updated. Restart your terminal for changes to take effect."
+    command mv -f ${1} ${2} && _zimfw_print -R $'<%= okay %><%= bold %>'${2}$':<%= normal %> Updated.'${_zrestartmsg}
   fi
 }

src/stage2/29_zimfw_build_init.zsh.erb

@@ -1,16 +1,44 @@
 _zimfw_build_init() {
   local -r ztarget=${ZIM_HOME}/init.zsh
   # Force update of init.zsh if it's older than .zimrc
-  if [[ ${ztarget} -ot <%= home %>/.zimrc ]]; then
+  if [[ ${ztarget} -ot ${ZIM_CONFIG_FILE:-<%= home %>/.zimrc} ]]; then
     command mv -f ${ztarget}{,.old} || return 1
   fi
   _zimfw_mv =(
-    print -R "zimfw() { source ${ZIM_HOME}/zimfw.zsh \"\${@}\" }"
-    print -R "zmodule() { source ${ZIM_HOME}/zimfw.zsh \"\${@}\" }"
-    # Remove all prefixes from _zfpaths, _zfunctions and _zcmds
-    local -r zpre=$'*\0'
-    if (( ${#_zfpaths} )) print -R 'fpath=('${${_zfpaths#${~zpre}}:A}' ${fpath})'
-    if (( ${#_zfunctions} )) print -R 'autoload -Uz -- '${_zfunctions#${~zpre}}
-    print -R ${(F)_zcmds#${~zpre}}
+    print -R "zimfw() { source ${(q-)ZIM_HOME}/zimfw.zsh \"\${@}\" }"
+    print -R "zmodule() { source ${(q-)ZIM_HOME}/zimfw.zsh \"\${@}\" }"
+    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=('${(q-)${_zfpaths#${~zpre}}:a}' ${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}
 }

src/stage2/29_zimfw_build_login_init.zsh.erb

@@ -1,12 +1,10 @@
 _zimfw_build_login_init() {
-  # Array with unique dirs. ${ZIM_HOME} or any subdirectory should only occur once.
-  local -Ur zscriptdirs=(${ZIM_HOME} ${${_zdirs##${ZIM_HOME}/*}:A})
-  local -r zscriptglob=("${^zscriptdirs[@]}/(^*test*/)#*.zsh(|-theme)(N-.)") ztarget=${ZIM_HOME}/login_init.zsh
+  local -r ztarget=${ZIM_HOME}/login_init.zsh
   # Force update of login_init.zsh if it's older than .zimrc
-  if [[ ${ztarget} -ot <%= home %>/.zimrc ]]; then
+  if [[ ${ztarget} -ot ${ZIM_CONFIG_FILE:-<%= home %>/.zimrc} ]]; then
     command mv -f ${ztarget}{,.old} || return 1
   fi
   _zimfw_mv =(
-    print -nR "<%= render_escaped("src/templates/login_init.zsh.erb") %>"
+    print '# Do nothing. This file is deprecated.'
   ) ${ztarget}
 }

src/stage2/30_zimfw_build.zsh.erb

@@ -1,3 +1,3 @@
 _zimfw_build() {
-  _zimfw_build_init && _zimfw_build_login_init && _zimfw_print -P '<%= done %>Done with build.'
+  _zimfw_build_init && _zimfw_build_login_init && _zimfw_print 'Done with build.'
 }

src/stage2/30_zmodule.zsh.erb

@@ -1,62 +1,87 @@
 zmodule() {
-  local -r zusage="Usage: %B${0}%b <url> [%B-n%b|%B--name%b <module_name>] [options]
+  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 %Bzmodule%b calls to your %B${ZDOTDIR:-${HOME}}/.zimrc%b file to define the modules to be initialized.
-The modules are initialized in the same order they are defined.
+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: %Bname%b, %Bzimfw/name%b, %Bhttps://github.com/zimfw/name.git%b.
-  %B-n%b|%B--name%b <module_name>    Set a custom module name. Default: the last component in the <url>.
-                             Use slashes inside the name to organize the module into subdirecto-
-                             ries.
+                             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.
 
-Repository options:
-  %B-b%b|%B--branch%b <branch_name>  Use specified branch when installing and updating the module.
-                             Overrides the tag option. Default: the repository's default branch.
-  %B-t%b|%B--tag%b <tag_name>        Use specified tag when installing and updating the module.
-                             Overrides the branch option.
-  %B-u%b|%B--use%b <%%Bgit%b|%Bdegit%b>       Install and update the module using the defined tool. Default is
-                             defined by %Bzstyle ':zim:zmodule' use '%b<%%Bgit%b|%Bdegit%b>%B'%b, or %Bgit%b if none
-                             is provided.
-                             %Bgit%b requires git itself. Local changes are preserved during updates.
-                             %Bdegit%b requires curl or wget, and currently only works with GitHub
-                             URLs. Modules install faster and take less disk space. Local changes
-                             are lost during updates. Git submodules are not supported.
-  %B-z%b|%B--frozen%b                Don't install or update the module.
+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.
 
-Initialization options:
-  %B-f%b|%B--fpath%b <path>          Add specified path to fpath. The path is relative to the module
-                             root directory. Default: %Bfunctions%b, if the subdirectory exists.
-  %B-a%b|%B--autoload%b <func_name>  Autoload specified function. Default: all valid names inside the
-                             module's specified fpath paths.
-  %B-s%b|%B--source%b <file_path>    Source specified file. The file path is relative to the module root
-                             directory. Default: %Binit.zsh%b, if the %Bfunctions%b subdirectory also
-                             exists, or the file with largest size matching
-                             %B{init.zsh,module_name.{zsh,plugin.zsh,zsh-theme,sh}}%b, if any exist.
-  %B-c%b|%B--cmd%b <command>         Execute specified command. Occurrences of the %B{}%b placeholder in the
-                             command are substituted by the module root directory path.
-                             I.e., %B-s 'script.zsh'%b and %B-c 'source {}/script.zsh'%b are equivalent.
-  %B-d%b|%B--disabled%b              Don't initialize or uninstall the module.
+  The per-module options above are carried over multiple zmodule calls for the same module.
+  Modules are uniquely identified by their name.
 
-  Setting any initialization option above will disable all the default values from the other ini-
-  tialization options, so only your provided values are used. I.e. these values are either all
-  automatic, or all manual."
-  if [[ ${${funcfiletrace[1]%:*}:t} != .zimrc ]]; then
-    print -u2 -PlR "%F{red}${0}: Must be called from %B<%= home %>/.zimrc%b%f" '' ${zusage}
+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 -PlR "%F{red}<%= error %>${funcfiletrace[1]}: Missing zmodule url%f" '' ${zusage}
+    print -u2 -lR $'<%= red %><%= error %>'${funcfiletrace[1]}$': Missing zmodule url<%= normal %>' '' ${zusage}
     _zfailed=1
     return 2
   fi
-  setopt LOCAL_OPTIONS CASE_GLOB EXTENDED_GLOB
-  local zurl=${1} zmodule=${1:t} ztool zdir ztype zrev zarg
-  local -i zdisabled=0 zfrozen=0
+  local zurl=${1} zname=${1:t} zroot zarg
   local -a zfpaths zfunctions zcmds
-  zstyle -s ':zim:zmodule' use 'ztool' || ztool=git
   if [[ ${zurl} =~ ^[^:/]+: ]]; then
-    zmodule=${zmodule%.git}
+    zname=${zname%.git}
   elif [[ ${zurl} != /* ]]; then
     # Count number of slashes
     case ${#zurl//[^\/]/} in
@@ -65,57 +90,95 @@ Initialization options:
     esac
   fi
   shift
-  if [[ ${1} == (-n|--name) ]]; then
+  while [[ ${1} == (-n|--name|-r|--root) ]]; do
     if (( # < 2 )); then
-      print -u2 -PlR "%F{red}<%= error %>${funcfiletrace[1]}:%B${zmodule}:%b Missing argument for zmodule option ${1}%f" '' ${zusage}
+      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
-    zmodule=${${1%%/##}##/##}
-    shift
-  fi
+  done
   if [[ ${zurl} == /* ]]; then
-    zdir=${zurl%%/##}
+    _zdirs[${zname}]=${zurl%%/##}
     zurl=
   else
-    zdir=${ZIM_HOME}/modules/${zmodule}
+    _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|-f|--fpath|-a|--autoload|-s|--source|-c|--cmd)
+      -b|--branch|-t|--tag|-u|--use|--on-pull|--if|--if-command|-f|--fpath|-a|--autoload|-s|--source|-c|--cmd)
         if (( # < 2 )); then
-          print -u2 -PlR "%F{red}<%= error %>${funcfiletrace[1]}:%B${zmodule}:%b Missing argument for zmodule option ${1}%f" '' ${zusage}
+          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)
-        if [[ -z ${zurl} ]] _zimfw_print -u2 -PR "%F{yellow}<%= warn %>${funcfiletrace[1]}:%B${zmodule}:%b The zmodule option ${1} has no effect for external modules%f"
+      -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
-        ztype=branch
-        zrev=${1}
+        _ztypes[${zname}]=branch
+        _zrevs[${zname}]=${1}
         ;;
       -t|--tag)
         shift
-        ztype=tag
-        zrev=${1}
+        _ztypes[${zname}]=tag
+        _zrevs[${zname}]=${1}
         ;;
       -u|--use)
         shift
-        ztool=${1}
+        _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}]} ))"
         ;;
-      -z|--frozen) zfrozen=1 ;;
       -f|--fpath)
         shift
         zarg=${1}
-        if [[ ${zarg} != /* ]] zarg=${zdir}/${zarg}
+        if [[ ${zarg} != /* ]] zarg=${zroot_dir}/${zarg}
         zfpaths+=(${zarg})
         ;;
       -a|--autoload)
@@ -125,16 +188,16 @@ Initialization options:
       -s|--source)
         shift
         zarg=${1}
-        if [[ ${zarg} != /* ]] zarg=${zdir}/${zarg}
-        zcmds+=("source ${zarg:A}")
+        if [[ ${zarg} != /* ]] zarg=${zroot_dir}/${zarg}
+        zcmds+=("source ${(q-)zarg:a}")
         ;;
       -c|--cmd)
         shift
-        zcmds+=(${1//{}/${zdir:A}})
+        zcmds+=(${1//{}/${(q-)zroot_dir:a}})
         ;;
-      -d|--disabled) zdisabled=1 ;;
+      -d|--disabled) _zdisabled_root_dirs+=(${zroot_dir}) ;;
       *)
-        print -u2 -PlR "%F{red}<%= error %>${funcfiletrace[1]}:%B${zmodule}:%b Unknown zmodule option ${1}%f" '' ${zusage}
+        print -u2 -lR $'<%= red %><%= error %>'${funcfiletrace[1]}$':<%= bold %>'${zname}$':<%= normalred %> Unknown zmodule option <%= bold %>'${1}$'<%= normal %>' '' ${zusage}
         _zfailed=1
         return 2
         ;;
@@ -142,45 +205,36 @@ Initialization options:
     shift
   done
   if (( _zflags & 1 )); then
-    _zmodules_zargs+=("${ztool}" "${_zargs_action}" "${zmodule}" "${zdir}" "${zurl}" "${ztype}" "${zrev}" "${zfrozen}" "${zdisabled}")
+    _znames+=(${zname})
   fi
   if (( _zflags & 2 )); then
-    if (( zdisabled )); then
-      _zdisabled_dirs+=(${zdir})
-    else
-      if [[ ! -e ${zdir} ]]; then
-        if [[ -z ${zurl} ]]; then
-          print -u2 -PR "%F{red}<%= error %>${funcfiletrace[1]}:%B${zmodule}: ${zdir}%b not found%f"
-        else
-          print -u2 -PR "%F{red}<%= error %>${funcfiletrace[1]}:%B${zmodule}:%b Not installed. Run %Bzimfw install%b to install.%f"
-        fi
-        _zfailed=1
-        return 1
-      fi
-      if (( ! ${#zfpaths} && ! ${#zfunctions} && ! ${#zcmds} )); then
-        zfpaths=(${zdir}/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=(${zdir}/init.zsh(N))
-        if (( ${#zfpaths} && ${#prezto_scripts} )); then
-          # this follows the prezto module format, no need to check for other scripts
-          zcmds=("source ${^prezto_scripts[@]:A}")
-        else
-          # get script with largest size (descending `O`rder by `L`ength, and return only `[1]` first)
-          local -ra zscripts=(${zdir}/(init.zsh|${zmodule:t}.(zsh|plugin.zsh|zsh-theme|sh))(NOL[1]))
-          zcmds=("source ${^zscripts[@]:A}")
-        fi
-      fi
-      if (( ! ${#zfpaths} && ! ${#zfunctions} && ! ${#zcmds} )); then
-        _zimfw_print -u2 -PlR "%F{yellow}<%= warn %>${funcfiletrace[1]}:%B${zmodule}:%b Nothing found to be initialized. Customize the module name or initialization with %Bzmodule%b options.%f" '' ${zusage}
-      fi
-      _zdirs+=(${zdir})
-      # Prefix is added to all _zfpaths, _zfunctions and _zcmds to distinguish the originating modules
-      local -r zpre=${zmodule}$'\0'
-      _zfpaths+=(${zpre}${^zfpaths})
-      _zfunctions+=(${zpre}${^zfunctions})
-      _zcmds+=(${zpre}${^zcmds})
+    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
 }

src/stage2/31_zimfw_source_zimrc.zsh.erb

@@ -1,12 +1,20 @@
 _zimfw_source_zimrc() {
-  local -r ztarget=<%= home %>/.zimrc _zflags=${1} _zargs_action=${2}
+  local -r ztarget=${ZIM_CONFIG_FILE:-<%= home %>/.zimrc} _zflags=${1}
   local -i _zfailed=0
   if ! source ${ztarget} || (( _zfailed )); then
-    print -u2 -PR "%F{red}<%= failed %>Failed to source %B${ztarget}%b%f"
+    print -u2 -R $'<%= red %>Failed to source <%= bold %>'${ztarget}$'<%= normal %>'
     return 1
   fi
-  if (( _zflags & 1 && ${#_zmodules_zargs} == 0 )); then
-    print -u2 -PR "%F{red}<%= failed %>No modules defined in %B${ztarget}%b%f"
+  if (( _zflags & 1 && ${#_znames} == 0 )); then
+    print -u2 -R $'<%= red %>No modules defined in <%= bold %>'${ztarget}$'<%= normal %>'
     return 1
   fi
+  # Remove all from _zfpaths, _zfunctions and _zcmds with disabled root dirs prefixes
+  local zroot_dir zpre
+  for zroot_dir in ${_zdisabled_root_dirs}; do
+    zpre=${zroot_dir}$'\0'
+    _zfpaths=(${_zfpaths:#${zpre}*})
+    _zfunctions=(${_zfunctions:#${zpre}*})
+    _zcmds=(${_zcmds:#${zpre}*})
+  done
 }

src/stage2/34_zimfw_list_unuseds.zsh.erb

@@ -1,19 +1,18 @@
 _zimfw_list_unuseds() {
   local -i i=1
-  local -a zinstalled=(${ZIM_HOME}/modules/*(N/))
+  local zinstalled=(${ZIM_HOME}/modules/*(N/))
+  local -r zdirs=(${(v)_zdirs})
   # Search into subdirectories
   while (( i <= ${#zinstalled} )); do
-    if (( ${_zdirs[(I)${zinstalled[i]}/*]} || ${_zdisabled_dirs[(I)${zinstalled[i]}/*]} )); then
+    if (( ${zdirs[(I)${zinstalled[i]}/*]} )); then
       zinstalled+=(${zinstalled[i]}/*(N/))
       zinstalled[i]=()
     else
       (( i++ ))
     fi
   done
-  # Unused = all installed dirs not in _zdirs and _zdisabled_dirs
-  _zunused_dirs=(${${zinstalled:|_zdirs}:|_zdisabled_dirs})
+  # Unused = all installed dirs not in zdirs
+  _zunused_dirs=(${zinstalled:|zdirs})
   local zunused
-  for zunused in ${_zunused_dirs}; do
-    _zimfw_print -PR "%B${zunused:t}:%b ${zunused}${1}"
-  done
+  for zunused (${_zunused_dirs}) _zimfw_print -R $'<%= bold %>'${zunused:t}$':<%= normal %> '${zunused}${1}
 }

src/stage2/40_zimfw_version_check.zsh.erb

@@ -1,19 +0,0 @@
-_zimfw_version_check() {
-  if (( _zprintlevel > 0 )); then
-    setopt LOCAL_OPTIONS EXTENDED_GLOB
-    local -r ztarget=${ZIM_HOME}/.latest_version
-    # If .latest_version does not exist or was not modified in the last 30 days
-    if [[ -w ${ztarget:h} && ! -f ${ztarget}(#qNm-30) ]]; then
-      # Get latest version (get all `v*` tags from repo, delete `*v` from beginning,
-      # sort in descending `O`rder `n`umerically, and get the `[1]` first)
-      print ${${(On)${(f)"$(command git ls-remote --tags --refs \
-          https://github.com/zimfw/zimfw.git 'v*' 2>/dev/null)"}##*v}[1]} >! ${ztarget} &!
-    fi
-    if [[ -f ${ztarget} ]]; then
-      local -r zlatest_version=$(<${ztarget})
-      if [[ -n ${zlatest_version} && ${_zversion} != ${zlatest_version} ]]; then
-        print -u2 -PlR "%F{yellow}Latest zimfw version is %B${zlatest_version}%b. You're using version %B${_zversion}%b. Run %Bzimfw upgrade%b to upgrade.%f" ''
-      fi
-    fi
-  fi
-}

src/stage2/50_zimfw_check_dumpfile.zsh.erb

@@ -0,0 +1,3 @@
+_zimfw_check_dumpfile() {
+  _zimfw_print -u2 $'<%= yellow %><%= warn %>Deprecated action. This is now handled by the completion module alone.<%= normal %>'
+}

src/stage2/50_zimfw_check_version.zsh.erb

@@ -0,0 +1,23 @@
+_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 $'<%= yellow %>Latest zimfw version is <%= bold %>'${zlatest_version}$'<%= normalyellow %>. You\'re using version <%= bold %>'${_zversion}$'<%= normalyellow %>. Run <%= bold %>zimfw upgrade<%= normalyellow %> to upgrade.<%= normal %>'
+      return 4
+    fi
+  fi
+}

src/stage2/50_zimfw_clean_compiled.zsh.erb

@@ -1,9 +1,8 @@
 _zimfw_clean_compiled() {
   # Array with unique dirs. ${ZIM_HOME} or any subdirectory should only occur once.
-  local -Ur zscriptdirs=(${ZIM_HOME} ${${_zdirs##${ZIM_HOME}/*}:A})
+  local -Ur zscriptdirs=(${ZIM_HOME:A} ${${(v)_zdirs##${ZIM_HOME:A}/*}:A})
   local zopt
   if (( _zprintlevel > 0 )) zopt=-v
-  command rm -f ${zopt} ${^zscriptdirs}/**/*.zwc(|.old)(N) || return 1
-  command rm -f ${zopt} <%= home %>/<%= startup_files_glob %>.zwc(|.old)(N) || return 1
-  _zimfw_print -P '<%= done %>Done with clean-compiled. Restart your terminal or run %Bzimfw compile%b to re-compile.'
+  command rm -f ${zopt} ${^zscriptdirs}/**/*.zwc(|.old)(N) && \
+      _zimfw_print $'Done with clean-compiled. Restart your terminal or run <%= bold %>zimfw compile<%= normal %> to re-compile.'
 }

src/stage2/50_zimfw_clean_dumpfile.zsh.erb

@@ -2,6 +2,6 @@ _zimfw_clean_dumpfile() {
   local zdumpfile zopt
   zstyle -s ':zim:completion' dumpfile 'zdumpfile' || zdumpfile=<%= home %>/.zcompdump
   if (( _zprintlevel > 0 )) zopt=-v
-  command rm -f ${zopt} ${zdumpfile}(|.zwc(|.old))(N) || return 1
-  _zimfw_print -P '<%= done %>Done with clean-dumpfile. Restart your terminal to dump an updated configuration.'
+  command rm -f ${zopt} ${zdumpfile}(|.dat|.zwc(|.old))(N) && \
+      _zimfw_print -R "Done with clean-dumpfile.${_zrestartmsg}"
 }

src/stage2/50_zimfw_compile.zsh.erb

@@ -1,5 +1,16 @@
 _zimfw_compile() {
-  local zopt
-  if (( _zprintlevel <= 0 )) zopt=-q
-  source ${ZIM_HOME}/login_init.zsh ${zopt}
+  # Compile zimfw scripts
+  local zroot_dir zfile
+  for zroot_dir in ${_zroot_dirs:|_zdisabled_root_dirs}; do
+    if [[ ! -w ${zroot_dir} ]]; then
+      _zimfw_print -R $'<%= yellow %><%= warn %><%= bold %>'${zroot_dir}$':<%= normalyellow %> No write permission, unable to compile.<%= normal %>'
+      continue
+    fi
+    for zfile in ${zroot_dir}/(^*test*/)#*.zsh(|-theme)(N-.); do
+      if [[ ! ${zfile}.zwc -nt ${zfile} ]]; then
+        zcompile -UR ${zfile} && _zimfw_print -R $'<%= okay %><%= bold %>'${zfile}$'.zwc:<%= normal %> Compiled'
+      fi
+    done
+  done
+  _zimfw_print 'Done with compile.'
 }

src/stage2/50_zimfw_info.zsh.erb

@@ -1,6 +1,7 @@
 _zimfw_info() {
-  print -R 'zimfw version: '${_zversion}' (built at <%= Time.now.utc %>, previous commit is <%= `git rev-parse --short HEAD | tr -d '\r\n'` %>)'
-  print -R 'ZIM_HOME:      '${ZIM_HOME}
-  print -R 'Zsh version:   '${ZSH_VERSION}
-  print -R 'System info:   '$(command uname -a)
+  print -R 'zimfw version:        '${_zversion}' (built at <%= Time.now.utc %>, previous commit is <%= `git rev-parse --short HEAD | tr -d '\r\n'` %>)'
+  local zparam
+  for zparam in LANG ${(Mk)parameters:#LC_*} OSTYPE TERM TERM_PROGRAM TERM_PROGRAM_VERSION ZIM_HOME ZSH_VERSION; do
+    print -R ${(r.22....:.)zparam}${(P)zparam}
+  done
 }

src/stage2/50_zimfw_install_update.zsh.erb

@@ -1,5 +0,0 @@
-_zimfw_install_update() {
-  _zimfw_source_zimrc 1 ${1} && \
-      zargs -n 9 -P 0 -- "${_zmodules_zargs[@]}" -- _zimfw_run_tool && \
-      _zimfw_print -PR "<%= done %>Done with ${1}. Restart your terminal for any changes to take effect."
-}

src/stage2/50_zimfw_uninstall.zsh.erb

@@ -7,5 +7,5 @@ _zimfw_uninstall() {
       command rm -rf ${zopt} ${_zunused_dirs} || return 1
     fi
   fi
-  _zimfw_print -P '<%= done %>Done with uninstall.'
+  _zimfw_print 'Done with uninstall.'
 }

src/stage2/50_zimfw_upgrade.zsh.erb

@@ -8,7 +8,7 @@ _zimfw_upgrade() {
       if (( _zprintlevel <= 1 )) zopt=-q
       if ! command wget -nv ${zopt} -O ${ztarget}.new.gz ${zurl}; then
         if (( _zprintlevel <= 1 )); then
-          print -u2 -PR "%F{red}<%= failed %>Failed to download %B${zurl}%b. Use %B-v%b option to see details.%f"
+          print -u2 -R $'<%= red %>Failed to download <%= bold %>'${zurl}$'<%= normalred %>. Use <%= bold %>-v<%= normalred %> option to see details.<%= normal %>'
         fi
         return 1
       fi
@@ -17,7 +17,7 @@ _zimfw_upgrade() {
     # .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 -P '<%= done %>Done with upgrade.'
+        _zimfw_print 'Done with upgrade.'
   } always {
     command rm -f ${ztarget}.new{,.gz}
   }

src/stage2/69_zimfw_run_list.zsh.erb

@@ -1,26 +1,40 @@
 _zimfw_run_list() {
-  local -r ztool=${1} zmodule=${3} zdir=${4} zurl=${5} ztype=${6} zrev=${7}
-  local -ri zfrozen=${8} zdisabled=${9}
-  print -PnR "%B${zmodule}:%b ${zdir}"
-  if [[ -z ${zurl} ]] print -Pn ' (external)'
-  if (( ${zfrozen} )) print -Pn ' (frozen)'
-  if (( ${zdisabled} )) print -Pn ' (disabled)'
+  local -r zname=${1}
+  local -r zdir=${_zdirs[${zname}]}
+  print -nR $'<%= bold %>'${zname}$':<%= normal %> '${zdir}
+  if [[ -z ${_zurls[${zname}]} ]] print -n ' (external)'
+  if (( ${_zfrozens[${zname}]} )) print -n ' (frozen)'
+  if (( ${_zdisabled_root_dirs[(I)${zdir}]} )) print -n ' (disabled)'
   print
   if (( _zprintlevel > 1 )); then
-    if [[ ${zfrozen} -eq 0 && -n ${zurl} ]]; then
-      print -nR "  From: ${zurl}, "
-      if [[ -z ${zrev} ]]; then
+    if [[ ${_zfrozens[${zname}]} -eq 0 && -n ${_zurls[${zname}]} ]]; then
+      print -nR "  From: ${_zurls[${zname}]}, "
+      if [[ -z ${_zrevs[${zname}]} ]]; then
         print -n 'default branch'
       else
-        print -nR "${ztype} ${zrev}"
+        print -nR "${_ztypes[${zname}]} ${_zrevs[${zname}]}"
       fi
-      print -R ", using ${ztool}"
+      print -nR ", using ${_ztools[${zname}]}"
+      if (( ! _zsubmodules[${zname}] )) print -n ', no git submodules'
+      print
+      if [[ -n ${_zonpulls[${zname}]} ]] print -R "  On-pull: ${_zonpulls[${zname}]}"
     fi
-    # Match and remove the current module prefix from _zfpaths, _zfunctions and _zcmds
-    local -r zpre=${zmodule}$'\0'
-    local -r zfpaths=(${${(M)_zfpaths:#${zpre}*}#${zpre}}) zfunctions=(${${(M)_zfunctions:#${zpre}*}#${zpre}}) zcmds=(${${(M)_zcmds:#${zpre}*}#${zpre}})
-    if (( ${#zfpaths} )) print -R "  fpath: ${zfpaths[@]}"
-    if (( ${#zfunctions} )) print -R "  autoload: ${zfunctions[@]}"
-    if (( ${#zcmds} )) print -R "  cmd: ${(j:; :)zcmds[@]}"
+    # Match the current module dir prefix from _zroot_dirs
+    local -r zroot_dirs=(${(M)_zroot_dirs:#${zdir}/*})
+    if (( ${#zroot_dirs} )); then
+      print '  Additional root:'
+      local zroot_dir
+      for zroot_dir in ${zroot_dirs}; do
+        print -nR "    ${zroot_dir}"
+        if (( ${_zdisabled_root_dirs[(I)${zroot_dir}]} )) print -n ' (disabled)'
+        print
+      done
+    fi
+    # Match and remove the prefix from _zfpaths, _zfunctions and _zcmds
+    local -r zpre="${(q)zdir}(|/*)"$'\0'
+    local -r zfpaths=(${${(M)_zfpaths:#${~zpre}*}#${~zpre}}) zfunctions=(${${(M)_zfunctions:#${~zpre}*}#${~zpre}}) zcmds=(${${(M)_zcmds:#${~zpre}*}#${~zpre}})
+    if (( ${#zfpaths} )) print -R '  fpath: '${zfpaths}
+    if (( ${#zfunctions} )) print -R '  autoload: '${zfunctions}
+    if (( ${#zcmds} )) print -R '  cmd: '${(j:; :)zcmds}
   fi
 }

src/stage2/70_zimfw_create_dir.zsh.erb

@@ -0,0 +1,6 @@
+_zimfw_create_dir() {
+  if ! ERR=$(command mkdir -p ${1} 2>&1); then
+    _zimfw_print_error "Error creating ${1}" ${ERR}
+    return 1
+  fi
+}

src/stage2/70_zimfw_print_error.zsh.erb

@@ -0,0 +1,3 @@
+_zimfw_print_error() {
+  print -u2 -lR $'<%= clear_line %><%= red %><%= error %><%= bold %>'${_zname}$':<%= normalred %> '${1}$'<%= normal %>' ${2:+${(F):-  ${(f)^2}}}
+}

src/stage2/70_zimfw_print_okay.zsh.erb

@@ -0,0 +1,3 @@
+_zimfw_print_okay() {
+  if (( _zprintlevel > ${2:-0} )) print -lR $'<%= clear_line %><%= okay %><%= bold %>'${_zname}$':<%= normal %> '${1} ${3:+${(F):-  ${(f)^3}}}
+}

src/stage2/70_zimfw_print_warn.zsh.erb

@@ -0,0 +1,3 @@
+_zimfw_print_warn() {
+  _zimfw_print -u2 -R $'<%= clear_line %><%= yellow %><%= warn %><%= bold %>'${_zname}$':<%= normalyellow %> '${1}$'<%= normal %>'
+}

src/stage2/70_zimfw_run_tool.zsh.erb

@@ -1,41 +0,0 @@
-_zimfw_run_tool() {
-  local -r ztool=${1} zaction=${2} zmodule=${3} zdir=${4} zurl=${5}
-  if [[ -z ${zurl} ]]; then
-    if (( _zprintlevel > 1 )) print -u2 -PR <%= clear_line %>"<%= okay %>%B${zmodule}:%b Skipping external module"
-    return 0
-  fi
-  local -ri zfrozen=${8}
-  if (( zfrozen )); then
-    if (( _zprintlevel > 1 )) print -u2 -PR <%= clear_line %>"<%= okay %>%B${zmodule}:%b Skipping frozen module"
-    return 0
-  fi
-  case ${zaction} in
-    install)
-      if [[ -e ${zdir} ]]; then
-        # Already installed
-        return 0
-      fi
-      _zimfw_print -nR <%= clear_line %>"Installing ${zmodule}<%= ellipsis %>"
-      ;;
-    update)
-      if [[ ! -d ${zdir} ]]; then
-        print -u2 -PR <%= clear_line %>"%F{red}<%= error %>%B${zmodule}:%b Not installed. Run %Bzimfw install%b to install.%f"
-        return 1
-      fi
-      _zimfw_print -nR <%= clear_line %>"Updating ${zmodule}<%= ellipsis %>"
-      ;;
-    *)
-      print -u2 -PR <%= clear_line %>"%F{red}<%= error %>%B${zmodule}:%b Unknown action ${zaction}%f"
-      return 1
-      ;;
-  esac
-  local zcmd
-  case ${ztool} in
-<%= render_tools("src/tools/*", "zcmd") %>
-    *)
-      print -u2 -PR "<%= clear_line %>%F{red}<%= error %>%B${zmodule}:%b Unknown tool ${ztool}%f"
-      return 1
-      ;;
-  esac
-  zsh -c ${zcmd} ${ztool} ${_zprintlevel} "${@[2,7]}"
-}

src/stage2/71_zimfw_pull_print_okay.zsh.erb

@@ -0,0 +1,13 @@
+_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 "${@}"
+}

src/stage2/75_zimfw_tool_degit.zsh.erb

@@ -0,0 +1,145 @@
+_zimfw_download_tarball() {
+  if [[ ${URL} =~ <%= url_regex %> ]]; 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 GitHub URL. Will not try to ${_zaction}."
+    return 1
+  fi
+  readonly HEADERS_TARGET=${DIR}/${TEMP}_headers
+  {
+    if [[ -r ${INFO_TARGET} ]]; then
+      readonly INFO=("${(@f)"$(<${INFO_TARGET})"}")
+      if [[ ${URL} != ${INFO[1]} ]]; then
+        _zimfw_print_error "URL does not match. Expected ${URL}. Will not try to ${_zaction}."
+        return 1
+      fi
+      # 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 [[ ${_zaction} == check ]]; then
+      if [[ -z ${INFO_HEADER} ]] return 0
+      if (( ${+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]} )); 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 [[ ${_zaction} == 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=${5}
+  readonly DIR=${1} URL=${2} REV=${4} ONPULL=${6} TEMP=.zdegit_${sysparams[pid]}
+  readonly TARBALL_TARGET=${DIR}/${TEMP}_tarball.tar.gz INFO_TARGET=${DIR}/.zdegit
+  case ${_zaction} in
+    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)
+      if [[ ! -r ${INFO_TARGET} ]]; then
+        _zimfw_print_warn $'Module was not installed using zimfw\'s degit. Will not try to '${_zaction}$'. Use zmodule option <%= bold %>-z<%= normalyellow %>|<%= bold %>--frozen<%= normalyellow %> to disable this warning.'
+        return 0
+      fi
+      readonly DIR_NEW=${DIR}${TEMP}
+      {
+        _zimfw_download_tarball || return 1
+        if [[ ${_zaction} == 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]} )); 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 <%= bold %>--no-submodules<%= normalyellow %> to disable this warning.'
+  fi
+}

src/stage2/75_zimfw_tool_git.zsh.erb

@@ -0,0 +1,93 @@
+_zimfw_tool_git() {
+  # This runs in a subshell
+  readonly -i SUBMODULES=${5}
+  readonly  DIR=${1} URL=${2} TYPE=${3} ONPULL=${6}
+  REV=${4}
+  case ${_zaction} in
+    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 [[ ! -r ${DIR}/.git ]]; then
+        _zimfw_print_warn 'Module was not installed using git. Will not try to '${_zaction}$'. Use zmodule option <%= bold %>-z<%= normalyellow %>|<%= bold %>--frozen<%= normalyellow %> to disable this warning.'
+        return 0
+      fi
+      if [[ ${URL} != $(command git -C ${DIR} config --get remote.origin.url) ]]; then
+        _zimfw_print_error "URL does not match. Expected ${URL}. Will not try to ${_zaction}."
+        return 1
+      fi
+      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
+        TO_REV=${REV}@{u}
+        if [[ ${_zaction} == check ]]; then
+          readonly -i BEHIND=$(command git -C ${DIR} rev-list --count ${REV}..${TO_REV} -- 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
+      else
+        if [[ ${REV} == $(command git -C ${DIR} describe --tags --exact-match 2>/dev/null) ]]; then
+          if [[ ${_zaction} == 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 [[ ${_zaction} == check ]]; then
+          _zimfw_print_okay 'Update available'
+          return 4
+        fi
+        TO_REV=${REV}
+      fi
+      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)
+      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
+}

src/stage2/75_zimfw_tool_mkdir.zsh.erb

@@ -0,0 +1,14 @@
+_zimfw_tool_mkdir() {
+  # This runs in a subshell
+  readonly -i SUBMODULES=${5}
+  readonly DIR=${1} TYPE=${3} REV=${4} ONPULL=${6}
+  if [[ -n ${REV} ]]; then
+    _zimfw_print_warn $'The zmodule option <%= bold %>-'${TYPE[1]}$'<%= normalyellow %>|<%= bold %>--'${TYPE}$'<%= normalyellow %> has no effect when using the mkdir tool'
+  fi
+  if (( ! SUBMODULES )); then
+    _zimfw_print_warn $'The zmodule option <%= bold %>--no-submodules<%= normalyellow %> has no effect when using the mkdir tool'
+  fi
+  if [[ ! -d ${DIR} || -n ${ONPULL} ]]; then
+    _zimfw_create_dir ${DIR} && _zimfw_pull_print_okay Created || return 1
+  fi
+}

src/stage2/77_zimfw_run_tool.zsh.erb

@@ -0,0 +1,45 @@
+_zimfw_run_tool() {
+  local -r _zname=${1}
+  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
+  case ${_zaction} in
+    install)
+      if [[ -e ${_zdirs[${_zname}]} ]]; then
+        _zimfw_print_okay 'Skipping already installed module' 1
+        return 0
+      fi
+      _zimfw_print -nR $'<%= clear_line %>Installing '${_zname}'<%= ellipsis %>'
+      ;;
+    check|update)
+      if [[ ! -d ${_zdirs[${_zname}]} ]]; then
+        _zimfw_print_error $'Not installed. Run <%= bold %>zimfw install<%= normalred %> to install.'
+        return 1
+      fi
+      if [[ ${_zaction} == check ]]; then
+        if (( _zprintlevel > 1 )) print -nR $'<%= clear_line %>Checking '${_zname}'<%= ellipsis %>'
+      else
+        _zimfw_print -nR $'<%= clear_line %>Updating '${_zname}'<%= ellipsis %>'
+      fi
+      ;;
+    *)
+      _zimfw_print_error "Unknown action ${_zaction}"
+      return 1
+      ;;
+  esac
+  local -r ztool=${_ztools[${_zname}]}
+  case ${ztool} in
+    degit|git|mkdir)
+      _zimfw_tool_${ztool} "${_zdirs[${_zname}]}" "${_zurls[${_zname}]}" "${_ztypes[${_zname}]}" "${_zrevs[${_zname}]}" "${_zsubmodules[${_zname}]}" "${_zonpulls[${_zname}]}"
+      ;;
+    *)
+      _zimfw_print_error "Unknown tool ${ztool}"
+      return 1
+      ;;
+  esac
+}

src/stage2/78_zimfw_run_tool_action.zsh.erb

@@ -0,0 +1,5 @@
+_zimfw_run_tool_action() {
+  local -r _zaction=${1}
+  _zimfw_source_zimrc 1 && zargs -n 1 -P 0 -- "${_znames[@]}" -- _zimfw_run_tool
+  return 0
+}

src/stage2/80_zimfw.zsh.erb

@@ -1,78 +1,104 @@
 zimfw() {
-  local -r _zversion='<%= version %>' zusage="Usage: %B${0}%b <action> [%B-q%b|%B-v%b]
+  builtin emulate -L zsh -o EXTENDED_GLOB
+  local -r _zversion='<%= version %>' _zversion_target=${ZIM_HOME}/.latest_version zusage=$'Usage: <%= bold %>'${0}$'<%= normal %> <action> [<%= bold %>-q<%= normal %>|<%= bold %>-v<%= normal %>]
 
 Actions:
-  %Bbuild%b           Build %B${ZIM_HOME}/init.zsh%b and %B${ZIM_HOME}/login_init.zsh%b.
-                  Also does %Bcompile%b. Use %B-v%b to also see its output.
-  %Bclean%b           Clean all. Does both %Bclean-compiled%b and %Bclean-dumpfile%b.
-  %Bclean-compiled%b  Clean Zsh compiled files.
-  %Bclean-dumpfile%b  Clean completion dump file.
-  %Bcompile%b         Compile Zsh files.
-  %Bhelp%b            Print this help.
-  %Binfo%b            Print Zim and system info.
-  %Blist%b            List all modules. Use %B-v%b to also see the current details for all modules.
-  %Binstall%b         Install new modules. Also does %Bbuild%b and %Bcompile%b. Use %B-v%b to also see their
-                  output, and see skipped modules.
-  %Buninstall%b       Delete unused modules. Prompts for confirmation. Use %B-q%b to uninstall quietly.
-  %Bupdate%b          Update current modules. Also does %Bbuild%b and %Bcompile%b. Use %B-v%b to see their
-                  output, and see skipped modules.
-  %Bupgrade%b         Upgrade zimfw. Also does %Bcompile%b. Use %B-v%b to also see its output.
-  %Bversion%b         Print zimfw version.
+  <%= bold %>build<%= normal %>           Build <%= bold %>'${ZIM_HOME}$'/init.zsh<%= normal %> and <%= bold %>'${ZIM_HOME}$'/login_init.zsh<%= normal %>.
+                  Also does <%= bold %>compile<%= normal %>. Use <%= bold %>-v<%= normal %> to also see its output.
+  <%= bold %>clean<%= normal %>           Clean all. Does both <%= bold %>clean-compiled<%= normal %> and <%= bold %>clean-dumpfile<%= normal %>.
+  <%= bold %>clean-compiled<%= normal %>  Clean Zsh compiled files.
+  <%= bold %>clean-dumpfile<%= normal %>  Clean completion dumpfile.
+  <%= bold %>compile<%= normal %>         Compile Zsh files.
+  <%= bold %>help<%= normal %>            Print this help.
+  <%= bold %>info<%= normal %>            Print zimfw and system info.
+  <%= bold %>list<%= normal %>            List all modules currently defined in <%= bold %>'${ZIM_CONFIG_FILE:-<%= home %>/.zimrc}$'<%= normal %>.
+                  Use <%= bold %>-v<%= normal %> to also see the modules details.
+  <%= bold %>init<%= normal %>            Same as <%= bold %>install<%= normal %>, but with output tailored to be used at terminal startup.
+  <%= bold %>install<%= normal %>         Install new modules. Also does <%= bold %>build<%= normal %>, <%= bold %>compile<%= normal %>. Use <%= bold %>-v<%= normal %> to also see their
+                  output, any on-pull output and skipped modules.
+  <%= bold %>uninstall<%= normal %>       Delete unused modules. Prompts for confirmation. Use <%= bold %>-q<%= normal %> for quiet uninstall.
+  <%= bold %>check<%= normal %>           Check if updates for current modules are available. Use <%= bold %>-v<%= normal %> to also see
+                  skipped and up to date modules.
+  <%= bold %>update<%= normal %>          Update current modules. Also does <%= bold %>build<%= normal %>, <%= bold %>compile<%= normal %>. Use <%= bold %>-v<%= normal %> to also see their
+                  output, any on-pull output and skipped modules.
+  <%= bold %>check-version<%= normal %>   Check if a new version of zimfw is available.
+  <%= bold %>upgrade<%= normal %>         Upgrade zimfw. Also does <%= bold %>compile<%= normal %>. Use <%= bold %>-v<%= normal %> to also see its output.
+  <%= bold %>version<%= normal %>         Print zimfw version.
 
 Options:
-  %B-q%b              Quiet (yes to prompts, and only outputs errors)
-  %B-v%b              Verbose (outputs more details)"
-  local -a _zdisabled_dirs _zdirs _zfpaths _zfunctions _zcmds _zmodules_zargs _zunused_dirs
+  <%= bold %>-q<%= normal %>              Quiet (yes to prompts and only outputs errors)
+  <%= bold %>-v<%= normal %>              Verbose (outputs more details)'
+  local -Ua _znames _zroot_dirs _zdisabled_root_dirs
+  local -A _zfrozens _ztools _zdirs _zurls _ztypes _zrevs _zsubmodules _zonpulls _zifs
+  local -a _zfpaths _zfunctions _zcmds _zunused_dirs
   local -i _zprintlevel=1
   if (( # > 2 )); then
-     print -u2 -PlR "%F{red}${0}: Too many options%f" '' ${zusage}
+     print -u2 -lR $'<%= red %>'${0}$': Too many options<%= normal %>' '' ${zusage}
      return 2
   elif (( # > 1 )); then
     case ${2} in
       -q) _zprintlevel=0 ;;
       -v) _zprintlevel=2 ;;
       *)
-        print -u2 -PlR "%F{red}${0}: Unknown option ${2}%f" '' ${zusage}
+        print -u2 -lR $'<%= red %>'${0}': Unknown option '${2}$'<%= normal %>' '' ${zusage}
         return 2
         ;;
     esac
   fi
 
-  if ! zstyle -t ':zim' disable-version-check; then
-    _zimfw_version_check
+  if ! zstyle -t ':zim' disable-version-check && [[ ${1} != check-version ]]; 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
 
+  local _zrestartmsg=' Restart your terminal for changes to take effect.'
   case ${1} in
     build)
       _zimfw_source_zimrc 2 && _zimfw_build || return 1
       (( _zprintlevel-- ))
       _zimfw_compile
       ;;
-    init) _zimfw_install_update install && _zimfw_source_zimrc 2 && _zimfw_build ;;
+    check-dumpfile) _zimfw_check_dumpfile ;;
     clean) _zimfw_source_zimrc 2 && _zimfw_clean_compiled && _zimfw_clean_dumpfile ;;
     clean-compiled) _zimfw_source_zimrc 2 && _zimfw_clean_compiled ;;
     clean-dumpfile) _zimfw_clean_dumpfile ;;
-    compile) _zimfw_source_zimrc 2 && _zimfw_build_login_init && _zimfw_compile ;;
-    help) print -PR ${zusage} ;;
+    compile) _zimfw_source_zimrc 2 && _zimfw_compile ;;
+    help) print -R ${zusage} ;;
     info) _zimfw_info ;;
     list)
-      _zimfw_source_zimrc 3 && zargs -n 9 -- "${_zmodules_zargs[@]}" -- _zimfw_run_list && \
+      _zimfw_source_zimrc 3 && zargs -n 1 -- "${_znames[@]}" -- _zimfw_run_list && \
           _zimfw_list_unuseds ' (unused)'
       ;;
+    check)
+      _zrestartmsg=
+      _zimfw_run_tool_action ${1} || return 1
+      (( _zprintlevel-- ))
+      _zimfw_print -R "Done with ${1}." # 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 2 && _zimfw_build && _zimfw_compile
+      ;;
     install|update)
-      _zimfw_install_update ${1} || return 1
+      _zimfw_run_tool_action ${1} || return 1
+      _zimfw_print -R "Done with ${1}.${_zrestartmsg}"
       (( _zprintlevel-- ))
       _zimfw_source_zimrc 2 && _zimfw_build && _zimfw_compile
       ;;
     uninstall) _zimfw_source_zimrc 2 && _zimfw_list_unuseds && _zimfw_uninstall ;;
+    check-version) _zimfw_check_version 1 ;;
     upgrade)
       _zimfw_upgrade || return 1
       (( _zprintlevel-- ))
-      _zimfw_compile
+      _zimfw_source_zimrc 2 && _zimfw_compile
       ;;
-    version) print -PR ${_zversion} ;;
+    version) print -R ${_zversion} ;;
     *)
-      print -u2 -PlR "%F{red}${0}: Unknown action ${1}%f" '' ${zusage}
+      print -u2 -lR $'<%= red %>'${0}': Unknown action '${1}$'<%= normal %>' '' ${zusage}
       return 2
       ;;
   esac

src/templates/login_init.zsh.erb

@@ -1,23 +0,0 @@
-() {
-  setopt LOCAL_OPTIONS CASE_GLOB EXTENDED_GLOB
-  autoload -Uz zrecompile
-  local zdumpfile zfile
-
-  # Compile the completion cache; significant speedup
-  zstyle -s ':zim:completion' dumpfile 'zdumpfile' || zdumpfile=<%= home %>/.zcompdump
-  if [[ -f ${zdumpfile} ]]; then
-    zrecompile -p ${1} ${zdumpfile} || return 1
-  fi
-
-  # Compile Zsh startup files
-  for zfile in <%= home %>/<%= startup_files_glob %>(N-.); do
-    zrecompile -p ${1} ${zfile} || return 1
-  done
-
-  # Compile Zim scripts
-  for zfile in #{zscriptglob}; do
-    zrecompile -p ${1} ${zfile} || return 1
-  done
-
-  if [[ ${1} != -q ]] print -P '<%= done %>Done with compile.'
-} "${@}"

src/tools/degit.zsh.erb

@@ -1,142 +0,0 @@
-# This runs in a new shell
-readonly -i PRINTLEVEL=${1}
-readonly ACTION=${2} MODULE=${3} DIR=${4} URL=${5} REV=${7}
-readonly TEMP=.zdegit_${RANDOM}
-readonly TARBALL_TARGET=${DIR}/${TEMP}_tarball.tar.gz INFO_TARGET=${DIR}/.zdegit
-
-print_error() {
-  print -u2 -PlR <%= clear_line %>"%F{red}<%= error %>%B${MODULE}:%b ${1}%f" ${2:+${(F):-  ${(f)^2}}}
-}
-
-print_okay() {
-  if (( PRINTLEVEL > 0 )); then
-    local -r log=${2:+${(F):-  ${(f)^2}}}
-    if [[ -e ${DIR}/.gitmodules ]]; then
-      print -u2 -PlR <%= clear_line %>"%F{yellow}<%= warn %>%B${MODULE}:%b ${(C)1}. Module contains git submodules, which are not supported by Zim's degit and were not ${1}.%f" ${log}
-    else
-      print -PlR <%= clear_line %>"<%= okay %>%B${MODULE}:%b ${(C)1}" ${log}
-    fi
-  fi
-}
-
-download_tarball() {
-  setopt LOCAL_OPTIONS EXTENDED_GLOB
-  local host repo
-  if [[ ${URL} =~ <%= url_regex %> ]]; then
-    host=${match[3]}
-    repo=${match[4]%.git}
-  fi
-  if [[ ${host} != github.com || -z ${repo} ]]; then
-    print_error "${URL} is not a valid GitHub URL. Will not try to ${ACTION}."
-    return 1
-  fi
-  local -r headers_target=${DIR}/${TEMP}_headers
-  {
-    local info_header header etag
-    if [[ -r ${INFO_TARGET} ]]; then
-      local -r info=("${(@f)"$(<${INFO_TARGET})"}")
-      if [[ ${URL} != ${info[1]} ]]; then
-        print_error "URL does not match. Expected ${URL}. Will not try to ${ACTION}."
-        return 1
-      fi
-      # Previous REV is in line 2, reserved for future use.
-      info_header=${info[3]}
-    fi
-    local -r tarball_url=https://api.github.com/repos/${repo}/tarball/${REV}
-    if (( ${+commands[curl]} )); then
-      if ! ERR=$(command curl -fsSL ${info_header:+-H} ${info_header} -o ${TARBALL_TARGET} -D ${headers_target} ${tarball_url} 2>&1); then
-        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 -q ${info_header:+--header=${info_header}} -O ${TARBALL_TARGET} -S ${tarball_url} 2>${headers_target}
-    fi
-    local -i http_code
-    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
-      print_error "Error downloading ${tarball_url}, HTTP code ${http_code}"
-      return 1
-    fi
-    if [[ -z ${etag} ]]; then
-      print_error "Error downloading ${tarball_url}, no ETag header found in response"
-      return 1
-    fi
-    if ! print -lR "${URL}" "${REV}" "If-None-Match: ${etag}" >! ${INFO_TARGET} 2>/dev/null; then
-      print_error "Error creating or updating ${INFO_TARGET}"
-      return 1
-    fi
-  } always {
-    command rm -f ${headers_target} 2>/dev/null
-  }
-}
-
-untar_tarball() {
-  if ! ERR=$(command tar -C ${1} --strip=1 -xzf ${TARBALL_TARGET} 2>&1); then
-    print_error "Error extracting ${TARBALL_TARGET}" ${ERR}
-    return 1
-  fi
-}
-
-create_dir() {
-  if ! ERR=$(command mkdir -p ${1} 2>&1); then
-    print_error "Error creating ${1}" ${ERR}
-    return 1
-  fi
-}
-
-case ${ACTION} in
-  install)
-    {
-      create_dir ${DIR} && download_tarball && untar_tarball ${DIR} && print_okay installed
-    } 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 )); then
-        command rm -rf ${DIR} 2>/dev/null
-      fi
-    }
-    ;;
-  update)
-    if [[ ! -r ${INFO_TARGET} ]]; then
-      if (( PRINTLEVEL > 0 )); then
-        print -u2 -PR <%= clear_line %>"%F{yellow}<%= warn %>%B${MODULE}:%b Module was not installed using Zim's degit. Will not try to update. You can disable this with the zmodule option -z|--frozen.%f"
-      fi
-      return 0
-    fi
-    readonly DIR_NEW=${DIR}${TEMP}
-    {
-      download_tarball || return 1
-      if [[ ! -e ${TARBALL_TARGET} ]]; then
-        if (( PRINTLEVEL > 0 )) print -PR <%= clear_line %>"<%= okay %>%B${MODULE}:%b Already up to date"
-        return 0
-      fi
-      create_dir ${DIR_NEW} && untar_tarball ${DIR_NEW} || return 1
-      if (( ${+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
-        print_error "Error updating ${DIR}" ${ERR}
-        return 1
-      fi
-      print_okay updated ${LOG}
-    } always {
-      command rm -f ${TARBALL_TARGET} 2>/dev/null
-      command rm -rf ${DIR_NEW} 2>/dev/null
-    }
-    ;;
-esac

src/tools/git.zsh.erb

@@ -1,81 +0,0 @@
-# This runs in a new shell
-readonly -i PRINTLEVEL=${1}
-readonly ACTION=${2} MODULE=${3} DIR=${4} URL=${5} TYPE=${6:=branch}
-REV=${7}
-
-print_error() {
-  print -u2 -PlR <%= clear_line %>"%F{red}<%= error %>%B${MODULE}:%b ${1}%f" ${2:+${(F):-  ${(f)^2}}}
-}
-
-print_okay() {
-  if (( PRINTLEVEL > 0 )) print -PlR <%= clear_line %>"<%= okay %>%B${MODULE}:%b ${1}" ${2:+${(F):-  ${(f)^2}}}
-}
-
-case ${ACTION} in
-  install)
-    if ERR=$(command git clone ${REV:+-b} ${REV} -q --config core.autocrlf=false --recursive ${URL} ${DIR} 2>&1); then
-      print_okay Installed
-    else
-      print_error 'Error during git clone' ${ERR}
-      return 1
-    fi
-    ;;
-  update)
-    if ! builtin cd -q ${DIR} 2>/dev/null; then
-      print_error "Error during cd ${DIR}"
-      return 1
-    fi
-    if [[ ${PWD:A} != ${"$(command git rev-parse --show-toplevel 2>/dev/null)":A} ]]; then
-      if (( PRINTLEVEL > 0 )); then
-        print -u2 -PR <%= clear_line %>"%F{yellow}<%= warn %>%B${MODULE}:%b Module was not installed using git. Will not try to update. You can disable this with the zmodule option -z|--frozen.%f"
-      fi
-      return 0
-    fi
-    if [[ ${URL} != $(command git config --get remote.origin.url) ]]; then
-      print_error "URL does not match. Expected ${URL}. Will not try to update."
-      return 1
-    fi
-    if ! ERR=$(command git fetch -pq origin 2>&1); then
-      print_error 'Error during git fetch' ${ERR}
-      return 1
-    fi
-    if [[ ${TYPE} == tag ]]; then
-      if [[ ${REV} == $(command git describe --tags --exact-match 2>/dev/null) ]]; then
-        print_okay 'Already up to date'
-        return 0
-      fi
-    elif [[ -z ${REV} ]]; then
-      # Get HEAD remote branch
-      if ! ERR=$(command git remote set-head origin -a 2>&1); then
-        print_error 'Error during git remote set-head' ${ERR}
-        return 1
-      fi
-      REV=${$(command git symbolic-ref --short refs/remotes/origin/HEAD)#origin/} || return 1
-    fi
-    if [[ ${TYPE} == branch ]]; then
-      LOG_REV=${REV}@{u}
-    else
-      LOG_REV=${REV}
-    fi
-    LOG=$(command git log --graph --color --format='%C(yellow)%h%C(reset) %s %C(cyan)(%cr)%C(reset)' ..${LOG_REV} -- 2>/dev/null)
-    if ! ERR=$(command git checkout -q ${REV} -- 2>&1); then
-      print_error 'Error during git checkout' ${ERR}
-      return 1
-    fi
-    if [[ ${TYPE} == branch ]]; then
-      if ! OUT=$(command git merge --ff-only --no-progress -n 2>&1); then
-        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 ! ERR=$(command git submodule update --init --recursive -q 2>&1); then
-      print_error 'Error during git submodule update' ${ERR}
-      return 1
-    fi
-    print_okay ${OUT} ${LOG}
-    ;;
-esac

src/zimfw.zsh.erb

@@ -1,24 +1,27 @@
 <%
 class Zim
-  attr_reader :version, :home, :min_zsh_version, :startup_files_glob, :url_regex,
-      :clear_line, :ellipsis, :okay, :warn, :error, :done, :failed
+  attr_reader :version, :home, :min_zsh_version, :url_regex,
+      :bold, :normal, :red, :normalred, :yellow, :normalyellow, :clear_line, :ellipsis, :okay, :warn, :error
 
   def initialize
-    @version = "1.6.1"
+    @version = "1.13.1"
     @home = "${ZDOTDIR:-${HOME}}"
     @min_zsh_version = "5.2"
-    @startup_files_glob = ".z(shenv|profile|shrc|login|logout)"
     # Matches {ssh,http,https,git}://{user@,}host/org/repo and {user@,}host:org/repo
     # but not file:///path/to/repo or /path/to/repo
     # ${match[3]} contains host, and ${match[4]} contains org/repo
     @url_regex = "^([^:@/]+://)?([^@]+@)?([^:/]+)[:/]([^/]+/[^/]+)/?$"
-    @clear_line = "$'\\E[2K\\r'"
+    @bold = "\\E[1m"
+    @normal = "\\E[0m"
+    @yellow = "\\E[33m"
+    @normalyellow = "\\E[0;33m"
+    @red = "\\E[31m"
+    @normalred = "\\E[0;31m"
+    @clear_line = "\\E[2K\\r"
     @ellipsis = " ..."
-    @okay = "%F{green})%f "
+    @okay = "\\E[32m)\\E[0m "
     @warn = "! "
     @error = "x "
-    @done = ""
-    @failed = ""
   end
 
   def render(filename)
@@ -32,16 +35,6 @@ class Zim
   def render_commented(filename)
     render(filename).gsub(/^(?=.)/, "# ").gsub(/^$/, "#")
   end
-
-  def render_escaped(filename)
-    render(filename).gsub(/(?=\$[^']|"|`)/, "\\\\").gsub(/#\{/, "$\{")
-  end
-
-  def render_tools(pattern, var)
-    Dir[pattern].sort.map { |filename|
-      "    #{File.basename(filename, ".zsh.erb")}) #{var}=\"#{render_escaped(filename)}\" ;;"
-    }.join("\n")
-  end
 end
 zim = Zim.new
 %># AUTOMATICALLY GENERATED FILE. EDIT ONLY THE SOURCE FILES AND THEN COMPILE.