Bump version to 0.12.3

Resolves #79.

When tmux is compiled from source the version string is "master" which
the tmux-version command didn't deal with correctly.

.gitignore

@@ -0,0 +1,3 @@
+test-runner.sh
+test/assert.sh
+test/stub.sh

.travis.yml

@@ -0,0 +1,16 @@
+language: c
+env:
+  - TMUX_VERSION="1.6"
+  - TMUX_VERSION="1.7"
+  - TMUX_VERSION="1.8"
+  - TMUX_VERSION="1.9a"
+  - TMUX_VERSION="2.0"
+before_install:
+  - sudo apt-get update
+  - sudo apt-get install -y bc build-essential libevent-dev libncurses5-dev
+  - wget https://github.com/tmux/tmux/releases/download/${TMUX_VERSION}/tmux-${TMUX_VERSION}.tar.gz
+  - tar -zxf tmux-${TMUX_VERSION}.tar.gz
+  - cd tmux-${TMUX_VERSION}
+  - ./configure && make && sudo make install
+  - cd ..
+script: make test

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2012 Jim Myhrberg.
+Copyright (c) 2014 Jim Myhrberg.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

Makefile

@@ -0,0 +1,50 @@
+test: bootstrap
+	./test-runner.sh
+
+bootstrap: test-runner.sh test/assert.sh test/stub.sh
+clean: remove_test-runner.sh remove_test/assert.sh remove_test/stub.sh
+update: update_test-runner.sh update_test/assert.sh update_test/stub.sh
+
+test-runner.sh:
+	echo "fetching test-runner.sh..." && \
+	curl -s -L -o test-runner.sh \
+		https://github.com/jimeh/test-runner.sh/raw/v0.2.0/test-runner.sh && \
+	chmod +x test-runner.sh
+
+remove_test-runner.sh:
+	( \
+		test -f "test-runner.sh" && rm "test-runner.sh" && \
+		echo "removed test-runner.sh"\
+	) || exit 0
+
+update_test-runner.sh: remove_test-runner.sh test-runner.sh
+
+test/assert.sh:
+	echo "fetching test/assert.sh..." && \
+	curl -s -L -o test/assert.sh \
+		https://raw.github.com/lehmannro/assert.sh/v1.0.2/assert.sh
+
+remove_test/assert.sh:
+	test -f "test/assert.sh" && \
+		rm "test/assert.sh" && \
+		echo "removed test/assert.sh"
+
+update_test/assert.sh: remove_test/assert.sh test/assert.sh
+
+test/stub.sh:
+	echo "fetching test/stub.sh..." && \
+	curl -s -L -o test/stub.sh \
+		https://raw.github.com/jimeh/stub.sh/v1.0.1/stub.sh
+
+remove_test/stub.sh:
+	test -f "test/stub.sh" && \
+		rm "test/stub.sh" && \
+		echo "removed test/stub.sh"
+
+update_test/stub.sh: remove_test/stub.sh test/stub.sh
+
+.SILENT:
+.PHONY: test bootstrap clean \
+	remove_test-runner.sh update_test-runner.sh \
+	remove_test/assert.sh update_test/assert.sh \
+	remove_test/stub.sh   update_test/stub.sh

README.md

@@ -1,11 +1,11 @@
-# Tmuxifier
+# Tmuxifier [![Build Status](https://api.travis-ci.org/jimeh/tmuxifier.svg)](https://travis-ci.org/jimeh/tmuxifier)
 
-Tmuxify your Tmux. Create, edit, mangage and load complex Tmux session, window
+Tmuxify your Tmux. Create, edit, manage and load complex Tmux session, window
 and pane configurations with ease.
 
 In short, Tmuxifier allows you to easily create, edit, and load "layout"
 files, which are simple shell scripts where you use the `tmux` command and
-helper commands provided by tmuxifier to manage Tmux sessions and windows
+helper commands provided by `tmuxifier` to manage Tmux sessions and windows
 
 ### Window Layouts
 
@@ -33,17 +33,16 @@ looks like:
 ```bash
 window_root "~/Desktop"
 new_window "Example Window"
-tmux split-window -t "$session:$window.0" -v -p 20 "watch -t date"
+split_v 20
-tmux split-window -t "$session:$window.1" -h -p 60
+run_cmd "watch -t date"
-tmux select-pane -t "$session:$window.0"
+split_h 60
+select_pane 0
 ```
 
 You can then load that window layout into a new window in the
 current tmux session using:
 
-```bash
+    tmuxifier load-window example
-tmuxifier load-window example
-```
 
 Which will yield a Tmux window looking like this:
 
@@ -51,14 +50,86 @@ Which will yield a Tmux window looking like this:
 
 ## Installation
 
+Clone the repo to your machine:
+
+    git clone https://github.com/jimeh/tmuxifier.git ~/.tmuxifier
+
+Then add `$HOME/.tmuxifier/bin` to your PATH to make the `tmuxifier` executable
+available to you:
+
+__In bash & zsh:__
+
 ```bash
-git clone https://github.com/jimeh/tmuxifier.git ~/.tmuxifier
+export PATH="$HOME/.tmuxifier/bin:$PATH"
 ```
 
-And add the following to your `~/.profile`, `~/.bash_profile` or equivalent:
+__In tcsh:__
+
+```tcsh
+set path = ( "~/.tmuxifier/bin" $path )
+```
+
+__In fish:__
 
 ```bash
-[[ -s "$HOME/.tmuxifier/init.sh" ]] && source "$HOME/.tmuxifier/init.sh"
+set -gx PATH "~/.tmuxifier/bin" $PATH
+```
+
+### Custom Installation Path
+
+To install Tmuxifier somewhere else than the suggested `~/.tmuxifier`, simply
+clone the repository to your custom location, and ensure the `bin` folder is
+added to your PATH making the `tmuxifier` executable available to you.
+
+## Setup
+
+__In bash & zsh:__
+
+And add the following to your `~/.profile`, `~/.bash_profile`, `~/.zshrc` or
+equivalent:
+
+```bash
+eval "$(tmuxifier init -)"
+```
+
+__In tcsh:__
+
+Add the following to your `~/.cshrc`, `~/.tcshrc` or equivalent:
+
+```tcsh
+eval `tmuxifier init -`
+```
+
+__In fish:__
+
+And add the following to your `~/.config/fish/config.fish` or equivalent:
+
+```bash
+eval (tmuxifier init -)
+```
+
+### Custom Tmux Arguments
+
+If you need to pass custom arguments to `tmux` itself, you can do so by
+setting the `TMUXIFIER_TMUX_OPTS` environment variable. For example to set
+custom arguments globally:
+
+```bash
+export TMUXIFIER_TMUX_OPTS="-L my-awesome-socket-name"
+eval "$(tmuxifier init -)"
+```
+
+And/or specify dynamically when calling `tmuxifier`:
+
+```bash
+TMUXIFIER_TMUX_OPTS="-L other-socket" tmuxifier load-session welcome
+```
+
+## Updating
+
+```bash
+cd ~/.tmuxifier # or where you've cloned tmuxifier to
+git pull
 ```
 
 ## Usage
@@ -113,17 +184,6 @@ in it.
 
 ## Configure & Customize
 
-### Custom Installaton Path
-
-To install Tmuxifier to a custom path, clone the repository to your desired
-path and set `$TMUXIFIER` to that path, additionally loading `init.sh` from
-that same path.
-
-```bash
-export TMUXIFIER="$HOME/.dotfiles/tmuxifier"
-[[ -s "$TMUXIFIER/init.sh" ]] && source "$TMUXIFIER/init.sh"
-```
-
 ### Custom Layouts Path
 
 You can customize the layouts directory used by Tmuxifier by setting
@@ -135,13 +195,29 @@ export TMUXIFIER_LAYOUT_PATH="$HOME/.tmux-layouts"
 
 ### Disable Shell-Completion
 
-Tmuxifier comes with shell-completion for bash and zsh. If for any
+Tmuxifier comes with shell-completion for bash, zsh, tcsh, and fish. If for
-reason you need to disable it, just set `$TMUXIFIER_NO_COMPLETE`.
+any reason you need to disable it, just set `$TMUXIFIER_NO_COMPLETE`.
 
 ```bash
 export TMUXIFIER_NO_COMPLETE=1
 ```
 
+## Tips
+
+### iTerm2 Integration
+
+Tmuxifier supports iTerm2's [Tmux integration][]. It can be used in two ways:
+
+- Passing `-CC` as a second argument to the `load-session` command. For
+example:
+
+        tmuxifier load-session my-awesome-session -CC
+
+- Setting the `TMUXIFIER_TMUX_ITERM_ATTACH` environment variable to `-CC`
+  before calling the `load-session` command.
+
+[tmux integration]: https://gitlab.com/gnachman/iterm2/wikis/TmuxIntegration
+
 ## Inspiration
 
 - Tmuxifier is largely inspired by [Tmuxinator][].
@@ -151,7 +227,7 @@ export TMUXIFIER_NO_COMPLETE=1
 ## Tmuxifier vs. Tmuxinator
 
 Though Tmuxifier is largely inspired by the excellent [Tmuxinator][] project,
-but does set itself apart in a number of ways:
+it does set itself apart in a number of ways:
 
 - Uses shell scripts to define Tmux sessions and windows instead of YAML
   files. The benefit is total control over Tmux, but the definition files are
@@ -166,25 +242,16 @@ but does set itself apart in a number of ways:
 [tmuxinator]: https://github.com/aziz/tmuxinator
 [rbenv]: https://github.com/sstephenson/rbenv
 
-## Heed My Warning
-
-Tmuxifier is pretty much an alpha product hacked together over a weekend at
-this point. Documentation is sketchy at best, and things might drastically
-change and/or break.
-
-But if that doesn't put you off, please enjoy Tmuxifier :)
-
 ## Todos
 
 * Improve Readme, specially Usage section.
