[zsh] reinvent the wheel yet again by creating a plugin manager
This commit is contained in:
Dmytro Meleshko
parent
d7d3fb6b08
commit
ff92a1ab7a
|
|
@ -1,31 +1,54 @@
|
|||
#!/usr/bin/env zsh
|
||||
|
||||
configure_oh_my_zsh() {
|
||||
# disable automatic updates because OMZ is managed by zgen
|
||||
DISABLE_AUTO_UPDATE="true"
|
||||
# https://github.com/zdharma/zplugin/blob/master/doc/mod-install.sh
|
||||
# https://github.com/zdharma/zplugin/blob/master/zmodules/Src/Makefile.in
|
||||
# https://github.com/zsh-users/zsh/blob/master/Etc/zsh-development-guide
|
||||
|
||||
source "$ZSH_DOTFILES/zplg.zsh"
|
||||
|
||||
plugin completions 'zsh-users/zsh-completions'
|
||||
|
||||
# Oh-My-Zsh {{{
|
||||
|
||||
# initialize the completion system
|
||||
autoload -Uz compinit && compinit -C
|
||||
|
||||
ZSH_CACHE_DIR="$ZSH_DOTFILES/cache"
|
||||
|
||||
# disable automatic updates because OMZ is managed by my plugin manager
|
||||
DISABLE_AUTO_UPDATE=true
|
||||
|
||||
# use hyphen-insensitive completion (makes `_` and `-` interchangeable)
|
||||
HYPHEN_INSENSITIVE="true"
|
||||
HYPHEN_INSENSITIVE=true
|
||||
|
||||
# enable command auto-correction
|
||||
ENABLE_CORRECTION="true"
|
||||
ENABLE_CORRECTION=true
|
||||
|
||||
# display red dots while waiting for completion
|
||||
COMPLETION_WAITING_DOTS="true"
|
||||
COMPLETION_WAITING_DOTS=true
|
||||
|
||||
# disable marking untracked files under VCS as dirty (this makes repository
|
||||
# status check for large repositories faster)
|
||||
DISABLE_UNTRACKED_FILES_DIRTY="true"
|
||||
# status check for large repositories much faster)
|
||||
DISABLE_UNTRACKED_FILES_DIRTY=true
|
||||
|
||||
# command execution time stamp shown in the history
|
||||
HIST_STAMPS="mm/dd/yyyy"
|
||||
}
|
||||
HIST_STAMPS=dd.mm.yyyy
|
||||
|
||||
configure_syntax_highlighting() {
|
||||
FAST_WORK_DIR="$ZSH_DOTFILES/cache"
|
||||
}
|
||||
omz_plugins=(git extract fasd)
|
||||
|
||||
plugin oh-my-zsh 'robbyrussell/oh-my-zsh' \
|
||||
load='lib/*.zsh' load='plugins/'${^omz_plugins}'/*.plugin.zsh' \
|
||||
ignore='lib/(compfix|diagnostics).zsh' \
|
||||
before_load='ZSH="$plugin_dir"' \
|
||||
after_load='plugin-cfg-path fpath prepend completions functions' \
|
||||
after_load='plugin-cfg-path fpath prepend plugins/'${^omz_plugins}
|
||||
|
||||
unset omz_plugins
|
||||
|
||||
# }}}
|
||||
|
||||
# spaceship prompt {{{
|
||||
|
||||
configure_prompt() {
|
||||
SPACESHIP_PROMPT_ADD_NEWLINE=false
|
||||
|
||||
SPACESHIP_PROMPT_ORDER=(
|
||||
|
|
@ -56,27 +79,23 @@ configure_prompt() {
|
|||
SPACESHIP_DIR_TRUNC_REPO=false
|
||||
|
||||
SPACESHIP_EXIT_CODE_SHOW=true
|
||||
}
|
||||
|
||||
configure_oh_my_zsh
|
||||
configure_syntax_highlighting
|
||||
configure_prompt
|
||||
plugin spaceship-prompt 'denysdovhan/spaceship-prompt'
|
||||
|
||||
source "$ZSH_DOTFILES/zgen/zgen.zsh"
|
||||
# }}}
|
||||
|
||||
if ! zgen saved; then
|
||||
zgen oh-my-zsh
|
||||
plugin fzf 'junegunn/fzf' build='./install --bin' \
|
||||
after_load='plugin-cfg-path path prepend bin' \
|
||||
after_load='plugin-cfg-path manpath prepend man'
|
||||
|
||||
zgen oh-my-zsh plugins/git
|
||||
zgen oh-my-zsh plugins/extract
|
||||
zgen oh-my-zsh plugins/fasd
|
||||
is_linux && zgen oh-my-zsh plugins/command-not-found
|
||||
plugin alias-tips 'djui/alias-tips'
|
||||
|
||||
zgen load zdharma/fast-syntax-highlighting
|
||||
plugin ssh 'zpm-zsh/ssh'
|
||||
|
||||
zgen load denysdovhan/spaceship-prompt spaceship
|
||||
plugin base16-shell 'chriskempson/base16-shell' \
|
||||
after_load='export BASE16_SHELL="$plugin_dir"'
|
||||
|
||||
zgen load chriskempson/base16-shell
|
||||
autoload -Uz compinit && compinit -C
|
||||
|
||||
zgen save
|
||||
fi
|
||||
FAST_WORK_DIR="$ZSH_CACHE_DIR"
|
||||
plugin fast-syntax-highlighting 'zdharma/fast-syntax-highlighting'
|
||||
|
|
|
|||
|
|
@ -0,0 +1,492 @@
|
|||
# This... is my DIY plugin manager for Zsh. "Why did I reinvent the wheel yet
|
||||
# again and created my own plugin manager?" you might ask. Well, some of them
|
||||
# are too slow (antigen, zplug), some are too complicated (antigen-hs, zplugin)
|
||||
# and some are too simple (zgen, antibody). So, I decided to go into into my
|
||||
# cave for a couple of weeks and now, I proudly present to you MY ZSH PLUGIN
|
||||
# MANAGER (ZPLG for short). It is very fast even without caching (that's why it
|
||||
# isn't implemented), has the most essential features and is not bloated. The
|
||||
# code is rather complex at the first glance because of two reasons:
|
||||
#
|
||||
# 1. The syntax of the shell language, to put it simply, utter trash designed
|
||||
# 40 (!!!) years ago.
|
||||
# 2. The shell language, especially when it comes to Zsh, is rather slow, so I
|
||||
# had to use as less abstractions as possible.
|
||||
#
|
||||
# But, read my comments and they'll guide you through this jungle of shell
|
||||
# script mess.
|
||||
|
||||
# Also:
|
||||
#
|
||||
# 1. This script is compatitable with SH_WORD_SPLIT (if you for whatever reason
|
||||
# want to enable this), so I use "@" everywhere. This expansion modifier
|
||||
# means "put all elements of the array in separate quotes".
|
||||
# 2. I often use the following snippet to exit functions on errors:
|
||||
# eval "$some_user_command_that_might_fail" || return "$?"
|
||||
# I do this instead of `setopt localoptions errexit` because some plugins
|
||||
# may not be compatitable with ERREXIT.
|
||||
|
||||
|
||||
_ZPLG_SCRIPT_PATH="${(%):-%N}"
|
||||
|
||||
|
||||
# $ZPLG_HOME is a directory where all your plugins are downloaded, it also
|
||||
# might contain in the future some kind of state/lock/database files. It is
|
||||
# recommended to change it before `source`-ing this script for compatitability
|
||||
# with future versions.
|
||||
if [[ -z "$ZPLG_HOME" ]]; then
|
||||
ZPLG_HOME="${XDG_DATA_HOME:-$HOME/.local/share}/zplg"
|
||||
fi
|
||||
|
||||
# Directory in which plugins are stored. It is separate from $ZPLG_HOME for
|
||||
# compatitability with future versions.
|
||||
_ZPLG_PLUGINS_DIR="$ZPLG_HOME/plugins"
|
||||
|
||||
# basic logging {{{
|
||||
|
||||
_ZPLG_ANSI_BOLD="$(tput bold)"
|
||||
_ZPLG_ANSI_RED="$(tput setaf 1)"
|
||||
_ZPLG_ANSI_GREEN="$(tput setaf 2)"
|
||||
_ZPLG_ANSI_BLUE="$(tput setaf 4)"
|
||||
_ZPLG_ANSI_RESET="$(tput sgr0)"
|
||||
|
||||
_zplg_log() {
|
||||
print >&2 "${_ZPLG_ANSI_BLUE}${_ZPLG_ANSI_BOLD}[zplg]${_ZPLG_ANSI_RESET} $@"
|
||||
}
|
||||
|
||||
_zplg_debug() {
|
||||
if [[ -n "$ZPLG_DEBUG" ]]; then
|
||||
_zplg_log "${_ZPLG_ANSI_GREEN}debug:${_ZPLG_ANSI_RESET} $@"
|
||||
fi
|
||||
}
|
||||
|
||||
_zplg_error() {
|
||||
# try to find the place outside of the script that caused this error
|
||||
local external_caller
|
||||
local i; for (( i=1; i<=${#funcfiletrace}; i++ )); do
|
||||
# $funcfiletrace contains file paths and line numbers
|
||||
if [[ "${funcfiletrace[$i]}" != "$_ZPLG_SCRIPT_PATH"* ]]; then
|
||||
# $functrace contains "ugly" call sites, the line numbers are
|
||||
# relative to the beginning of a function/file here. I use it here
|
||||
# only for consistency with the shell, TODO might change this in the
|
||||
# future.
|
||||
_zplg_log "${_ZPLG_ANSI_RED}error:${_ZPLG_ANSI_RESET} ${functrace[$i]}: $@"
|
||||
return 1
|
||||
fi
|
||||
done
|
||||
|
||||
# if for whatever reason we couldn't find the caller, simply print the
|
||||
# error without it
|
||||
_zplg_log "${_ZPLG_ANSI_RED}error:${_ZPLG_ANSI_RESET} $@"
|
||||
return 1
|
||||
}
|
||||
|
||||
# }}}
|
||||
|
||||
# These variables contain essential information about the currently loaded
|
||||
# plugins. When I say "essential" I mean "required for upgrading,
|
||||
# reinstallating and uninstalling plugins", so options for configuring loading
|
||||
# behavior are not stored here.
|
||||
#
|
||||
# $ZPLG_LOADED_PLUGINS is an array of plugin IDs, other variables are
|
||||
# associative arrays that have IDs as their keys. It is implemented this way
|
||||
# because you can't put associative arrays (or any other alternative to
|
||||
# "objects") into another associative array.
|
||||
typeset -a ZPLG_LOADED_PLUGINS
|
||||
typeset -A ZPLG_LOADED_PLUGIN_URLS ZPLG_LOADED_PLUGIN_SOURCES ZPLG_LOADED_PLUGIN_BUILD_CMDS
|
||||
|
||||
# Takes name of a variable with an array (array is passed by variable name
|
||||
# because this reduces boilerplate) and runs every command in it, exits
|
||||
# immediately with an error code if any command fails. This snippet was
|
||||
# extracted in a function because it's often used to run plugin loading hooks
|
||||
# (before_load/after_load) or build commands.
|
||||
_zplg_run_commands() {
|
||||
local var_name="$1"
|
||||
# (P) modifier lets you access the variable dynamically by its name stored in
|
||||
# another variable
|
||||
local cmd; for cmd in "${(@P)var_name}"; do
|
||||
eval "$cmd" || return "$?"
|
||||
done
|
||||
}
|
||||
|
||||
# Expands a glob pattern with the NULL_GLOB flag from the first argument and
|
||||
# puts all matched filenames into a variable from the second argument because
|
||||
# shell functions can't return arrays. This function is needed to simplify
|
||||
# handling of user-provided glob expressions because I can use LOCAL_OPTIONS
|
||||
# inside a function which reverts NULL_GLOB to its previous value as soon as
|
||||
# the function returns.
|
||||
_zplg_expand_pattern() {
|
||||
setopt localoptions nullglob
|
||||
local pattern="$1" out_var_name="$2"
|
||||
# ${~var_name} turns on globbing for this expansion, note lack of quotes: as
|
||||
# it turns out glob expansions are automatically quoted by design, and when
|
||||
# you explicitly write "${~pattern}" it is basically the same as "$pattern"
|
||||
eval "$out_var_name=(\${~pattern})"
|
||||
}
|
||||
|
||||
# Wrapper around `source` for simpler profiling and debugging. You can override
|
||||
# this function to change plugin loading strategy
|
||||
_zplg_load() {
|
||||
local script_path="$1"
|
||||
source "$script_path"
|
||||
}
|
||||
|
||||
# plugin sources {{{
|
||||
# See documentation of the `plugin` function for description.
|
||||
|
||||
_zplg_source_url_download() {
|
||||
local plugin_url="$1" plugin_dir="$2"
|
||||
wget --timestamping --directory-prefix "$plugin_dir" -- "$plugin_url"
|
||||
}
|
||||
|
||||
_zplg_source_url_upgrade() {
|
||||
_zplg_source_url_download "$@"
|
||||
}
|
||||
|
||||
_zplg_source_git_download() {
|
||||
local plugin_url="$1" plugin_dir="$2"
|
||||
git clone --depth=1 --recurse-submodules -- "$plugin_url" "$plugin_dir"
|
||||
}
|
||||
|
||||
_zplg_source_git_upgrade() {
|
||||
local plugin_url="$1" plugin_dir="$2"
|
||||
( cd "$plugin_dir" && git pull && git submodule update --init --recursive )
|
||||
}
|
||||
|
||||
_zplg_source_github_download() {
|
||||
local plugin_url="$1" plugin_dir="$2"
|
||||
_zplg_source_git_download "https://github.com/$plugin_url.git" "$plugin_dir"
|
||||
}
|
||||
|
||||
_zplg_source_github_upgrade() {
|
||||
local plugin_url="$1" plugin_dir="$2"
|
||||
_zplg_source_git_upgrade "https://github.com/$plugin_url.git" "$plugin_dir"
|
||||
}
|
||||
|
||||
# }}}
|
||||
|
||||
# The main part of my plugin manager. This function does two things: it
|
||||
# downloads a plugin if necessary and loads it into the shell. Usage is very
|
||||
# simple:
|
||||
#
|
||||
# plugin <id> <url> option_a=value_a option_b=value_b ...
|
||||
#
|
||||
# <id>
|
||||
# identifier of the plugin, alphanumeric, may contain underscores,
|
||||
# hyphens and periods, mustn't start with a period.
|
||||
#
|
||||
# <url>
|
||||
# I guess this is self-descreptive.
|
||||
#
|
||||
# Some options can be repeated (marked with a plus). Available options:
|
||||
#
|
||||
# from
|
||||
# Sets plugin source. Sources are where the plugin will be downloaded from.
|
||||
# Currently supported sources are:
|
||||
# * git - clones a repository
|
||||
# * github - clones a repository from GitHub
|
||||
# * url - simply downloads a file
|
||||
# Custom sources can easily be defined. Just create two functions:
|
||||
# `_zplg_source_${name}_download` and `_zplg_source_${name}_upgrade`. Both
|
||||
# functions take two arguments: plugin URL and plugin directory. Download
|
||||
# function must, well, download a plugin from the given URL into the given
|
||||
# directory, ugrade one, obviously, upgrades plugin inside of the given
|
||||
# directory. Please note that neither of these functions is executed INSIDE
|
||||
# of the plugin directory.
|
||||
#
|
||||
# build (+)
|
||||
# Command which builds/compiles the plugin, executed INSIDE of $plugin_dir
|
||||
# (i.e. cd $plugin_dir) once after downloading. Plugin directory can be
|
||||
# accessed through the $plugin_dir variable.
|
||||
#
|
||||
# before_load (+) and after_load (+)
|
||||
# Execute commands before and after loading of the plugin, useful when you
|
||||
# need to read plugin directory which is available through the $plugin_dir
|
||||
# variable.
|
||||
#
|
||||
# load (+) and ignore (+)
|
||||
# Globs which tell what files should be sourced (load) or ignored (ignore).
|
||||
# If glob expands to nothing (NULL_GLOB), nothing is loaded.
|
||||
#
|
||||
# Neat trick when using options: if you want to assign values using an array,
|
||||
# write it like this: option=${^array}. That way `option=` is prepended to
|
||||
# each value of `array`.
|
||||
#
|
||||
# For examples see my dotfiles: https://github.com/dmitmel/dotfiles/blob/master/zsh/plugins.zsh
|
||||
# You may ask me why did I choose to merge loading and downloading behavior
|
||||
# into one function. Well, first of all plugin manager itself becomes much
|
||||
# simpler. Second: it allows you to load plugins from any part of zshrc (which
|
||||
# is useful for me because my dotfiles are used by my friends, and they too
|
||||
# want customization) and even in an active shell.
|
||||
#
|
||||
# Oh, and I had to optimize this function, so it is very long because I merged
|
||||
# everything into one code block. I hope (this is also a message for my future
|
||||
# self) that you'll be able to read this code, I tried to comment everything.
|
||||
plugin() {
|
||||
|
||||
# parse basic arguments {{{
|
||||
|
||||
if (( $# < 2 )); then
|
||||
_zplg_error "usage: $0 <id> <url> [option...]"
|
||||
return 1
|
||||
fi
|
||||
|
||||
local plugin_id="$1"
|
||||
local plugin_url="$2"
|
||||
if [[ ! "$plugin_id" =~ '^[a-zA-Z0-9_\-][a-zA-Z0-9._\-]*$' ]]; then
|
||||
_zplg_error "invalid plugin ID"
|
||||
return 1
|
||||
fi
|
||||
if [[ -z "$plugin_url" ]]; then
|
||||
_zplg_error "invalid plugin URL"
|
||||
return 1
|
||||
fi
|
||||
|
||||
# Don't even try to continue if the plugin has already been loaded. This is
|
||||
# not or problem. Plugin manager loads plugins and shouldn't bother
|
||||
# unloading them.
|
||||
if _zplg_is_plugin_loaded "$plugin_id"; then
|
||||
_zplg_error "plugin $plugin_id has already been loaded"
|
||||
return 1
|
||||
fi
|
||||
|
||||
# }}}
|
||||
|
||||
# parse options {{{
|
||||
|
||||
local plugin_from="github"
|
||||
local -a plugin_build plugin_before_load plugin_after_load plugin_load plugin_ignore
|
||||
|
||||
local option key value; shift 2; for option in "$@"; do
|
||||
# globs are faster than regular expressions
|
||||
if [[ "$option" != *?=?* ]]; then
|
||||
_zplg_error "options must have the following format: <key>=<value>"
|
||||
return 1
|
||||
fi
|
||||
|
||||
# split 'option' at the first occurence of '='
|
||||
key="${option%%=*}" value="${option#*=}"
|
||||
case "$key" in
|
||||
from)
|
||||
eval "plugin_$key=\"\$value\"" ;;
|
||||
build|before_load|after_load|load|ignore)
|
||||
eval "plugin_$key+=(\"\$value\")" ;;
|
||||
*)
|
||||
_zplg_error "unknown option: $key"
|
||||
return 1 ;;
|
||||
esac
|
||||
done; unset option key value
|
||||
|
||||
# }}}
|
||||
|
||||
if (( ${#plugin_load} == 0 )); then
|
||||
# default loading patterns:
|
||||
# - *.plugin.zsh for most plugins and Oh-My-Zsh ones
|
||||
# - *.zsh-theme for most themes and Oh-My-Zsh ones
|
||||
# - init.zsh for Prezto plugins
|
||||
# ([1]) means "expand only to the first match"
|
||||
plugin_load=("(*.plugin.zsh|*.zsh-theme|init.zsh)([1])")
|
||||
fi
|
||||
|
||||
# download plugin {{{
|
||||
|
||||
local plugin_dir="$_ZPLG_PLUGINS_DIR/$plugin_id"
|
||||
# simple check whether the plugin directory exists is enough for me
|
||||
if [[ ! -d "$plugin_dir" ]]; then
|
||||
_zplg_log "downloading $plugin_id"
|
||||
_zplg_source_"$plugin_from"_download "$plugin_url" "$plugin_dir" || return "$?"
|
||||
|
||||
if (( ${#plugin_build} > 0 )); then
|
||||
_zplg_log "building $plugin_id"
|
||||
( cd "$plugin_dir" && _zplg_run_commands plugin_build ) || return "$?"
|
||||
fi
|
||||
fi
|
||||
|
||||
# }}}
|
||||
|
||||
# load plugin {{{
|
||||
|
||||
_zplg_run_commands plugin_before_load || return "$?"
|
||||
|
||||
local load_pattern ignore_pattern script_path; local -a script_paths
|
||||
for load_pattern in "${plugin_load[@]}"; do
|
||||
_zplg_expand_pattern "$plugin_dir/$load_pattern" script_paths
|
||||
for script_path in "${script_paths[@]}"; do
|
||||
for ignore_pattern in "${plugin_ignore[@]}"; do
|
||||
if [[ "$script_path" == "$plugin_dir/"${~ignore_pattern} ]]; then
|
||||
# continue outer loop
|
||||
continue 2
|
||||
fi
|
||||
done
|
||||
_zplg_debug "sourcing $script_path"
|
||||
_zplg_load "$script_path" || return "$?"
|
||||
done
|
||||
done; unset load_pattern ignore_pattern script_path
|
||||
|
||||
_zplg_run_commands plugin_after_load || return "$?"
|
||||
|
||||
# plugin has finally been loaded, we can add it to $ZPLG_LOADED_PLUGINS
|
||||
ZPLG_LOADED_PLUGINS+=("$plugin_id")
|
||||
ZPLG_LOADED_PLUGIN_URLS[$plugin_id]="$plugin_url"
|
||||
ZPLG_LOADED_PLUGIN_SOURCES[$plugin_id]="$plugin_from"
|
||||
|
||||
# HORRIBLE HACK: because you can't store arrays as values in associative
|
||||
# arrays, I simply quote every element with the (@q) modifier, then join
|
||||
# quoted ones into a string and put this "encoded" string into the
|
||||
# associative array. Terrible idea? Maybe. Does it work? YES!!!
|
||||
if (( ${#plugin_build} > 0 )); then
|
||||
# extra ${...} is needed to turn array into a string by joining it with
|
||||
# spaces
|
||||
ZPLG_LOADED_PLUGIN_BUILD_CMDS[$plugin_id]="${${(@q)plugin_build}}"
|
||||
unset plugin_build_quoted
|
||||
fi
|
||||
|
||||
# }}}
|
||||
|
||||
}
|
||||
|
||||
# helper functions for plugin configuration {{{
|
||||
|
||||
# Simplifies modification of path variables (path/fpath/manpath etc) in
|
||||
# after_load and before_load hooks.
|
||||
plugin-cfg-path() {
|
||||
if (( $# < 2 )); then
|
||||
_zplg_error "usage: $0 <var_name> prepend|append <value...>"
|
||||
return 1
|
||||
fi
|
||||
|
||||
if [[ -z "$plugin_dir" ]]; then
|
||||
_zplg_error "this function is intended to be used in after_load or before_load hooks"
|
||||
return 1
|
||||
fi
|
||||
|
||||
local var_name="$1" operator="$2"; shift 2; local values=("$@")
|
||||
|
||||
if [[ "$var_name" != *path || "${(Pt)var_name}" != array* ]]; then
|
||||
_zplg_error "unknown path variable $var_name"
|
||||
return 1
|
||||
fi
|
||||
|
||||
case "$operator" in
|
||||
prepend) eval "$var_name=(\"\$plugin_dir/\"\${^values} \${$var_name[@]})" ;;
|
||||
append) eval "$var_name=(\${$var_name[@]} \"\$plugin_dir/\"\${^values})" ;;
|
||||
*) _zplg_error "unknown $0 operator $operator"
|
||||
esac
|
||||
}
|
||||
|
||||
# }}}
|
||||
|
||||
# Exits with success code 0 if the plugin is loaded, otherwise exits with error
|
||||
# code 1. To be used in `if` statements.
|
||||
_zplg_is_plugin_loaded() {
|
||||
local plugin_id="$1"
|
||||
# (ie) are subscript flags:
|
||||
# - i returns index of the value (reverse subscripting) in the square
|
||||
# brackets (subscript)
|
||||
# - e disables patterns matching, so plain string matching is used instead
|
||||
# unlike normal programming languages, if the value is not found an index
|
||||
# greater than the length of the array is returned
|
||||
(( ${ZPLG_LOADED_PLUGINS[(ie)$plugin_id]} <= ${#ZPLG_LOADED_PLUGINS} ))
|
||||
}
|
||||
|
||||
# Here are some useful commands for managing plugins. I chose to make them
|
||||
# functions because:
|
||||
# 1. automatic completion
|
||||
# 2. automatic correction
|
||||
|
||||
# Prints IDs of all loaded plugins.
|
||||
plugin-list() {
|
||||
# (F) modifier joins an array with newlines
|
||||
print "${(F)ZPLG_LOADED_PLUGINS}"
|
||||
}
|
||||
|
||||
# Upgrades all plugins if no arguments are given, otherwise upgrades plugins by
|
||||
# their IDs.
|
||||
plugin-upgrade() {
|
||||
local plugin_ids_var
|
||||
if (( $# > 0 )); then
|
||||
plugin_ids_var="@"
|
||||
else
|
||||
plugin_ids_var="ZPLG_LOADED_PLUGINS"
|
||||
fi
|
||||
|
||||
local plugin_id plugin_url plugin_from plugin_dir; local -a plugin_build
|
||||
# for description of the (P) modifier see _zplg_run_commands
|
||||
for plugin_id in "${(@P)plugin_ids_var}"; do
|
||||
if ! _zplg_is_plugin_loaded "$plugin_id"; then
|
||||
_zplg_error "unknown plugin $plugin_id"
|
||||
return 1
|
||||
fi
|
||||
|
||||
plugin_url="${ZPLG_LOADED_PLUGIN_URLS[$plugin_id]}"
|
||||
plugin_from="${ZPLG_LOADED_PLUGIN_SOURCES[$plugin_id]}"
|
||||
plugin_dir="$_ZPLG_PLUGINS_DIR/$plugin_id"
|
||||
|
||||
_zplg_log "upgrading $plugin_id"
|
||||
_zplg_source_"$plugin_from"_upgrade "$plugin_url" "$plugin_dir" || return "$?"
|
||||
|
||||
if (( ${+ZPLG_LOADED_PLUGIN_BUILD_CMDS[$plugin_id]} )); then
|
||||
# TERRIBLE HACK continued: this monstrosity is used to "decode" build
|
||||
# commands. See ending of the `plugin` function for "encoding" procedure.
|
||||
# First, I get encoded string. Then with the (z) modifier I split it into
|
||||
# array taking into account quoting. Then with the (Q) modifier I unquote
|
||||
# every value.
|
||||
plugin_build=("${(@Q)${(z)${ZPLG_LOADED_PLUGIN_BUILD_CMDS[$plugin_id]}}}")
|
||||
_zplg_log "building $plugin_id"
|
||||
( cd "$plugin_dir" && _zplg_run_commands plugin_build ) || return "$?"
|
||||
fi
|
||||
done
|
||||
}
|
||||
|
||||
# Reinstall plugins by IDs.
|
||||
plugin-reinstall() {
|
||||
if (( $# == 0 )); then
|
||||
_zplg_error "usage: $0 <plugin...>"
|
||||
return 1
|
||||
fi
|
||||
|
||||
local plugin_id plugin_url plugin_from plugin_dir; local -a plugin_build
|
||||
for plugin_id in "$@"; do
|
||||
if ! _zplg_is_plugin_loaded "$plugin_id"; then
|
||||
_zplg_error "unknown plugin $plugin_id"
|
||||
return 1
|
||||
fi
|
||||
|
||||
plugin_url="${ZPLG_LOADED_PLUGIN_URLS[$plugin_id]}"
|
||||
plugin_from="${ZPLG_LOADED_PLUGIN_SOURCES[$plugin_id]}"
|
||||
plugin_dir="$_ZPLG_PLUGINS_DIR/$plugin_id"
|
||||
|
||||
_zplg_log "removing $plugin_id"
|
||||
rm -rf "$plugin_dir"
|
||||
|
||||
_zplg_log "downloading $plugin_id"
|
||||
_zplg_source_"$plugin_from"_download "$plugin_url" "$plugin_dir" || return "$?"
|
||||
|
||||
if (( ${+ZPLG_LOADED_PLUGIN_BUILD_CMDS[$plugin_id]} )); then
|
||||
# for description of this terrible hack see the ending of the
|
||||
# `plugin-upgrade` function
|
||||
plugin_build=("${(@Q)${(z)${ZPLG_LOADED_PLUGIN_BUILD_CMDS[$plugin_id]}}}")
|
||||
_zplg_log "building $plugin_id"
|
||||
( cd "$plugin_dir" && _zplg_run_commands plugin_build ) || return "$?"
|
||||
fi
|
||||
done
|
||||
}
|
||||
|
||||
# Clears directories of plugins by their IDs.
|
||||
plugin-purge() {
|
||||
if (( $# == 0 )); then
|
||||
_zplg_error "usage: $0 <plugin...>"
|
||||
return 1
|
||||
fi
|
||||
|
||||
for plugin_id in "$@"; do
|
||||
if ! _zplg_is_plugin_loaded "$plugin_id"; then
|
||||
_zplg_error "unknown plugin $plugin_id"
|
||||
return 1
|
||||
fi
|
||||
|
||||
local plugin_dir="$_ZPLG_PLUGINS_DIR/$plugin_id"
|
||||
|
||||
_zplg_log "removing $plugin_id"
|
||||
rm -rf "$plugin_dir"
|
||||
done
|
||||
}
|
||||
|
|
@ -9,7 +9,6 @@ done
|
|||
|
||||
command_exists rbenv && eval "$(rbenv init -)"
|
||||
|
||||
export BASE16_SHELL="$HOME/.zgen/chriskempson/base16-shell-master"
|
||||
BASE16_SHELL_profile_helper="$BASE16_SHELL/profile_helper.sh"
|
||||
[[ -n "$PS1" && -r "$BASE16_SHELL_profile_helper" ]] && eval "$("$BASE16_SHELL_profile_helper")"
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue