zsh_dots 0.5.0

data/vendor/antigen.zsh

@@ -0,0 +1,251 @@
+#!/bin/zsh
+#
+# Antigen is a bundled plugin loader.
+
+# Each line in this string has the following entries separated by a space
+# character.
+# <repo-url>, <plugin-location>, <bundle-type>
+# FIXME: Is not kept local by zsh!
+local _ANTIGEN_BUNDLE_RECORD=""
+
+# Syntaxes
+#   antigen-bundle <url> [<loc>=/]
+antigen-bundle () {
+
+    # Bundle spec arguments' default values.
+    local url="$ANTIGEN_DEFAULT_REPO_URL"
+    local loc=/
+    local btype=plugin
+
+    # Set spec values based on the positional arguments.
+    local position_args='url loc'
+    local i=1
+    while ! [[ -z $1 || $1 == --*=* ]]; do
+        local arg_name="$(echo "$position_args" | cut -d\  -f$i)"
+        local arg_value="$1"
+        eval "local $arg_name='$arg_value'"
+        shift
+        i=$(($i + 1))
+    done
+
+    # Check if url is just the plugin name. Super short syntax.
+    if [[ "$url" != */* ]]; then
+        loc="plugins/$url"
+        url="$ANTIGEN_DEFAULT_REPO_URL"
+    fi
+
+    # Set spec values from keyword arguments, if any. The remaining arguments
+    # are all assumed to be keyword arguments.
+    while [[ $1 == --*=* ]]; do
+        local arg_name="$(echo "$1" | cut -d= -f1 | sed 's/^--//')"
+        local arg_value="$(echo "$1" | cut -d= -f2)"
+        eval "local $arg_name='$arg_value'"
+        shift
+    done
+
+    # Resolve the url.
+    if [[ $url != git://* && $url != https://* && $url != /* ]]; then
+        url="${url%.git}"
+        url="https://github.com/$url.git"
+    fi
+
+    # Add it to the record.
+    _ANTIGEN_BUNDLE_RECORD="$_ANTIGEN_BUNDLE_RECORD\n$url $loc $btype"
+
+    -antigen-ensure-repo "$url"
+
+    -antigen-load "$url" "$loc" "$btype"
+
+}
+
+antigen-bundles () {
+    # Bulk add many bundles at one go. Empty lines and lines starting with a `#`
+    # are ignored. Everything else is given to `antigen-bundle` as is, no
+    # quoting rules applied.
+
+    local line
+
+    grep -v '^\s*$\|^#' | while read line; do
+        # Using `eval` so that we can use the shell-style quoting in each line
+        # piped to `antigen-bundles`.
+        eval "antigen-bundle $line"
+    done
+}
+
+antigen-update () {
+    # Update your bundles, i.e., `git pull` in all the plugin repos.
+    -antigen-echo-record | awk '{print $1}' | sort -u | while read url; do
+        -antigen-ensure-repo --update "$url"
+    done
+}
+
+-antigen-get-clone-dir () {
+    # Takes a repo url and gives out the path that this url needs to be cloned
+    # to. Doesn't actually clone anything.
+    # TODO: Memoize?
+    echo -n $ADOTDIR/repos/
+    echo "$1" | sed \
+        -e 's/\.git$//' \
+        -e 's./.-SLASH-.g' \
+        -e 's.:.-COLON-.g'
+}
+
+-antigen-get-clone-url () {
+    # Takes a repo's clone dir and gives out the repo's original url that was
+    # used to create the given directory path.
+    # TODO: Memoize?
+    echo "$1" | sed \
+        -e "s:^$ADOTDIR/repos/::" \
+        -e 's/$/.git/' \
+        -e 's.-SLASH-./.g' \
+        -e 's.-COLON-.:.g'
+}
+
+-antigen-ensure-repo () {
+
+    local update=false
+    if [[ $1 == --update ]]; then
+        update=true
+        shift
+    fi
+
+    local url="$1"
+    local clone_dir="$(-antigen-get-clone-dir $url)"
+
+    if [[ ! -d $clone_dir ]]; then
+        git clone "$url" "$clone_dir"
+    elif $update; then
+        git --git-dir "$clone_dir/.git" --work-tree "$clone_dir" pull
+    fi
+
+}
+
+-antigen-load () {
+
+    local url="$1"
+    local location="$(-antigen-get-clone-dir "$url")/$2"
+    local btype="$3"
+
+    if [[ $btype == theme ]]; then
+
+        # Of course, if its a theme, the location would point to the script
+        # file.
+        source "$location"
+
+    else
+
+        # Source the plugin script
+        # FIXME: I don't know. Looks very very ugly. Needs a better
+        # implementation once tests are ready.
+        local script_loc="$(ls "$location" | grep -m1 '.plugin.zsh$')"
+        if [[ -f $script_loc ]]; then
+            # If we have a `*.plugin.zsh`, source it.
+            source "$script_loc"
+        elif [[ ! -z "$(ls "$location" | grep -m1 '.zsh$')" ]]; then
+            # If there is no `*.plugin.zsh` file, source *all* the `*.zsh`
+            # files.
+            for script ($location/*.zsh) source "$script"
+        elif [[ ! -z "$(ls "$location" | grep -m1 '.sh$')" ]]; then
+            # If there are no `*.zsh` files either, we look for and source any
+            # `*.sh` files instead.
+            for script ($location/*.sh) source "$script"
+        fi
+
+        # Add to $fpath, for completion(s)
+        fpath=($location $fpath)
+
+    fi
+
+}
+
+antigen-cleanup () {
+
+    if [[ ! -d "$ADOTDIR/repos" || -z "$(ls "$ADOTDIR/repos/")" ]]; then
+        echo "You don't have any bundles."
+        return 0
+    fi
+
+    # Find directores in ADOTDIR/repos, that are not in the bundles record.
+    local unused_clones="$(comm -13 \
+        <(-antigen-echo-record | awk '{print $1}' | sort -u) \
+        <(ls "$ADOTDIR/repos" | while read line; do
+                -antigen-get-clone-url "$line"
+            done))"
+
+    if [[ -z $unused_clones ]]; then
+        echo "You don't have any unidentified bundles."
+        return 0
+    fi
+
+    echo 'You have clones for the following repos, but are not used.'
+    echo "$unused_clones" | sed 's/^/  /'
+
+    echo -n '\nDelete them all? [y/N] '
+    if read -q; then
+        echo
+        echo
+        echo "$unused_clones" | while read url; do
+            echo -n "Deleting clone for $url..."
+            rm -rf "$(-antigen-get-clone-dir $url)"
+            echo ' done.'
+        done
+    else
+        echo
+        echo Nothing deleted.
+    fi
+}
+
+antigen-lib () {
+    antigen-bundle --loc=lib
+}
+
+antigen-theme () {
+    local name="${1:-robbyrussell}"
+    antigen-bundle --loc=themes/$name.zsh-theme --btype=theme
+}
+
+antigen-apply () {
+    # Initialize completion.
+    # TODO: Only load completions if there are any changes to the bundle
+    # repositories.
+    compinit -i
+}
+
+antigen-list () {
+    # List all currently installed bundles
+    if [[ -z "$_ANTIGEN_BUNDLE_RECORD" ]]; then
+        echo "You don't have any bundles." >&2
+        return 1
+    else
+        -antigen-echo-record
+    fi
+}
+
+# Echo the bundle specs as in the record. The first line is not echoed since it
+# is a blank line.
+-antigen-echo-record () {
+    echo "$_ANTIGEN_BUNDLE_RECORD" | sed -n '1!p'
+}
+
+-antigen-env-setup () {
+    # Pre-startup initializations
+    -set-default ANTIGEN_DEFAULT_REPO_URL \
+        https://github.com/robbyrussell/oh-my-zsh.git
+    -set-default ADOTDIR $HOME/.antigen
+
+    # Load the compinit module
+    autoload -U compinit
+
+    # Without the following, `compdef` function is not defined.
+    compinit -i
+}
+
+# Same as `export $1=$2`, but will only happen if the name specified by `$1` is
+# not already set.
+-set-default () {
+    local arg_name="$1"
+    local arg_value="$2"
+    eval "test -z \"\$$arg_name\" && export $arg_name='$arg_value'"
+}
+
+-antigen-env-setup

data/vendor/oh-my-zsh/check_for_upgrade.sh

@@ -0,0 +1,45 @@
+#!/bin/sh
+
+function _current_epoch() {
+  echo $(($(date +%s) / 60 / 60 / 24))
+}
+
+function _update_zsh_update() {
+  echo "LAST_EPOCH=$(_current_epoch)" > ~/.zsh-update
+}
+
+function _upgrade_zsh() {
+  /usr/bin/env ZSH=$ZSH /bin/sh $ZSH/tools/upgrade.sh
+  # update the zsh file
+  _update_zsh_update
+}
+
+if [ -f ~/.zsh-update ]
+then
+  . ~/.zsh-update
+
+  if [[ -z "$LAST_EPOCH" ]]; then
+    _update_zsh_update && return 0;
+  fi
+
+  epoch_diff=$(($(_current_epoch) - $LAST_EPOCH))
+  if [ $epoch_diff -gt 6 ]
+  then
+    if [ "$DISABLE_UPDATE_PROMPT" = "true" ]
+    then
+      _upgrade_zsh
+    else
+      echo "Would you like to check for updates to DOTS?"
+      echo "Type Y to update ~/.dots: \c"
+      read line
+      if [ "$line" = Y ] || [ "$line" = y ]
+      then
+        _upgrade_zsh
+      fi
+    fi
+  fi
+else
+  # create the zsh file
+  _update_zsh_update
+fi
+

data/vendor/oh-my-zsh/install.sh

@@ -0,0 +1,43 @@
+#
+# DOTS Installer
+#
+
+if [ -d ~/.dots ]
+then
+  echo "Error: You already have DOTS installed."
+  cd ~/.dots
+  exit
+fi
+
+echo "\033[0;34mInstalling DOTS...\033[0m"
+/usr/bin/env git clone https://github.com/tubbo/dots.git ~/.dots
+
+echo "\033[0;34mLooking for an existing zsh config...\033[0m"
+if [ -f ~/.zshrc ] || [ -h ~/.zshrc ]
+then
+  echo "\033[0;33mFound ~/.zshrc.\033[0m \033[0;32]Backing up to ~/.zshrc.pre-dots\033[0m";
+  cp ~/.zshrc ~/.zshrc.pre-dots;
+  cp ~/.zshrc ~/.dots/config/zshrc;
+  rm ~/.zshrc;
+else
+  echo "\033[0;34mCreating a template ZSH config from our example...\033[0m"
+  cp ~/.dots/templates/zshrc.zsh-template ~/.zshrc
+fi
+
+echo "\033[0;34m Linking ZSH config...\033[0m"
+ln -s ~/.dots/config/zshrc ~/.zshrc;
+
+echo "\033[0;34m Synchronizing your custom binaries...\033[0m"
+cp -R $HOME/bin/** $DOTS/bin
+mv $HOME/bin $HOME/bin-pre-dots
+ln -s $HOME/bin $DOTS/bin
+
+echo "\033[0;34mCopying your current PATH and adding it to the end of ~/.zshrc for you.\033[0m"
+echo "export PATH=$PATH" >> ~/.zshrc
+
+echo "\033[0;34mTime to change your default shell to zsh!\033[0m"
+chsh -s `which zsh`
+
+echo "\n\n \033[0;32mCongratulations! We like yo DOTS!\033[0m"
+/usr/bin/env zsh
+source ~/.zshrc

data/vendor/oh-my-zsh/require_tool.sh

@@ -0,0 +1,161 @@
+__require_tool_version_compare ()
+{
+  (
+    # Locally ignore failures, otherwise we'll exit whenever $1 and $2
+    # are not equal!
+    set +e
+
+awk_strverscmp='
+  # Use only awk features that work with 7th edition Unix awk (1978).
+  # My, what an old awk you have, Mr. Solaris!
+  END {
+    while (length(v1) || length(v2)) {
+      # Set d1 to be the next thing to compare from v1, and likewise for d2.
+      # Normally this is a single character, but if v1 and v2 contain digits,
+      # compare them as integers and fractions as strverscmp does.
+      if (v1 ~ /^[0-9]/ && v2 ~ /^[0-9]/) {
+	# Split v1 and v2 into their leading digit string components d1 and d2,
+	# and advance v1 and v2 past the leading digit strings.
+	for (len1 = 1; substr(v1, len1 + 1) ~ /^[0-9]/; len1++) continue
+	for (len2 = 1; substr(v2, len2 + 1) ~ /^[0-9]/; len2++) continue
+	d1 = substr(v1, 1, len1); v1 = substr(v1, len1 + 1)
+	d2 = substr(v2, 1, len2); v2 = substr(v2, len2 + 1)
+	if (d1 ~ /^0/) {
+	  if (d2 ~ /^0/) {
+	    # Compare two fractions.
+	    while (d1 ~ /^0/ && d2 ~ /^0/) {
+	      d1 = substr(d1, 2); len1--
+	      d2 = substr(d2, 2); len2--
+	    }
+	    if (len1 != len2 && ! (len1 && len2 && substr(d1, 1, 1) == substr(d2, 1, 1))) {
+	      # The two components differ in length, and the common prefix
+	      # contains only leading zeros.  Consider the longer to be less.
+	      d1 = -len1
+	      d2 = -len2
+	    } else {
+	      # Otherwise, compare as strings.
+	      d1 = "x" d1
+	      d2 = "x" d2
+	    }
+	  } else {
+	    # A fraction is less than an integer.
+	    exit 1
+	  }
+	} else {
+	  if (d2 ~ /^0/) {
+	    # An integer is greater than a fraction.
+	    exit 2
+	  } else {
+	    # Compare two integers.
+	    d1 += 0
+	    d2 += 0
+	  }
+	}
+      } else {
+	# The normal case, without worrying about digits.
+	if (v1 == "") d1 = v1; else { d1 = substr(v1, 1, 1); v1 = substr(v1,2) }
+	if (v2 == "") d2 = v2; else { d2 = substr(v2, 1, 1); v2 = substr(v2,2) }
+      }
+      if (d1 < d2) exit 1
+      if (d1 > d2) exit 2
+    }
+  }
+'
+    awk "$awk_strverscmp" v1="$1" v2="$2" /dev/null
+    case $? in
+      1)  echo '<';;
+      0)  echo '=';;
+      2)  echo '>';;
+    esac
+  )
+}
+
+
+__require_tool_fatal ()
+{
+    echo $@ >/dev/stderr
+    return 1
+}
+
+# Usage: require_tool program version
+# Returns: 0 if $1 version if greater equals than $2, 1 otherwise.
+# In case of error, message is written on error output.
+#
+# Example: require_tool gcc 4.6
+# Use GCC environment variable if defined instead of lookup for the tool
+# in the environment.
+require_tool ()
+{
+  envvar_name=$(echo $1 | tr '[:lower:]' '[:upper:]')
+  tool=$(printenv $envvar_name || echo $1)
+  local version=$($tool --version 2>/dev/null| \
+    sed -n 's/.*[^0-9.]\([0-9]*\.[0-9.]*\).*/\1/p;q')
+  if test x"$version" = x ; then
+      echo "$tool is required" >/dev/stderr
+      return 1
+  fi
+  case $(__require_tool_version_compare "$2" "$version") in
+    '>')
+	  echo "$1 $2 or better is required: this is $tool $version" >/dev/stderr
+	  return 1
+	  ;;
+  esac
+}
+
+usage() {
+    cat <<EOF
+NAME
+    require_tool.sh - Ensure version of a tool is greater than the one expected
+
+SYNOPSYS
+    require_tool.sh [ -h ]
+                    [ --help ]
+                    [ TOOL MIN_VERSION ]
+
+DESCRIPTION
+    TOOL is the name or path of the program to check. If the name is specified, its
+    path is deduced from PATH environment variable. If environment variable TOOL
+    (in upper-case characters) is defined, considers its value as path to the tool.
+
+    MIN_VERSION is a string representing the minimum required version.
+
+BEHAVIOR
+    * locate path to the program.
+    * execute $ TOOL_PATH --version
+    * extract version from standard output.
+    * compare this version to the expected one.
+
+OPTIONS
+    -h --help
+        Display this message and exit 0
+
+ERRORS
+    if program is not found or its version is prior to expected version,
+    a message is written to error output.
+
+EXIT VALUE
+    returns 0 if program version if greater equals than expected version,
+    returns 1 otherwise.
+
+EXAMPLE
+    $ require_tool.sh emacs 23
+    $ CC=g++ require_tool.sh cc 4.6
+    $ require_tool.sh zsh 4.5
+
+EOF
+}
+
+for arg in $@; do
+    case $arg in
+        -h|--help)
+            usage
+            exit 0
+            ;;
+    esac
+done
+if [ $# -gt 2 ] ; then
+    echo "ERROR: expecting 2 parameters. Please see option --help"
+    exit 1
+fi
+
+require_tool $@

data/vendor/oh-my-zsh/uninstall.sh

@@ -0,0 +1,20 @@
+echo "Removing ~/.dots"
+if [[ -d ~/.dots ]]
+then
+  rm -rf ~/.dots
+fi
+
+echo "Looking for an existing zsh config..."
+if [ -f ~/.zshrc.pre-dots ] || [ -h ~/.zshrc.pre-dots ]
+then
+  echo "Restored ~/.zshrc from ~/.zshrc.pre-dots";
+  rm ~/.zshrc;
+  cp ~/.zshrc.pre-dots ~/.zshrc;
+  source ~/.zshrc;
+else
+  echo "Switching back to bash"
+  chsh -s /bin/bash
+  source /etc/profile
+fi
+
+echo "Thanks for using DOTS, it's been uninstalled."

data/vendor/oh-my-zsh/upgrade.sh

@@ -0,0 +1,6 @@
+# Upgrade DOTS from GitHub
+current_path=`pwd`
+printf '\033[0;34m%s\033[0m\n' "Upgrading DOTS from upstream..."
+( cd $ZSH && git pull origin master )
+printf '\033[0;34m%s\033[0m\n' 'Your DOTS have been upgraded to the newest version! https://github.com/tubbo/dots for more information.'
+cd "$current_path"

data/zsh_dots.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/ruby/dots/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Tom Scott"]
+  gem.email         = ["tubbo@psychedeli.ca"]
+  gem.description   = %q{DOTS is an advanced ZSH framework.}
+  gem.summary       = <<-TEXT
+  DOTS is an advanced ZSH framework. It abstracts a lot of hard-to-remember commands away from you
+  and leaves you with fully-documented, easy-to-remember, plain-english aliases for common tasks.
+  Supporting the Antigen framework for plugins, it's meant to be easy to install and light-weight in
+  code, but able to support and replicate an entire home directory worth of dotfiles, essentially
+  enabling you to take your shell environment "on the road" in a Github repository.
+  TEXT
+  gem.homepage      = "http://tubbo.github.com/dots"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(spec)/})
+  gem.name          = "zsh_dots"
+  gem.require_paths = ["lib/ruby"]
+  gem.version       = Dots::VERSION
+
+  gem.add_runtime_dependency 'thor'
+  gem.add_runtime_dependency 'activemodel'
+
+  gem.add_development_dependency 'rake'
+end