-* Expand `help` command with details for most commands, rather than just the
+* Write up a detailed reference for all available layout helper functions.
-  essential ones.
 
 ## License
 
 (The MIT license)
 
-Copyright (c) 2012 Jim Myhrberg.
+Copyright (c) 2014 Jim Myhrberg.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

bin/tmuxifier

@@ -2,17 +2,47 @@
 set -e
 [ -n "$TMUXIFIER_DEBUG" ] && set -x
 
+resolve_link() {
+  $(type -p greadlink readlink | head -1) $1
+}
+
+abs_dirname() {
+  local cwd="$(pwd)"
+  local path="$1"
+
+  while [ -n "$path" ]; do
+    cd "${path%/*}"
+    local name="${path##*/}"
+    path="$(resolve_link "$name" || true)"
+  done
+
+  pwd
+  cd "$cwd"
+}
+
 if [ -z "${TMUXIFIER}" ]; then
-  export TMUXIFIER="${HOME}/.tmuxifier"
+  # Set TMUXIFIER relative to the "tmuxifier" executable.
+  export TMUXIFIER="$(dirname "$(abs_dirname "$0")")"
 else
+  # Strip any trailing slash (/) characters from TMUXIFIER variable.
   export TMUXIFIER="${TMUXIFIER%/}"
 fi
 
 # Load tmuxifier environment variables.
-source "$TMUXIFIER/env.sh"
+source "$TMUXIFIER/lib/env.sh"
 
+# Add tmuxifier's internal commands to PATH.
 export PATH="$TMUXIFIER/libexec:$PATH"
 
+# Check Tmux version.
+export TMUXIFIER_MIN_TMUX_VERSION="1.6"
+if [ "$(tmuxifier-tmux-version "$TMUXIFIER_MIN_TMUX_VERSION")" == "<" ]; then
+  echo -e "ERROR: Tmuxifier requires Tmux v${TMUXIFIER_MIN_TMUX_VERSION}" \
+       "or newer. You have v$(tmuxifier-tmux-version)." >&2
+  exit 1
+fi
+
+# Parse given command
 command="$1"
 case "$command" in
   "" | "-h" | "--help" )

completion/tmuxifier.fish

@@ -0,0 +1,36 @@
+
+set -l cmd_load_session  'load-session s'
+set -l cmd_load_window   'load-window w'
+set -l cmd_list          'list l'
+set -l cmd_list_sessions 'list-sessions ls'
+set -l cmd_list_windows  'list-windows lw'
+set -l cmd_new_session   'new-session ns'
+set -l cmd_new_window    'new-window nw'
+set -l cmd_edit_session  'edit-session es'
+set -l cmd_edit_window   'edit-window ew'
+set -l cmd_commands      'commands'
+set -l cmd_version       'version'
+set -l cmd_help          'help'
+
+complete -c tmuxifier -x
+
+# Commands
+complete -c tmuxifier -n '__fish_use_subcommand' -a $cmd_load_session  -d 'Load the specified session layout.'
+complete -c tmuxifier -n '__fish_use_subcommand' -a $cmd_load_window   -d 'Load the specified window layout into current session.'
+complete -c tmuxifier -n '__fish_use_subcommand' -a $cmd_list          -d 'List all session and window layouts.'
+complete -c tmuxifier -n '__fish_use_subcommand' -a $cmd_list_sessions -d 'List session layouts.'
+complete -c tmuxifier -n '__fish_use_subcommand' -a $cmd_list_windows  -d 'List window layouts.'
+complete -c tmuxifier -n '__fish_use_subcommand' -a $cmd_new_session   -d 'Create new session layout and open it with $EDITOR.'
+complete -c tmuxifier -n '__fish_use_subcommand' -a $cmd_new_window    -d 'Create new window layout and open it with $EDITOR.'
+complete -c tmuxifier -n '__fish_use_subcommand' -a $cmd_edit_session  -d 'Edit specified session layout with $EDITOR.'
+complete -c tmuxifier -n '__fish_use_subcommand' -a $cmd_edit_window   -d 'Edit specified window layout with $EDITOR.'
+complete -c tmuxifier -n '__fish_use_subcommand' -a $cmd_commands      -d 'List all tmuxifier commands.'
+complete -c tmuxifier -n '__fish_use_subcommand' -a $cmd_version       -d 'Print Tmuxifier version.'
+complete -c tmuxifier -n '__fish_use_subcommand' -a $cmd_help          -d 'Show this message.'
+
+# Complete subcommands
+complete -c tmuxifier -x -n "__fish_seen_subcommand_from $cmd_load_session" -a '(tmuxifier list-sessions)' -d 'session-template'
+complete -c tmuxifier -x -n "__fish_seen_subcommand_from $cmd_load_window"  -a '(tmuxifier list-windows)'  -d 'window-template'
+complete -c tmuxifier -x -n "__fish_seen_subcommand_from $cmd_edit_session" -a '(tmuxifier list-sessions)' -d 'session-template'
+complete -c tmuxifier -x -n "__fish_seen_subcommand_from $cmd_edit_window"  -a '(tmuxifier list-windows)'  -d 'window-template'
+

completion/tmuxifier.tcsh

@@ -0,0 +1,2 @@
+complete tmuxifier 'p@1@`tmuxifier commands`@' \
+                   'p@2@`tmuxifier completions $:-1`@'

examples/example.window.sh

@@ -7,8 +7,9 @@ window_root "~/Desktop"
 new_window "Example Window"
 
 # Split window into panes.
-tmux split-window -t "$session:$window.0" -v -p 20 "watch -t date"
+split_v 20
-tmux split-window -t "$session:$window.1" -h -p 60
+run_cmd "watch -t date"
+split_h 60
 
 # Set active pane.
-tmux select-pane -t "$session:$window.0"
+select_pane 0

init.fish

@@ -0,0 +1,17 @@
+# Set/fix Tmuxifier root path if needed.
+if test -z $TMUXIFIER
+  set -gx TMUXIFIER "$HOME/.tmuxifier"
+end
+
+# Add `bin` directroy to `$PATH`.
+if not contains "$TMUXIFIER/bin" $PATH
+  set -gx PATH "$TMUXIFIER/bin" $PATH
+end
+
+# If `tmuxifier` is available, and `$TMUXIFIER_NO_COMPLETE` is not set, then
+# load Tmuxifier shell completion.
+if test -n (which tmuxifier); and test -z $TMUXIFIER_NO_COMPLETE
+  source "$TMUXIFIER/completion/tmuxifier.fish"
+end
+
+

init.sh

@@ -1,4 +1,4 @@
-# Set tmuxifier root path.
+# Set/fix Tmuxifier root path if needed.
 if [ -z "${TMUXIFIER}" ]; then
   export TMUXIFIER="${HOME}/.tmuxifier"
 else
@@ -6,10 +6,12 @@ else
 fi
 
 # Add `bin` directroy to `$PATH`.
-export PATH="$TMUXIFIER/bin:$PATH"
+if [[ ":$PATH:" != *":$TMUXIFIER/bin:"* ]]; then
+  export PATH="$TMUXIFIER/bin:$PATH"
+fi
 
 # If `tmuxifier` is available, and `$TMUXIFIER_NO_COMPLETE` is not set, then
-# load tmuxifier shell completion.
+# load Tmuxifier shell completion.
 if [ -n "$(command -v "tmuxifier")" ] && [ -z "$TMUXIFIER_NO_COMPLETE" ]; then
   if [ -n "$BASH_VERSION" ]; then
     source "$TMUXIFIER/completion/tmuxifier.bash"

init.tcsh

@@ -0,0 +1,15 @@
+# Set Tmuxifier root path if needed.
+if ( ! $?TMUXIFIER ) then
+  setenv TMUXIFIER "${HOME}/.tmuxifier"
+endif
+
+# Add `bin` directroy to `$path` if needed.
+if ( ! (" $path " =~ "* $TMUXIFIER/bin *" ) ) then
+  set path = ( $TMUXIFIER/bin $path )
+endif
+
+# If `tmuxifier` is available, and `$TMUXIFIER_NO_COMPLETE` is not set, then
+# load Tmuxifier shell completion.
+if ( ! $?TMUXIFIER_NO_COMPLETE ) then
+  which tmuxifier > /dev/null && source "$TMUXIFIER/completion/tmuxifier.tcsh"
+endif

lib/layout-helpers.sh

@@ -6,6 +6,11 @@
 # otherwise more complex means.
 #
 
+# Alias tmux to tmuxifier-tmux wrapper.
+tmux() {
+  tmuxifier-tmux "$@"
+}
+
 # Create a new window.
 #
 # Arguments:
@@ -13,12 +18,16 @@
 #   - $2: (optional) Shell command to execute when window is created.
 #
 new_window() {
-  if [ -n "$1" ]; then window="$1"; fi
+  if [ -n "$1" ]; then local winarg=(-n "$1"); fi
   if [ -n "$2" ]; then local command=("$2"); fi
-  if [ -n "$window" ]; then local winarg=(-n "$window"); fi
 
-  if [ -n "$window_root" ]; then cd "$window_root"; fi
+  tmuxifier-tmux new-window -t "$session:" "${winarg[@]}" "${command[@]}"
-  tmux new-window -t "$session:" "${winarg[@]}" "${command[@]}"
+
+  # Disable renaming if a window name was given.
+  if [ -n "$1" ]; then tmuxifier-tmux set-option -t "$1" allow-rename off; fi
+
+  window="$(__get_current_window_index)"
+  __go_to_window_or_session_path
 }
 
 # Split current window/pane vertically.
@@ -29,7 +38,8 @@ new_window() {
 #
 split_v() {
   if [ -n "$1" ]; then local percentage=(-p "$1"); fi
-  tmux split-window -t "$session:$window.$2" -v "${percentage[@]}"
+  tmuxifier-tmux split-window -t "$session:$window.$2" -v "${percentage[@]}"
+  __go_to_window_or_session_path
 }
 
 # Split current window/pane horizontally.
@@ -40,7 +50,40 @@ split_v() {
 #
 split_h() {
   if [ -n "$1" ]; then local percentage=(-p "$1"); fi
-  tmux split-window -t "$session:$window.$2" -h "${percentage[@]}"
+  tmuxifier-tmux split-window -t "$session:$window.$2" -h "${percentage[@]}"
+  __go_to_window_or_session_path
+}
+
+# Split current window/pane vertically by line count.
+#
+# Arguments:
+#   - $1: (optional) Number of lines the new pane will use.
+#   - $2: (optional) Target pane ID to split in current window.
+#
+split_vl() {
+  if [ -n "$1" ]; then local count=(-l "$1"); fi
+  tmuxifier-tmux split-window -t "$session:$window.$2" -v "${count[@]}"
+  __go_to_window_or_session_path
+}
+
+# Split current window/pane horizontally by column count.
+#
+# Arguments:
+#   - $1: (optional) Number of columns the new pane will use.
+#   - $2: (optional) Target pane ID to split in current window.
+#
+split_hl() {
+  if [ -n "$1" ]; then local count=(-l "$1"); fi
+  tmuxifier-tmux split-window -t "$session:$window.$2" -h "${count[@]}"
+  __go_to_window_or_session_path
+}
+
+# Run clock mode.
+#
+# Arguments:
+#   - $1: (optional) Target pane ID in which to run
+clock() {
+  tmuxifier-tmux clock-mode -t "$session:$window.$1"
 }
 
 # Select a specific window.
@@ -49,7 +92,8 @@ split_h() {
 #   - $1: Window ID or name to select.
 #
 select_window() {
-  tmux select-window -t "$session:$1"
+  tmuxifier-tmux select-window -t "$session:$1"
+  window="$(__get_current_window_index)"
 }
 
 # Select a specific pane in the current window.
@@ -58,7 +102,25 @@ select_window() {
 #   - $1: Pane ID to select.
 #
 select_pane() {
-  tmux select-pane -t "$session:$window.$1"
+  tmuxifier-tmux select-pane -t "$session:$window.$1"
+}
+
+balance_windows_vertical() {
+  tmuxifier-tmux select-layout even-vertical
+}
+
+balance_windows_horizontal() {
+  tmuxifier-tmux select-layout even-horizontal
+}
+
+# Send/paste keys to the currently active pane/window.
+#
+# Arguments:
+#   - $1: String to paste.
+#   - $2: (optional) Target pane ID to send input to.
+#
+send_keys() {
+  tmuxifier-tmux send-keys -t "$session:$window.$2" "$1"
 }
 
 # Runs a shell command in the currently active pane/window.
@@ -68,11 +130,11 @@ select_pane() {
 #   - $2: (optional) Target pane ID to run command in.
 #
 run_cmd() {
-  tmux send-keys -t "$session:$window.$2" -l "$1"
+  send_keys "$1" "$2"
-  tmux send-keys -t "$session:$window.$2" "C-m"
+  send_keys "C-m" "$2"
 }
 
-# Cusomize session root path. Default is `$HOME`.
+# Customize session root path. Default is `$HOME`.
 #
 # Arguments:
 #   - $1: Directory path to use for session root.
@@ -99,12 +161,22 @@ window_root() {
 # Load specified window layout.
 #
 # Arguments:
-#   - $1: Name of window layout to load.
+#   - $1: Name of or file path to window layout to load.
+#   - $2: (optional) Override default window name.
 #
 load_window() {
-  local file="$TMUXIFIER_LAYOUT_PATH/$1.window.sh"
+  local file="$1"
+  if [ ! -f "$file" ]; then
+    file="$TMUXIFIER_LAYOUT_PATH/$1.window.sh"
+  fi
+
   if [ -f "$file" ]; then
-    window="$1"
+    if [ $# -gt 1 ]; then
+      window="$2"
+    else
+      window="${1/%.window.sh}"
+      window="${window/%.sh}"
+    fi
     source "$file"
     window=
 
@@ -113,28 +185,50 @@ load_window() {
       window_root "$session_root"
     fi
   else
-    echo "No such window layout found '$1' in '$TMUXIFIER_LAYOUT_PATH'."
+    echo "\"$1\" window layout not found." >&2
+    return 1
   fi
 }
 
 # Load specified session layout.
 #
 # Arguments:
-#   - $1: Name of session layout to load.
+#   - $1: Name of or file path to session layout to load.
+#   - $2: (optional) Override default window name.
 #
 load_session() {
-  local file="$TMUXIFIER_LAYOUT_PATH/$1.session.sh"
+  local file
-  if [ -f "$file" ]; then
+  if [ "${1#*/}" = "$1" ]; then
-    session="$1"
+    # There's no slash in the path.
-    source "$file"
+    if [ -f "$TMUXIFIER_LAYOUT_PATH/$1.session.sh" ] || [ ! -f "$1" ]; then
-    session=
+      file="$TMUXIFIER_LAYOUT_PATH/$1.session.sh"
-
+    else
-    # Reset `$session_root`.
+      # bash's 'source' requires an slash in the filename to not use $PATH.
-    if [[ "$session_root" != "$HOME" ]]; then
+      file="./$1"
-      session_root="$HOME"
     fi
   else
-    echo "No such session layout found '$1' in '$TMUXIFIER_LAYOUT_PATH'."
+    file="$1"
+  fi
+
+  if ! [ -f "$file" ]; then
+    echo "\"$1\" session layout not found." >&2
+    return 1
+  fi
+
+  if [ $# -gt 1 ]; then
+    session="$2"
+  else
+    session="${1/%.session.sh}"
+    session="${session/%.sh}"
+  fi
+
+  set_default_path=true
+  source "$file"
+  session=
+
+  # Reset `$session_root`.
+  if [[ "$session_root" != "$HOME" ]]; then
+    session_root="$HOME"
   fi
 }
 
@@ -156,46 +250,61 @@ initialize_session() {
   fi
 
   # Ensure tmux server is running for has-session check.
-  tmux start-server
+  tmuxifier-tmux start-server
 
   # Check if the named session already exists.
-  if ! tmux has-session -t "$session:" 2>/dev/null; then
+  if tmuxifier-tmux has-session -t "$session:" 2>/dev/null; then
+    return 1
+  fi
+
+  # Tmux 1.8 and earlier.
+  if [ "$(tmuxifier-tmux-version "1.9")" == "<" ]; then
     # Create the new session.
-    env TMUX="" tmux new-session -d -s "$session"
+    env TMUX="" tmuxifier-tmux new-session -d -s "$session"
 
     # Set default-path for session
     if [ -n "$session_root" ] && [ -d "$session_root" ]; then
       cd "$session_root"
-      tmux set-option -t "$session:" default-path "$session_root" 1>/dev/null
+
+      $set_default_path && tmuxifier-tmux \
+        set-option -t "$session:" \
+        default-path "$session_root" 1>/dev/null
     fi
 
-    # In order to ensure only specified windows are created, we move the
+  # Tmux 1.9 and later.
-    # default window to position 99, and later remove it with the
+  else
-    # `finalize_session` function.
+    if $set_default_path; then
-    tmux move-window -s "$session:0" -t "$session:99"
+      local session_args=(-c "$session_root")
+    fi
 
-    # Ensure correct pane splitting.
+    env TMUX="" tmuxifier-tmux new-session \
-    __go_to_session
+      -d -s "$session" "${session_args[@]}"
-
-    # Session created, return ok exit status.
-    return 0
   fi
-  # Session already existed, return error exit status.
+
-  return 1
+  if $set_default_path && [[ "$session_root" != "$HOME" ]]; then
+    tmuxifier-tmux setenv -t "$session:" \
+      TMUXIFIER_SESSION_ROOT "$session_root"
+  fi
+
+  # In order to ensure only specified windows are created, we move the
+  # default window to position 999, and later remove it with the
+  # `finalize_and_go_to_session` function.
+  local first_window_index=$(__get_first_window_index)
+  tmuxifier-tmux move-window \
+    -s "$session:$first_window_index" -t "$session:999"
 }
 
 # Finalize session creation and then switch to it if needed.
 #
-# When the session is created, it leaves a unused window in position #99, this
+# When the session is created, it leaves a unused window in position #999,
-# is the default window which was created with the session, but it's also a
+# this is the default window which was created with the session, but it's also
-# window that was not explicitly created. Hence we kill it.
+# a window that was not explicitly created. Hence we kill it.
 #
 # If the session was created, we've already been switched to it. If it was not
-# created, the session already exists, and we'll need to specifically switch
+# created, but already existed, then we'll need to specifically switch to it.
-# to it here.
 #
 finalize_and_go_to_session() {
-  ! tmux kill-window -t "$session:99" 2>/dev/null
+  ! tmuxifier-tmux kill-window -t "$session:999" 2>/dev/null
   if [[ "$(tmuxifier-current-session)" != "$session" ]]; then
     __go_to_session
   fi
@@ -217,10 +326,49 @@ __expand_path() {
   echo $(eval echo "$@")
 }
 
-__go_to_session() {
+__get_first_window_index() {
-  if [ -z "$TMUX" ]; then
+  local index=$(tmuxifier-tmux list-windows -t "$session:" \
-    tmux -u attach-session -t "$session:"
+    -F "#{window_index}" 2>/dev/null)
+
+  if [ -n "$index" ]; then
+    echo "$index" | head -1
   else
-    tmux -u switch-client -t "$session:"
+    echo "0"
+  fi
+}
+
+__get_current_window_index() {
+  local lookup=$(tmuxifier-tmux list-windows -t "$session:" \
+    -F "#{window_active}:#{window_index}" 2>/dev/null | grep "^1:")
+
+  if [ -n "$lookup" ]; then
+    echo "${lookup/1:}"
+  fi
+}
+
+__go_to_session() {
+  if [ -z "$TMUX" ]; then
+    tmuxifier-tmux $TMUXIFIER_TMUX_ITERM_ATTACH -u \
+      attach-session -t "$session:"
+  else
+    tmuxifier-tmux -u switch-client -t "$session:"
+  fi
+}
+
+__go_to_window_or_session_path() {
+  local target_path
+
+  if [ -n "$window_root" ]; then
+    target_path="$window_root"
+  elif [ -n "$TMUXIFIER_SESSION_ROOT" ]; then
+    target_path="$TMUXIFIER_SESSION_ROOT"
+  elif [ -n "$session_root" ]; then
+    target_path="$session_root"
+  fi
+
+  # local window_or_session_root=${window_root-$session_root}
+  if [ -n "$target_path" ]; then
+    run_cmd "cd \"$target_path\""
+    run_cmd "clear"
   fi
 }

lib/runtime.sh

@@ -3,7 +3,7 @@
 #
 
 # Load tmuxifier environment.
-source "$TMUXIFIER/env.sh"
+source "$TMUXIFIER/lib/env.sh"
 
 # Setup default variables.
 session_root="$HOME"

lib/util.sh

@@ -0,0 +1,11 @@
+calling-help() {
+  if [[ " $@ " != *" --help "* ]] && [[ " $@ " != *" -h "* ]]; then
+    return 1
+  fi
+}
+
+calling-complete() {
+  if [[ " $@ " != *" --complete "* ]]; then
+    return 1
+  fi
+}

libexec/tmuxifier-alias

@@ -2,6 +2,17 @@
 set -e
 [ -n "$TMUXIFIER_DEBUG" ] && set -x
 
+# Load internal utility functions.
+source "$TMUXIFIER/lib/util.sh"
+
+# Provide tmuxifier help
+if calling-help "$@"; then
+  echo "usage: tmuxifier alias <alias>
+
+Resolve a command alias to it's full name."
+  exit
+fi
+
 case "$1" in
   "session" | "ses" | "s" )
     echo "load-session"
@@ -9,25 +20,25 @@ case "$1" in
   "window" | "win" | "w" )
     echo "load-window"
     ;;
-  "new-ses" | "ns" )
+  "new-ses" | "nses" | "ns" )
     echo "new-session"
     ;;
-  "new-win" | "nw" )
+  "new-win" | "nwin" | "nw" )
     echo "new-window"
     ;;
-  "edit-ses" | "es" )
+  "edit-ses" | "eses" | "es" )
     echo "edit-session"
     ;;
-  "edit-win" | "ew" )
+  "edit-win" | "ewin" | "ew" )
     echo "edit-window"
     ;;
-  "ls" )
+  "l" )
     echo "list"
     ;;
-  "list-ses" | "lss" )
+  "list-ses" | "lses" | "ls" )
     echo "list-sessions"
     ;;
-  "list-win" | "lsw" )
+  "list-win" | "lwin" | "lw" )
     echo "list-windows"
     ;;
   * )

libexec/tmuxifier-commands

@@ -2,6 +2,18 @@
 set -e
 [ -n "$TMUXIFIER_DEBUG" ] && set -x
 
+# Load internal utility functions.
+source "$TMUXIFIER/lib/util.sh"
+
+# Provide tmuxifier help
+if calling-help "$@"; then
+  echo "usage: tmuxifier commands
+
+List all available commands, includes internal commands not intended for
+normal use by users."
+  exit
+fi
+
 shopt -s nullglob
 
 { for path in ${PATH//:/$'\n'}; do

libexec/tmuxifier-completions

@@ -2,23 +2,33 @@
 set -e
 [ -n "$TMUXIFIER_DEBUG" ] && set -x
 
+# Load internal utility functions.
+source "$TMUXIFIER/lib/util.sh"
+
+# Provide tmuxifier help
+if calling-help "$@"; then
+  echo "usage: tmuxifier completion <command>
+
+Print a list of available completions for specified command."
+  exit
+fi
+
 # Provide tmuxifier completions
-if [ "$1" == "--complete" ]; then
+if calling-complete "$@"; then
   tmuxifier-commands
   exit
 fi
 
 has-completions() {
-  grep -i "^# provide tmuxifier completions" "$1" >/dev/null
+  grep -i "^# Provide tmuxifier completions" "$1" >/dev/null
 }
 
-command="$1"
+if [ -z "$1" ]; then
-if [ -z "$command" ]; then
+  echo "$(tmuxifier-help completions $@)" >&2
-  echo "$(tmuxifier-help completions)" >&2
   exit 1
 fi
 
-! command_path="$(tmuxifier-resolve-command-path "$command")"
+! command_path="$(tmuxifier-resolve-command-path "$1")"
 
 if [ -n "$command_path" ] && has-completions "$command_path"; then
   shift

libexec/tmuxifier-current-session

@@ -2,12 +2,21 @@
 set -e
 [ -n "$TMUXIFIER_DEBUG" ] && set -x
 
+# Load internal utility functions.
+source "$TMUXIFIER/lib/util.sh"
+
+# Provide tmuxifier help
+if calling-help "$@"; then
+  echo "usage: tmuxifier current-session
+
+Outputs the name of the current Tmux session."
+  exit
+fi
+
 if [ -n "$TMUX" ]; then
-  for item in $(tmux list-sessions -F "#{?session_attached,1,0}:#S"); do
+  for item in $(tmuxifier-tmux list-pane -F "#{session_name}");do
-    if [[ "$item" == "1:"* ]]; then
+    echo $item
-      echo ${item/1:/}
+    exit 0
-      exit 0
-    fi
   done
 fi
 

libexec/tmuxifier-edit-session

@@ -2,16 +2,27 @@
 set -e
 [ -n "$TMUXIFIER_DEBUG" ] && set -x
 
+# Load internal utility functions.
+source "$TMUXIFIER/lib/util.sh"
+
+# Provide tmuxifier help
+if calling-help "$@"; then
+  echo "usage: tmuxifier edit-session <layout_name>
+
+Aliases: edit-ses, eses, es
+
+Open specified session layout for editing in \$EDITOR."
+  exit
+fi
+
 # Provide tmuxifier completions
-if [ "$1" == "--complete" ]; then
+if calling-complete "$@"; then
-  for item in $(tmuxifier-list-sessions); do
+  tmuxifier-list-sessions
-    echo "$item"
-  done
   exit
 fi
 
 if [ -z "$1" ]; then
-  echo "$(tmuxifier-help edit-session)" >&2
+  echo "$(tmuxifier-help edit-session $@)" >&2
   exit 1
 fi
 
@@ -26,4 +37,10 @@ if [ ! -f "$layout_file" ]; then
   exit 1
 fi
 
-exec "$EDITOR" "$layout_file"
+if [ -n "$EDITOR" ]; then
+  exec $EDITOR "$layout_file"
+else
+  echo "'\$EDITOR' is not set. Please manually open the layout for editing:"
+  echo "$layout_file"
+  echo
+fi

libexec/tmuxifier-edit-window

@@ -2,16 +2,27 @@
 set -e
 [ -n "$TMUXIFIER_DEBUG" ] && set -x
 
+# Load internal utility functions.
+source "$TMUXIFIER/lib/util.sh"
+
+# Provide tmuxifier help
+if calling-help "$@"; then
+  echo "usage: tmuxifier edit-window <layout_name>
+
+Aliases: edit-win, ewin, ew
+
+Open specified window layout for editing in \$EDITOR."
+  exit
+fi
+
 # Provide tmuxifier completions
-if [ "$1" == "--complete" ]; then
+if calling-complete "$@"; then
-  for item in $(tmuxifier-list-windows); do
+  tmuxifier-list-windows
-    echo "$item"
-  done
   exit
 fi
 
 if [ -z "$1" ]; then
-  echo "$(tmuxifier-help edit-window)" >&2
+  echo "$(tmuxifier-help edit-window $@)" >&2
   exit 1
 fi
 
@@ -26,4 +37,10 @@ if [ ! -f "$layout_file" ]; then
   exit 1
 fi
 
-exec "$EDITOR" "$layout_file"
+if [ -n "$EDITOR" ]; then
+  exec $EDITOR "$layout_file"
+else
+  echo "'\$EDITOR' is not set. Please manually open the layout for editing:"
+  echo "$layout_file"
+  echo
+fi

libexec/tmuxifier-help

@@ -2,123 +2,63 @@
 set -e
 [ -n "$TMUXIFIER_DEBUG" ] && set -x
 
+# Load internal utility functions.
+source "$TMUXIFIER/lib/util.sh"
+
+# Provide tmuxifier help
+if calling-help "$@"; then
+  tmuxifier-help
+  exit
+fi
+
 # Provide tmuxifier completions
-if [ "$1" == "--complete" ]; then
+if calling-complete "$@"; then
   tmuxifier-commands
   exit
 fi
 
-command="$1"
+has-help() {
+  grep -i "^# Provide tmuxifier help" "$1" >/dev/null
+}
 
-# Ensure we have the correct command name in case an alias was given.
+if [ -z "$1" ]; then
-if [ -n "$command" ]; then
+  echo "usage: tmuxifier <command> [<args>]
-  ! resolved="$(tmuxifier-alias "$command")"
-  if [ -n "$resolved" ]; then
-    command="$resolved"
-  fi
-fi
-
-case "$command" in
-  "" )
-    echo "usage: tmuxifier <command> [<args>]
 
 Some useful tmuxifier commands are:
    <command>      <alias>
    load-session   s        Load the specified session layout.
    load-window    w        Load the specified window layout into current session.
-   list           ls       List all session and window layouts.
+   list           l        List all session and window layouts.
-   list-sessions  lss      List session layouts.
+   list-sessions  ls       List session layouts.
-   list-windows   lsw      List window layouts.
+   list-windows   lw       List window layouts.
    new-session    ns       Create new session layout and open it with \$EDITOR.
    new-window     nw       Create new window layout and open it with \$EDITOR.
    edit-session   es       Edit specified session layout with \$EDITOR.
    edit-window    ew       Edit specified window layout with \$EDITOR.
-   commands                List all tmuxifier commands.
+   commands                List all tmuxifier commands (including internal).
    version                 Print Tmuxifier version.
    help                    Show this message.
 
 See 'tmuxifier help <command>' for information on a specific command."
-    ;;
+  exit
-  "load-session" )
+fi
-    echo "usage: tmuxifier load-session <layout_name>
 
-Aliases: session, ses, s
+! command_path="$(tmuxifier-resolve-command-path "$1")"
 
-Create a session using the session layout, unless the session already exists
+if [ -z "$command_path" ]; then
-in which case, we simply switch to the existing one."
+  echo "tmuxifier: no such command '$1'" >&2
-    ;;
+  exit 1
-  "load-window" )
+fi
-    echo "usage: tmuxifier load-window <layout_name>
 
-Aliases: window, win, w
+if has-help "$command_path"; then
-
+  shift
-Create a new window using the specified window layout in the current session."
+  exec "$command_path" "$@" --help
-    ;;
+else
-  "new-session" )
+  command="$(basename "$command_path")"
-    echo "usage: tmuxifier new-session <layout_name>
+  command="${command/tmuxifier\-/}"
-
+  echo "Sorry, the '$command' command isn't documented yet."
-Aliases: new-ses, ns
+  echo ""
-
+  echo "You can view the command's source here:"
-Create a new session layout and open it for editing in \$EDITOR."
+  echo "$command_path"
-    ;;
+  echo ""
-  "new-window" )
+fi
-    echo "usage: tmuxifier new-window <layout_name>
-
-Aliases: new-win, ws
-
-Create a new window layout and open it for editing in \$EDITOR."
-    ;;
-  "edit-session" )
-    echo "usage: tmuxifier edit-session <layout_name>
-
-Aliases: edit-ses, es
-
-Open specified session layout for editing in \$EDITOR."
-    ;;
-  "edit-window" )
-    echo "usage: tmuxifier edit-window <layout_name>
-
-Aliases: edit-win, ew
-
-Open specified window layout for editing in \$EDITOR."
-    ;;
-  "completions" )
-    echo "usage: tmuxifier completion <command>
-
-Print a list of available completions for specified command."
-    ;;
-  "list" )
-    echo "usage: tmuxifier list
-
-Aliases: ls
-
-List all available session and window layouts."
-    ;;
-  "list-sessions" )
-    echo "usage: tmuxifier list-sessions
-
-Aliases: list-ses, lss
-
-List all session layouts."
-    ;;
-  "list-windows" )
-    echo "usage: tmuxifier list-windows
-
-Aliases: list-win, lsw
-
-List all window layouts."
-    ;;
-  * )
-    ! command_path="$(tmuxifier-resolve-command-path "$command")"
-    if [ -n "$command_path" ]; then
-      echo "Sorry, the '$command' command isn't documented yet."
-      echo
-      echo "You can view the command's source here:"
-      echo "$command_path"
-      echo
-    else
-      echo "tmuxifier: no such command '$command'" >&2
-      exit 1
-    fi
-    ;;
-esac

libexec/tmuxifier-init

@@ -0,0 +1,85 @@
+#! /usr/bin/env bash
+set -e
+[ -n "$TMUXIFIER_DEBUG" ] && set -x
+
+# Set shell to first argument that is not "-", "-h" or "--help".
+for arg in "$@"; do
+  if [ "$arg" != "-" ] && [ "$arg" != "-h" ] && [ "$arg" != "--help" ]; then
+    shell="$arg"
+  fi
+done
+
+if [ -z "$shell" ]; then
+  shell="$(basename "$SHELL")"
+fi
+
+case "$shell" in
+  bash )
+    profile='~/.bash_profile'
+    ;;
+  zsh )
+    profile='~/.zshrc'
+    ;;
+  ksh )
+    profile='~/.profile'
+    ;;
+  csh )
+    profile='~/.cshrc'
+    ;;
+  tcsh )
+    profile='~/.tcshrc'
+    ;;
+  fish )
+    profile='~/.config/fish/config.fish'
+    ;;
+  * )
+    profile='shell init file'
+    ;;
+esac
+
+# Provide tmuxifier help
+if [[ " $@ " == *" --help "* ]]; then
+  echo "usage: tmuxifier init -
+
+Load Tmuxifier by adding the following to your ${profile}:
+"
+
+  case "$shell" in
+    csh | tcsh )
+      echo "    eval \`tmuxifier init -\`
+"
+      ;;
+    fish )
+      echo "    eval (tmuxifier init -)
+"
+      ;;
+    * )
+      echo "    eval \"\$(tmuxifier init -)\"
+"
+      ;;
+  esac
+
+  echo "You might also need to add Tmuxifier's bin directory to your PATH."
+  exit
+fi
+
+# Print help if "-" argument is not given
+if [[ " $@ " != *" - "* ]]; then
+  echo "$(tmuxifier-help init $@)" >&2
+  exit 1
+fi
+
+case "$shell" in
+  csh | tcsh )
+    echo "setenv TMUXIFIER \"$TMUXIFIER\";"
+    echo "source \"\$TMUXIFIER/init.tcsh\";"
+    ;;
+  fish )
+    echo "set -gx TMUXIFIER \"$TMUXIFIER\";"
+    echo "source \"\$TMUXIFIER/init.fish\";"
+    ;;
+  * )
+    echo "export TMUXIFIER=\"$TMUXIFIER\";"
+    echo "source \"\$TMUXIFIER/init.sh\";"
+    ;;
+esac

libexec/tmuxifier-list

@@ -2,10 +2,27 @@
 set -e
 [ -n "$TMUXIFIER_DEBUG" ] && set -x
 
+# Load internal utility functions.
+source "$TMUXIFIER/lib/util.sh"
+
+# Provide tmuxifier help
+if calling-help "$@"; then
+  echo "usage: tmuxifier list
+
+Aliases: l
+
+List all available session and window layouts."
+  exit
+fi
+
 echo ""
 echo "Sessions:"
-tmuxifier-list-sessions
+for item in $(tmuxifier-list-sessions); do
+  echo " - $item"
+done
 echo ""
 echo "Windows:"
-tmuxifier-list-windows
+for item in $(tmuxifier-list-windows); do
+  echo " - $item"
+done
 echo ""

libexec/tmuxifier-list-sessions

@@ -2,8 +2,21 @@
 set -e
 [ -n "$TMUXIFIER_DEBUG" ] && set -x
 
-list=$(find "$TMUXIFIER_LAYOUT_PATH" -name "*.session.sh")
+# Load internal utility functions.
+source "$TMUXIFIER/lib/util.sh"
+
+# Provide tmuxifier help
+if calling-help "$@"; then
+  echo "usage: tmuxifier list-sessions
+
+Aliases: list-ses, lses, ls
+
+List all session layouts."
+  exit
+fi
+
+list=$(find -L "$TMUXIFIER_LAYOUT_PATH" -name "*.session.sh")
 for file in $list; do
   file=${file/$TMUXIFIER_LAYOUT_PATH\//}
-  echo "  ${file/.session.sh/}"
+  echo "${file/.session.sh/}"
 done

libexec/tmuxifier-list-windows

@@ -2,8 +2,21 @@
 set -e
 [ -n "$TMUXIFIER_DEBUG" ] && set -x
 
-list=$(find "$TMUXIFIER_LAYOUT_PATH" -name "*.window.sh")
+# Load internal utility functions.
+source "$TMUXIFIER/lib/util.sh"
+
+# Provide tmuxifier help
+if calling-help "$@"; then
+  echo "usage: tmuxifier list-windows
+
+Aliases: list-win, lwin, lw
+
+List all window layouts."
+  exit
+fi
+
+list=$(find -L "$TMUXIFIER_LAYOUT_PATH" -name "*.window.sh")
 for file in $list; do
   file=${file/$TMUXIFIER_LAYOUT_PATH\//}
-  echo "  ${file/.window.sh/}"
+  echo "${file/.window.sh/}"
 done

libexec/tmuxifier-load-session

@@ -2,25 +2,44 @@
 set -e
 [ -n "$TMUXIFIER_DEBUG" ] && set -x
 
+# Load internal utility functions.
+source "$TMUXIFIER/lib/util.sh"
+
+# Provide tmuxifier help
+if calling-help "$@"; then
+  echo "usage: tmuxifier load-session <layout_name | file_path> [<iterm mode>]
+
+Aliases: session, ses, s
+
+Create a session using the session layout, unless the session already exists
+in which case, we simply attach/switch to the existing one.
+
+Arguments:
+   <layout_name | file_path>  - Name of a session layout stored in the layouts
+                                directory, or path to a session layout file.
+   <iterm mode>               - When given as \"-CC\" tmux will be called with
+                                the -CC argument enabling iTerm2 integration.
+                                More info: http://bit.ly/1yDbMlm"
+  exit
+fi
+
 # Provide tmuxifier completions
-if [ "$1" == "--complete" ]; then
+if calling-complete "$@"; then
-  for item in $(tmuxifier-list-sessions); do
+  tmuxifier-list-sessions
-    echo "$item"
-  done
   exit
 fi
 
 if [ -z "$1" ]; then
-  echo "$(tmuxifier-help load-session)" >&2
+  echo "$(tmuxifier-help load-session $@)" >&2
   exit 1
 fi
 
 # Load runtime functions.
-source "$TMUXIFIER/runtime.sh"
+source "$TMUXIFIER/lib/runtime.sh"
 
-if [ ! -z $TMUX ]; then
+if [ "$2" == "-CC" ]; then
-  load_session "$1"
+  export TMUXIFIER_TMUX_ITERM_ATTACH="-CC"
-else
-  echo "tmuxifier: 'load-session' command can only be used from within Tmux."
-  exit 1
 fi
+
+# Load session file.
+load_session "$1"

libexec/tmuxifier-load-window

@@ -2,21 +2,36 @@
 set -e
 [ -n "$TMUXIFIER_DEBUG" ] && set -x
 
+# Load internal utility functions.
+source "$TMUXIFIER/lib/util.sh"
+
+# Provide tmuxifier help
+if calling-help "$@"; then
+  echo "usage: tmuxifier load-window <layout_name | file_path>
+
+Aliases: window, win, w
+
+Create a new window using the specified window layout in the current session.
+
+Arguments:
+   <layout_name | file_path>  - Name of a window layout stored in the layouts
+                                directory, or path to a window layout file."
+  exit
+fi
+
 # Provide tmuxifier completions
-if [ "$1" == "--complete" ]; then
+if calling-complete "$@"; then
-  for item in $(tmuxifier-list-windows); do
+  tmuxifier-list-windows
-    echo "$item"
-  done
   exit
 fi
 
 if [ -z "$1" ]; then
-  echo "$(tmuxifier-help load-window)" >&2
+  echo "$(tmuxifier-help load-window $@)" >&2
   exit 1
 fi
 
 # Load runtime functions.
-source "$TMUXIFIER/runtime.sh"
+source "$TMUXIFIER/lib/runtime.sh"
 
 if [ ! -z $TMUX ]; then
   session="$(tmuxifier-current-session)"

libexec/tmuxifier-new-session

@@ -2,8 +2,27 @@
 set -e
 [ -n "$TMUXIFIER_DEBUG" ] && set -x
 
+# Load internal utility functions.
+source "$TMUXIFIER/lib/util.sh"
+
+# Provide tmuxifier help
+if calling-help "$@"; then
+  echo "usage: tmuxifier new-session <layout_name>
+
+Aliases: new-ses, nses, ns
+
+Create a new session layout and open it for editing in \$EDITOR."
+  exit
+fi
+
+# Provide tmuxifier completions
+if calling-complete "$@"; then
+  tmuxifier-list-sessions
+  exit
+fi
+
 if [ -z "$1" ]; then
-  echo "$(tmuxifier-help new-session)" >&2
+  echo "$(tmuxifier-help new-session $@)" >&2
   exit 1
 fi
 
@@ -27,8 +46,8 @@ fi
 content="$(cat "$template")"
 echo "${content//\{\{SESSION_NAME\}\}/$layout_name}" > "$layout_file"
 
-if [ ! -z "$EDITOR" ]; then
+if [ -n "$EDITOR" ]; then
-  exec "$EDITOR" "$layout_file"
+  exec $EDITOR "$layout_file"
 else
   echo "Layout file has been created, but '\$EDITOR' is not set. Please "
   echo "manually open the layout for editing:"

libexec/tmuxifier-new-window

@@ -2,8 +2,27 @@
 set -e
 [ -n "$TMUXIFIER_DEBUG" ] && set -x
 
+# Load internal utility functions.
+source "$TMUXIFIER/lib/util.sh"
+
+# Provide tmuxifier help
+if calling-help "$@"; then
+  echo "usage: tmuxifier new-window <layout_name>
+
+Aliases: new-win, nwin, nw
+
+Create a new window layout and open it for editing in \$EDITOR."
+  exit
+fi
+
+# Provide tmuxifier completions
+if calling-complete "$@"; then
+  tmuxifier-list-windows
+  exit
+fi
+
 if [ -z "$1" ]; then
-  echo "$(tmuxifier-help new-window)" >&2
+  echo "$(tmuxifier-help new-window $@)" >&2
   exit 1
 fi
 
@@ -27,8 +46,8 @@ fi
 content="$(cat "$template")"
 echo "${content//\{\{WINDOW_NAME\}\}/$layout_name}" > "$layout_file"
 
-if [ ! -z "$EDITOR" ]; then
+if [ -n "$EDITOR" ]; then
-  exec "$EDITOR" "$layout_file"
+  exec $EDITOR "$layout_file"
 else
   echo "Layout file has been created, but '\$EDITOR' is not set. Please "
   echo "manually open the layout for editing:"

libexec/tmuxifier-resolve-command-path

@@ -2,6 +2,17 @@
 set -e
 [ -n "$TMUXIFIER_DEBUG" ] && set -x
 
+# Load internal utility functions.
+source "$TMUXIFIER/lib/util.sh"
+
+# Provide tmuxifier help
+if calling-help "$@"; then
+  echo "usage: tmuxifier resolve-command-path <command_or_alias>
+
+Outputs the absolute path to the given command or command alias."
+  exit
+fi
+
 if [ -n "$1" ]; then
   ! command_path="$(command -v "tmuxifier-$1")"
   if [ -z "$command_path" ]; then

libexec/tmuxifier-tmux

@@ -0,0 +1,5 @@
+#! /usr/bin/env bash
+set -e
+[ -n "$TMUXIFIER_DEBUG" ] && set -x
+
+tmux $TMUXIFIER_TMUX_OPTS "$@"

libexec/tmuxifier-tmux-version

@@ -0,0 +1,67 @@
+#! /usr/bin/env bash
+shopt -s extglob
+[ -n "$TMUXIFIER_DEBUG" ] && set -x
+
+# Load internal utility functions.
+source "$TMUXIFIER/lib/util.sh"
+
+# Provide tmuxifier help
+if calling-help "$@"; then
+  echo "usage: tmuxifier tmux-version [<target-version>]
+
+Outputs current Tmux version. If given optional target-version it outputs one
+of three possible characters indicating if the current Tmux version number is
+equal to, less than, or greater than the <target-version>.
+
+The three possible outputs are \"=\", \"<\", and \">\"."
+  exit
+fi
+
+# The vercomp() function is shamelessly ripped/borrowed from the following
+# StackOverflow answer: http://stackoverflow.com/a/4025065/42146
+vercomp () {
+  if [[ $1 == $2 ]]; then return 0; fi
+
+  local IFS=.
+  local i ver1=($1) ver2=($2)
+
+  # fill empty fields in ver1 with zeros
+  for ((i=${#ver1[@]}; i<${#ver2[@]}; i++)); do ver1[i]=0; done
+
+  for ((i=0; i<${#ver1[@]}; i++)); do
+    # fill empty fields in ver2 with zeros
+    if [[ -z ${ver2[i]} ]]; then ver2[i]=0; fi
+
+    if ((10#${ver1[i]} > 10#${ver2[i]})); then
+      return 1
+    elif ((10#${ver1[i]} < 10#${ver2[i]})); then
+      return 2
+    fi
+  done
+  return 0
+}
+
+version=$(tmux -V)
+version=${version/tmux /}
+
+if [ -z "$1" ]; then
+  echo "$version"
+  exit
+fi
+
+if [ "$version" == "master" ]; then
+  # When version string is "master", tmux was compiled from source, and we
+  # assume it's later than whatever the <target-version> is.
+  echo '>'
+else
+  # Fix for "1.9a" version comparison, as vercomp() can only deal with
+  # purely numeric version numbers.
+  version=${version//+([a-zA-Z])/}
+
+  vercomp "$version" "$1"
+  case $? in
+    0) echo '=';;
+    1) echo '>';;
+    2) echo '<';;
+  esac
+fi

libexec/tmuxifier-version

@@ -2,4 +2,15 @@
 set -e
 [ -n "$TMUXIFIER_DEBUG" ] && set -x
 
-echo "0.2.0"
+# Load internal utility functions.
+source "$TMUXIFIER/lib/util.sh"
+
+# Provide tmuxifier help
+if calling-help "$@"; then
+  echo "usage: tmuxifier version
+
+Outputs Tmuxifier version."
+  exit
+fi
+
+echo "0.12.3"

templates/window.sh

@@ -14,5 +14,9 @@ new_window "{{WINDOW_NAME}}"
 #run_cmd "top"     # runs in active pane
 #run_cmd "date" 1  # runs in pane 1
 
+# Paste text
+#send_keys "top"    # paste into active pane
+#send_keys "date" 1 # paste into pane 1
+
 # Set active pane.
 #select_pane 0

test/lib/env.test.sh

@@ -0,0 +1,33 @@
+#! /usr/bin/env bash
+source "../test-helper.sh"
+
+#
+# env.sh tests.
+#
+
+# Setup.
+realTMUXIFIER="$TMUXIFIER"
+TMUXIFER="/path/to/tmuxifier"
+
+# When TMUXIFIER_LAYOUT_PATH is not set.
+source "${root}/lib/env.sh"
+assert 'echo $TMUXIFIER_LAYOUT_PATH' "${TMUXIFIER}/layouts"
+
+# When TMUXIFIER_LAYOUT_PATH is set and has a trailing slash.
+TMUXIFIER_LAYOUT_PATH="/path/to/layouts/"
+source "${root}/lib/env.sh"
+assert 'echo $TMUXIFIER_LAYOUT_PATH' "/path/to/layouts"
+unset TMUXIFIER_LAYOUT_PATH
+
+# When TMUXIFIER_LAYOUT_PATH is set and does not have a trailing slash.
+TMUXIFIER_LAYOUT_PATH="/path/to/layouts"
+source "${root}/lib/env.sh"
+assert 'echo $TMUXIFIER_LAYOUT_PATH' "/path/to/layouts"
+unset TMUXIFIER_LAYOUT_PATH
+
+# Tear down.
+TMUXIFER="$realTMUXIFIER"
+unset realTMUXIFIER
+
+# End of tests.
+assert_end "env.sh"

test/lib/layout-helpers/__expand_path.test.sh

@@ -0,0 +1,27 @@
+#! /usr/bin/env bash
+source "../../test-helper.sh"
+source "${root}/lib/layout-helpers.sh"
+
+#
+# __expand_path() tests.
+#
+
+# Setup.
+realHOME="$HOME"
+HOME="/home/test-user"
+
+# When given a path containing "~", it expands "~" to "$HOME".
+assert '__expand_path "~/Foo/Bar"' "${HOME}/Foo/Bar"
+
+# When given a path without "~", it returns path as is.
+assert '__expand_path "/path/to/file"' "/path/to/file"
+
+# When given a path containing spaces, it returns path correctly.
+assert '__expand_path "~/Path To/File"' "${HOME}/Path To/File"
+
+# Tear down.
+HOME="$realHOME"
+unset realHOME
+
+# End of tests.
+assert_end "__expand_path()"

test/lib/layout-helpers/__get_current_window_index.test.sh

@@ -0,0 +1,48 @@
+#! /usr/bin/env bash
+source "../../test-helper.sh"
+source "${root}/lib/layout-helpers.sh"
+
+#
+# __get_current_window_index() tests.
+#
+
+# When current window is the first and only window.
+create-test-session
+assert "__get_current_window_index" "0"
+kill-test-session
+
+# When creating a second window.
+create-test-session
+test-socket-tmux new-window -t "$session:1"
+assert "__get_current_window_index" "1"
+kill-test-session
+
+# When creating a second window and then switching back to the first window.
+create-test-session
+test-socket-tmux new-window -t "$session:1"
+test-socket-tmux select-window -t "$session:0"
+assert "__get_current_window_index" "0"
+kill-test-session
+
+# When creating multiples windows and switching between them randomly.
+create-test-session
+assert "__get_current_window_index" "0"
+test-socket-tmux new-window -t "$session:1"
+assert "__get_current_window_index" "1"
+test-socket-tmux new-window -t "$session:2"
+assert "__get_current_window_index" "2"
+test-socket-tmux new-window -t "$session:3"
+assert "__get_current_window_index" "3"
+test-socket-tmux select-window -t "$session:1"
+assert "__get_current_window_index" "1"
+test-socket-tmux select-window -t "$session:0"
+assert "__get_current_window_index" "0"
+test-socket-tmux select-window -t "$session:3"
+assert "__get_current_window_index" "3"
+test-socket-tmux select-window -t "$session:2"
+assert "__get_current_window_index" "2"
+kill-test-session
+
+
+# End of tests.
+assert_end "__get_current_window_index()"

test/lib/layout-helpers/__get_first_window_index.test.sh

@@ -0,0 +1,30 @@
+#! /usr/bin/env bash
+source "../../test-helper.sh"
+source "${root}/lib/layout-helpers.sh"
+
+#
+# __get_first_window_index() tests.
+#
+
+# When first window has a index of 0.
+create-test-session
+assert "__get_first_window_index" "0"
+kill-test-session
+
+# When first window has a index of 1.
+create-test-session
+test-socket-tmux new-window -t "$session:1"
+test-socket-tmux kill-window -t "$session:0"
+assert "__get_first_window_index" "1"
+kill-test-session
+
+# When first window has a index of 2.
+create-test-session
+test-socket-tmux new-window -t "$session:2"
+test-socket-tmux kill-window -t "$session:0"
+assert "__get_first_window_index" "2"
+kill-test-session
+
+
+# End of tests.
+assert_end "__get_first_window_index()"

test/lib/layout-helpers/__go_to_session.test.sh

@@ -0,0 +1,42 @@
+#! /usr/bin/env bash
+source "../../test-helper.sh"
+source "${root}/lib/layout-helpers.sh"
+
+#
+# __go_to_session() tests.
+#
+
+# Setup.
+session="tmuxifier-test-session"
+
+# When TMUX is not set, attach to $session.
+stub tmuxifier-tmux
+__go_to_session
+assert_raises \
+  "stub_called_with tmuxifier-tmux -u attach-session -t \"${session}:\"" 0
+restore tmuxifier-tmux
+
+# When TMUXIFIER_TMUX_ITERM_ATTACH is set, pass it in as first argument(s) to
+# tmuxifier-tmux
+TMUXIFIER_TMUX_ITERM_ATTACH="-CC"
+stub tmuxifier-tmux
+__go_to_session
+assert_raises \
+  "stub_called_with tmuxifier-tmux -CC -u attach-session -t \"${session}:\"" 0
+restore tmuxifier-tmux
+unset TMUXIFIER_TMUX_ITERM_ATTACH
+
+# When TMUX is set, switch to $session.
+TMUX="/tmp/tmux-501/default,1203,0"
+stub tmuxifier-tmux
+__go_to_session
+assert_raises \
+  "stub_called_with tmuxifier-tmux -u switch-client -t \"${session}:\"" 0
+restore tmuxifier-tmux
+unset TMUX
+
+# Tear down.
+unset session
+
+# End of tests.
+assert_end "__go_to_session()"

test/lib/layout-helpers/__go_to_window_or_session_path.test.sh

@@ -0,0 +1,88 @@
+#! /usr/bin/env bash
+source "../../test-helper.sh"
+source "${root}/lib/layout-helpers.sh"
+
+#
+# __go_to_window_or_session_path() tests.
+#
+
+# When neither $window_root or $session_root are set, does nothing.
+stub run_cmd
+__go_to_window_or_session_path
+assert "stub_called_times run_cmd" "0"
+restore run_cmd
+
+
+# When only $window_root is set, runs cd to $window_root path.
+stub run_cmd
+window_root="/tmp"
+__go_to_window_or_session_path
+assert 'stub_called_with_times run_cmd cd \"/tmp\"' "1"
+assert 'stub_called_with_times run_cmd clear' "1"
+unset window_root
+restore run_cmd
+
+
+# When only $TMUXIFIER_SESSION_ROOT is set, runs cd to $TMUXIFIER_SESSION_ROOT
+# path.
+stub run_cmd
+TMUXIFIER_SESSION_ROOT="/opt"
+__go_to_window_or_session_path
+assert 'stub_called_with_times run_cmd cd \"/opt\"' "1"
+assert 'stub_called_with_times run_cmd clear' "1"
+unset TMUXIFIER_SESSION_ROOT
+restore run_cmd
+
+
+# When only $session_root is set, runs cd to $session_root path.
+stub run_cmd
+session_root="/usr"
+__go_to_window_or_session_path
+assert 'stub_called_with_times run_cmd cd \"/usr\"' "1"
+assert 'stub_called_with_times run_cmd clear' "1"
+unset session_root
+restore run_cmd
+
+
+# When $window_root and $session_root are set, runs cd to $window_root path.
+stub run_cmd
+window_root="/tmp"
+session_root="/usr"
+__go_to_window_or_session_path
+assert 'stub_called_with_times run_cmd cd \"/tmp\"' "1"
+assert 'stub_called_with_times run_cmd clear' "1"
+unset window_root
+unset session_root
+restore run_cmd
+
+
+# When $TMUXIFIER_SESSION_ROOT and $session_root are set, runs cd to
+# $TMUXIFIER_SESSION_ROOT path.
+stub run_cmd
+TMUXIFIER_SESSION_ROOT="/opt"
+session_root="/usr"
+__go_to_window_or_session_path
+assert 'stub_called_with_times run_cmd cd \"/opt\"' "1"
+assert 'stub_called_with_times run_cmd clear' "1"
+unset TMUXIFIER_SESSION_ROOT
+unset session_root
+restore run_cmd
+
+
+# When $window_root, $TMUXIFIER_SESSION_ROOT, and $session_root are set, runs
+# cd to $window_root path.
+stub run_cmd
+window_root="/tmp"
+TMUXIFIER_SESSION_ROOT="/opt"
+session_root="/usr"
+__go_to_window_or_session_path
+assert 'stub_called_with_times run_cmd cd \"/tmp\"' "1"
+assert 'stub_called_with_times run_cmd clear' "1"
+unset window_root
+unset TMUXIFIER_SESSION_ROOT
+unset session_root
+restore run_cmd
+
+
+# End of tests.
+assert_end "__go_to_window_or_session_path()"

test/lib/layout-helpers/new_window.test.sh

@@ -0,0 +1,59 @@
+#! /usr/bin/env bash
+source "../../test-helper.sh"
+source "${root}/lib/layout-helpers.sh"
+
+#
+# new_window() tests.
+#
+
+# When called without arguments, creates new window.
+create-test-session
+stub __go_to_window_or_session_path
+assert "test-socket-window-count" "1"
+new_window
+assert "test-socket-window-count" "2"
+assert "stub_called_times __go_to_window_or_session_path" "1"
+restore __go_to_window_or_session_path
+kill-test-session
+
+# When called with name argument, creates new window with specified name.
+create-test-session
+stub __go_to_window_or_session_path
+assert "test-socket-window-count yippieezzz" "0"
+new_window "yippieezzz"
+assert "test-socket-window-count" "2"
+assert "test-socket-window-count yippieezzz" "1"
+restore __go_to_window_or_session_path
+kill-test-session
+
+# When called with name and command argument, creates new window with
+# specified name and executes given command.
+rm "/tmp/tmuxifier-new_window-test" &> /dev/null
+create-test-session
+stub __go_to_window_or_session_path
+new_window "foobardoo" "touch /tmp/tmuxifier-new_window-test; bash"
+assert "test-socket-window-count" "2"
+assert "test-socket-window-count foobardoo" "1"
+sleep 0.1 # attempt to avoid timing issue causing flicker
+assert_raises 'test -f "/tmp/tmuxifier-new_window-test"' 0
+restore __go_to_window_or_session_path
+kill-test-session
+rm "/tmp/tmuxifier-new_window-test" &> /dev/null
+
+# When called ensure it sets the $window variable to the index of the newly
+# created window.
+unset window
+create-test-session
+stub __go_to_window_or_session_path
+new_window "foo"
+assert "echo $window" "1"
+new_window
+assert "echo $window" "2"
+new_window "bar"
+assert "echo $window" "3"
+restore __go_to_window_or_session_path
+kill-test-session
+unset window
+
+# End of tests.
+assert_end "new_window()"

test/lib/layout-helpers/select_window.test.sh

@@ -0,0 +1,55 @@
+#! /usr/bin/env bash
+source "../../test-helper.sh"
+source "${root}/lib/layout-helpers.sh"
+
+#
+# select_window() tests.
+#
+
+window_list() {
+  test-socket-tmux list-windows -t "$session:" \
+    -F "#{window_active}:#{window_index}" 2>/dev/null
+}
+
+# Selects given window when passed a window index
+create-test-session
+test-socket-tmux new-window -t "$session:1"
+test-socket-tmux new-window -t "$session:2"
+select_window 0
+assert "window_list | grep '^1:'" "1:0"
+select_window 1
+assert "window_list | grep '^1:'" "1:1"
+select_window 2
+assert "window_list | grep '^1:'" "1:2"
+kill-test-session
+
+# Selects given window when passed a window name
+create-test-session
+test-socket-tmux new-window -t "$session:1" -n "foo"
+test-socket-tmux new-window -t "$session:2" -n "bar"
+select_window foo
+assert "window_list | grep '^1:'" "1:1"
+select_window bar
+assert "window_list | grep '^1:'" "1:2"
+kill-test-session
+
+
+# When called ensure it sets the $window variable to the index of the newly
+# created window.
+unset window
+create-test-session
+test-socket-tmux new-window -t "$session:1" -n "foo"
+test-socket-tmux new-window -t "$session:2" -n "bar"
+select_window "foo"
+assert "echo $window" "1"
+select_window "bar"
+assert "echo $window" "2"
+select_window 1
+assert "echo $window" "1"
+select_window 2
+assert "echo $window" "2"
+kill-test-session
+unset window
+
+# End of tests.
+assert_end "select_window()"

test/lib/layout-helpers/tmux.test.sh

@@ -0,0 +1,20 @@
+#! /usr/bin/env bash
+source "../../test-helper.sh"
+source "${root}/lib/layout-helpers.sh"
+
+#
+# tmux() tests.
+#
+
+# Passes all arguments to tmuxifier-tmux.
+stub tmuxifier-tmux
+tmux -V
+tmux --help
+tmux new -s dude
+assert_raises "stub_called_with tmuxifier-tmux -V" 0
+assert_raises "stub_called_with tmuxifier-tmux --help" 0
+assert_raises "stub_called_with tmuxifier-tmux new -s dude" 0
+restore tmuxifier-tmux
+
+# End of tests.
+assert_end "tmux()"

test/lib/runtime.test.sh

@@ -0,0 +1,23 @@
+#! /usr/bin/env bash
+source "../test-helper.sh"
+
+#
+# runtime.sh tests.
+#
+
+source "${root}/lib/runtime.sh"
+
+# We assume env.sh has been sourced if $TMUXIFIER_LAYOUT_PATH has been set.
+assert 'echo $TMUXIFIER_LAYOUT_PATH' "${TMUXIFIER}/layouts"
+
+# We ensure $session_root is set to $HOME by default.
+assert 'echo $session_root' "$HOME"
+
+# We assume layout-helpers.sh has been sourced if a few of them are available.
+for helper in new_window split_v split_h select_window select_pane; do
+  assert "type $helper | head -1" "$helper is a function"
+done
+
+
+# End of tests.
+assert_end "runtime.sh"

test/lib/util.test.sh

@@ -0,0 +1,58 @@
+#! /usr/bin/env bash
+source "../test-helper.sh"
+source "${root}/lib/util.sh"
+
+#
+# calling-help() tests.
+#
+
+# Returns 0 when "--help" is part of passed arguments.
+assert_raises 'calling-help --help' 0
+assert_raises 'calling-help foo --help' 0
+assert_raises 'calling-help --help bar' 0
+assert_raises 'calling-help foo --help bar' 0
+
+# Returns 0 when "-h" is part of passed arguments.
+assert_raises 'calling-help -h' 0
+assert_raises 'calling-help foo -h' 0
+assert_raises 'calling-help -h bar' 0
+assert_raises 'calling-help foo -h bar' 0
+
+# Returns 1 when neither "--help" or "-h" is not part of passed arguments.
+assert_raises 'calling-help' 1
+assert_raises 'calling-help foo' 1
+assert_raises 'calling-help foo bar' 1
+
+# Returns 1 when "--help" is part of passed arguments, but not free-standing.
+assert_raises 'calling-help --help-me' 1
+assert_raises 'calling-help foo--help' 1
+
+# Returns 1 when "-h" is part of passed arguments, but not free-standing.
+assert_raises 'calling-help -hj' 1
+assert_raises 'calling-help welcome-home' 1
+
+# End of tests.
+assert_end "calling-help()"
+
+
+#
+# calling-complete() tests.
+#
+
+# Returns 0 when "--complete" is part of passed arguments.
+assert_raises 'calling-complete --complete' 0
+assert_raises 'calling-complete foo --complete' 0
+assert_raises 'calling-complete --complete bar' 0
+assert_raises 'calling-complete foo --complete bar' 0
+
+# Returns 1 when "--complete" is not part of passed arguments.
+assert_raises 'calling-complete' 1
+assert_raises 'calling-complete foo' 1
+assert_raises 'calling-complete foo bar' 1
+
+# Returns 1 when "--complete" is part of passed arguments, but not free-standing.
+assert_raises 'calling-complete --complete-me' 1
+assert_raises 'calling-complete foo--complete' 1
+
+# End of tests.
+assert_end "calling-complete()"

test/libexec/tmuxifier-tmux.test.sh

@@ -0,0 +1,22 @@
+#! /usr/bin/env bash
+source "../test-helper.sh"
+source "${root}/lib/util.sh"
+
+#
+# tmuxifier-tmux tests.
+#
+
+# Setup.
+libexec="${root}/libexec"
+test-socket-tmux new-session -d -s foobar
+test-socket-tmux new-session -d -s dude
+
+# Passes all arguments to Tmux.
+assert "${libexec}/tmuxifier-tmux list-sessions -F \"- #{session_name}\"" \
+       "- dude\n- foobar"
+
+# Tear down.
+kill-test-server
+
+# End of tests.
+assert_end "tmuxifier-tmux"

test/test-helper.sh

@@ -0,0 +1,87 @@
+[ -n "$TEST_DEBUG" ] && set -x
+
+resolve_link() {
+  $(type -p greadlink readlink | head -1) $1
+}
+
+abs_dirname() {
+  local cwd="$(pwd)"
+  local path="$1"
+
+  while [ -n "$path" ]; do
+    cd "${path%/*}"
+    local name="${path##*/}"
+    path="$(resolve_link "$name" || true)"
+  done
+
+  pwd
+  cd "$cwd"
+}
+
+# Find and store path to Tmux binary.
+TMUX_BIN="$(command -v tmux)"
+
+# Set testroot variable.
+testroot="$(abs_dirname "$BASH_SOURCE")"
+
+# Set root variable.
+root="$(abs_dirname "$testroot/../..")"
+
+# Set TMUXIFIER environment variable.
+TMUXIFIER="$root"
+
+# Setup PATH environment variable.
+PATH="$root/bin:$root/libexec:$PATH"
+
+# Unset TMUX environment variable, tests assume they're not running within
+# Tmux.
+unset TMUX
+
+# Unset various Tmuxifier environment variables to prevent a local install of
+# Tmuxifier interfering with tests.
+unset TMUXIFIER_LAYOUT_PATH
+unset TMUXIFIER_TMUX_OPTS
+unset TMUXIFIER_NO_COMPLETE
+
+# Include assert.sh and stub.sh libraries.
+source "${testroot}/assert.sh"
+source "${testroot}/stub.sh"
+
+
+#
+# Test Helpers
+#
+
+test-socket-tmux() {
+  export TMUXIFIER_TMUX_OPTS="-L tmuxifier-tests"
+  "$TMUX_BIN" $TMUXIFIER_TMUX_OPTS $@
+}
+
+create-test-session() {
+  session="$1"
+  if [ -z "$session" ]; then session="test"; fi
+
+  test-socket-tmux new-session -d -s "$session"
+}
+
+kill-test-session() {
+  local target="$1"
+  if [ -z "$target" ]; then target="$session"; fi
+
+  test-socket-tmux kill-session -t "$target"
+}
+
+kill-test-server() {
+  test-socket-tmux kill-server
+  unset TMUXIFIER_TMUX_OPTS
+  unset session
+}
+
+test-socket-window-count() {
+  local list="$(test-socket-tmux list-windows)"
+  if [ -n "$1" ]; then
+    echo "$list" | grep $1 | wc -l | awk '{print $1}'
+  else
+    echo "$list" | wc -l | awk '{print $1}'
+  fi
+}