v0.4.0

Close #25

CHANGELOG.md

@@ -2,6 +2,38 @@
 
 ### master
 
+### v0.4.0, 2014-08-29
+- change plugin name to `tmux-resurrect`. Change all the variable names.
+
+### v0.3.0, 2014-08-29
+- bugfix: when top is running the pane `$PWD` can't be saved. This was causing
+  issues during the restore and is now fixed.
+- restoring sessions multiple times messes up the whole environment - new panes
+  are all around. This is now fixed - pane restorations are now idempotent.
+- if pane exists from before session restore - do not restore the process within
+  it. This makes the restoration process even more idempotent.
+- more panes within a window can now be restored
+- restore window zoom state
+
+### v0.2.0, 2014-08-29
+- bugfix: with vim 'session' strategy, if the session file does not exist - make
+  sure vim does not contain `-S` flag
+- enable restoring programs with arguments (e.g. "rails console") and also
+  processes that contain program name
+- improve `irb` restore strategy
+
+### v0.1.0, 2014-08-28
+- refactor checking if saved tmux session exists
+- spinner while tmux sessions are restored
+
+### v0.0.5, 2014-08-28
+- restore pane processes
+- user option for disabling pane process restoring
+- enable whitelisting processes that will be restored
+- expand readme with configuration options
+- enable command strategies; enable restoring vim sessions
+- update readme: explain restoring vim sessions
+
 ### v0.0.4, 2014-08-26
 - restore pane layout for each window
 - bugfix: correct pane ordering in a window

CONTRIBUTING.md

@@ -0,0 +1,12 @@
+### Contributing
+
+Code contributions are welcome!
+
+### Reporting a bug
+
+If you find a bug please report it in the issues. When reporting a bug please
+attach:
+- a file symlinked to `~/.tmux/resurrect/last`.
+- your `.tmux.conf`
+- if you're getting an error paste it to a [gist](https://gist.github.com/) and
+  link it in the issue

README.md

@@ -1,19 +1,50 @@
-# Tmux Session Saver
+# Tmux Resurrect
 
-Enables saving and restoring of tmux sessions.
+Restore `tmux` environment after a system restart.
+
+Tmux is great, except when you have to restart the computer. You loose all the
+running programs, working directories, pane layouts etc.
+There are helpful management tools out there, but they require initial
+configuration and continuous updates as your workflow evolves or you start new
+projects.
+
+`tmux-resurrect` saves all the little details from tmux environment so it
+can be completely restored after a system restart. No configuration is required.
+You should feel like you never quit tmux.
+
+It even (optionally) [restores vim sessions](#restoring-vim-sessions)!
 
 ### Key bindings
 
-- `prefix + M-s` - save
-- `prefix + M-r` - restore
+- `prefix + Alt-s` - save
+- `prefix + Alt-r` - restore
+
+### About
+
+This plugin goes to great lengths to save and restore all the details from your
+`tmux` environment. Here's what's been taken care of:
+
+- all sessions, windows, panes and their order
+- current working directory for each pane
+- **exact pane layouts** within windows
+- active and alternative session
+- active and alternative window for each session
+- windows with focus
+- active pane for each window
+- programs running within a pane! More details in the
+  [configuration section](#configuration).
+- restoring vim sessions (optional). More details in
+  [restoring vim sessions](#restoring-vim-sessions).
+
+Requirements / dependencies: `tmux 1.9` or higher, `pgrep`
 
 ### Installation with [Tmux Plugin Manager](https://github.com/tmux-plugins/tpm) (recommended)
 
 Add plugin to the list of TPM plugins in `.tmux.conf`:
 
-    set -g @tpm_plugins "              \
-      tmux-plugins/tpm                 \
-      tmux-plugins/tmux-session-saver  \
+    set -g @tpm_plugins "           \
+      tmux-plugins/tpm              \
+      tmux-plugins/tmux-resurrect   \
     "
 
 Hit `prefix + I` to fetch the plugin and source it. You should now be able to
@@ -23,11 +54,11 @@ use the plugin.
 
 Clone the repo:
 
-    $ git clone https://github.com/tmux-plugins/tmux-session-saver ~/clone/path
+    $ git clone https://github.com/tmux-plugins/tmux-resurrect ~/clone/path
 
 Add this line to the bottom of `.tmux.conf`:
 
-    run-shell ~/clone/path/session_saver.tmux
+    run-shell ~/clone/path/resurrect.tmux
 
 Reload TMUX environment:
 
@@ -36,5 +67,53 @@ Reload TMUX environment:
 
 You should now be able to use the plugin.
 
+### Configuration
+
+Configuration is not required - but it enables extra features.
+
+Only a conservative list of programs is restored by default:<br/>
+`vi vim emacs man less more tail top htop irssi irb pry "~rails console"`.
+Open a github issue if you think some other program should be on the default list.
+
+- Restore additional programs with the setting in `.tmux.conf`:
+
+        set -g @resurrect-processes 'ssh psql mysql sqlite3'
+
+- Programs with arguments should be double quoted:
+
+        set -g @resurrect-processes 'some_program "git log"'
+
+- Start with tilde to restore a program whose process contains target name:
+
+        set -g @resurrect-processes 'some_program "~rails server"'
+
+- Don't restore any programs:
+
+        set -g @resurrect-processes 'false'
+
+- Restore **all** programs (be careful with this!):
+
+        set -g @resurrect-processes ':all:'
+
+#### Restoring vim sessions
+
+- save vim sessions. I recommend [tpope/vim-obsession](tpope/vim-obsession).
+- in `.tmux.conf`:
+
+        set -g @resurrect-strategy-vim "session"
+
+`tmux-resurrect` will now restore vim sessions if `Sessions.vim` file is
+present.
+
+### Reporting bugs and contributing
+
+Both contributing and bug reports are welcome. Please check out
+[contributing guidelines](CONTRIBUTING.md).
+
+### Credits
+
+[Mislav Marohnić](https://github.com/mislav) - the idea for the plugin came from his
+[tmux-session script](https://github.com/mislav/dotfiles/blob/master/bin/tmux-session).
+
 ### License
 [MIT](LICENSE.md)

resurrect.tmux

@@ -2,19 +2,14 @@
 
 CURRENT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 
+source "$CURRENT_DIR/scripts/variables.sh"
 source "$CURRENT_DIR/scripts/helpers.sh"
 
-default_save_key="M-s"
-save_option="@session-saver-save"
-
-default_restore_key="M-r"
-restore_option="@session-saver-restore"
-
 set_save_bindings() {
 	local key_bindings=$(get_tmux_option "$save_option" "$default_save_key")
 	local key
 	for key in $key_bindings; do
-		tmux bind-key "$key" run-shell "$CURRENT_DIR/scripts/session_saver.sh"
+		tmux bind-key "$key" run-shell "$CURRENT_DIR/scripts/save.sh"
 	done
 }
 
@@ -22,12 +17,17 @@ set_restore_bindings() {
 	local key_bindings=$(get_tmux_option "$restore_option" "$default_restore_key")
 	local key
 	for key in $key_bindings; do
-		tmux bind-key "$key" run-shell "$CURRENT_DIR/scripts/session_restorer.sh"
+		tmux bind-key "$key" run-shell "$CURRENT_DIR/scripts/restore.sh"
 	done
 }
 
+set_default_strategies() {
+	tmux set-option -g "${restore_process_strategy_option}irb" "default_strategy"
+}
+
 main() {
 	set_save_bindings
 	set_restore_bindings
+	set_default_strategies
 }
 main

scripts/helpers.sh

@@ -1,6 +1,5 @@
-# configurable constants
-default_sessions_dir="$HOME/.tmux/sessions"
-sessions_dir_option="@sessions-dir"
+default_resurrect_dir="$HOME/.tmux/resurrect"
+resurrect_dir_option="@resurrect-dir"
 
 SUPPORTED_VERSION="1.9"
 
@@ -46,17 +45,21 @@ supported_tmux_version_ok() {
 	$CURRENT_DIR/check_tmux_version.sh "$SUPPORTED_VERSION"
 }
 
+remove_first_char() {
+	echo "$1" | cut -c2-
+}
+
 # path helpers
 
-sessions_dir() {
-	echo $(get_tmux_option "$sessions_dir_option" "$default_sessions_dir")
+resurrect_dir() {
+	echo $(get_tmux_option "$resurrect_dir_option" "$default_resurrect_dir")
 }
 
-session_path() {
+resurrect_file_path() {
 	local timestamp="$(date +"%Y-%m-%dT%H:%M:%S")"
-	echo "$(sessions_dir)/tmux_session_${timestamp}.txt"
+	echo "$(resurrect_dir)/tmux_resurrect_${timestamp}.txt"
 }
 
-last_session_path() {
-	echo "$(sessions_dir)/last"
+last_resurrect_file() {
+	echo "$(resurrect_dir)/last"
 }

scripts/process_restore_helpers.sh

@@ -0,0 +1,123 @@
+restore_pane_processes_enabled() {
+	local restore_processes="$(get_tmux_option "$restore_processes_option" "$restore_processes")"
+	if [ "$restore_processes" == "false" ]; then
+		return 1
+	else
+		return 0
+	fi
+}
+
+restore_pane_process() {
+	local pane_full_command="$1"
+	local session_name="$2"
+	local window_number="$3"
+	local pane_index="$4"
+	local dir="$5"
+	if _process_should_be_restored "$pane_full_command" "$session_name" "$window_number" "$pane_index"; then
+		tmux switch-client -t "${session_name}:${window_number}"
+		tmux select-pane -t "$pane_index"
+
+		if _strategy_exists "$pane_full_command"; then
+			local strategy_file="$(_get_strategy_file "$pane_full_command")"
+			local strategy_command="$($strategy_file "$pane_full_command" "$dir")"
+			tmux send-keys "$strategy_command" "C-m"
+		else
+			# just invoke the command
+			tmux send-keys "$pane_full_command" "C-m"
+		fi
+	fi
+}
+
+# private functions below
+
+_process_should_be_restored() {
+	local pane_full_command="$1"
+	local session_name="$2"
+	local window_number="$3"
+	local pane_index="$4"
+	if is_pane_registered_as_existing "$session_name" "$window_number" "$pane_index"; then
+		# Scenario where pane existed before restoration, so we're not
+		# restoring the proces either.
+		return 1
+	elif _restore_all_processes; then
+		return 0
+	elif _process_on_the_restore_list "$pane_full_command"; then
+		return 0
+	else
+		return 1
+	fi
+}
+
+_restore_all_processes() {
+	local restore_processes="$(get_tmux_option "$restore_processes_option" "$restore_processes")"
+	if [ $restore_processes == ":all:" ]; then
+		return 0
+	else
+		return 1
+	fi
+}
+
+_process_on_the_restore_list() {
+	local pane_full_command="$1"
+	# TODO: make this work without eval
+	eval set $(_restore_list)
+	local proc
+	for proc in "$@"; do
+		if _proc_starts_with_tildae "$proc"; then
+			proc="$(remove_first_char "$proc")"
+			# regex matching the command makes sure `$proc` string is somewhere the command string
+			if [[ "$pane_full_command" =~ ($proc) ]]; then
+				return 0
+			fi
+		else
+			# regex matching the command makes sure process is a "word"
+			if [[ "$pane_full_command" =~ (^${proc} ) ]] || [[ "$pane_full_command" =~ (^${proc}$) ]]; then
+				return 0
+			fi
+		fi
+	done
+	return 1
+}
+
+_restore_list() {
+	local user_processes="$(get_tmux_option "$restore_processes_option" "$restore_processes")"
+	local default_processes="$(get_tmux_option "$default_proc_list_option" "$default_proc_list")"
+	if [ -z $user_processes ]; then
+		# user didn't define any processes
+		echo "$default_processes"
+	else
+		echo "$default_processes $user_processes"
+	fi
+}
+
+_proc_starts_with_tildae() {
+	[[ "$1" =~ (^~) ]]
+}
+
+_strategy_exists() {
+	local pane_full_command="$1"
+	local strategy="$(_get_command_strategy "$pane_full_command")"
+	if [ -n "$strategy" ]; then # strategy set?
+		local strategy_file="$(_get_strategy_file "$pane_full_command")"
+		[ -e "$strategy_file" ] # strategy file exists?
+	else
+		return 1
+	fi
+}
+
+_get_command_strategy() {
+	local pane_full_command="$1"
+	local command="$(_just_command "$pane_full_command")"
+	get_tmux_option "${restore_process_strategy_option}${command}" ""
+}
+
+_just_command() {
+	echo "$1" | cut -d' ' -f1
+}
+
+_get_strategy_file() {
+	local pane_full_command="$1"
+	local strategy="$(_get_command_strategy "$pane_full_command")"
+	local command="$(_just_command "$pane_full_command")"
+	echo "$CURRENT_DIR/../strategies/${command}_${strategy}.sh"
+}

scripts/restore.sh

@@ -0,0 +1,208 @@
+#!/usr/bin/env bash
+
+CURRENT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+source "$CURRENT_DIR/variables.sh"
+source "$CURRENT_DIR/helpers.sh"
+source "$CURRENT_DIR/process_restore_helpers.sh"
+source "$CURRENT_DIR/spinner_helpers.sh"
+
+# Global variable.
+# Used during the restore: if a pane already exists from before, it is
+# saved in the array in this variable. Later, process running in existing pane
+# is also not restored. That makes the restoration process more idempotent.
+EXISTING_PANES_VAR=""
+
+is_line_type() {
+	local line_type="$1"
+	local line="$2"
+	echo "$line" |
+		\grep -q "^$line_type"
+}
+
+check_saved_session_exists() {
+	local resurrect_file="$(last_resurrect_file)"
+	if [ ! -f $resurrect_file ]; then
+		display_message "Tmux resurrect file not found!"
+		return 1
+	fi
+}
+
+pane_exists() {
+	local session_name="$1"
+	local window_number="$2"
+	local pane_index="$3"
+	tmux list-panes -t "${session_name}:${window_number}" -F "#{pane_index}" 2>/dev/null |
+		\grep -q "^$pane_index$"
+}
+
+register_existing_pane() {
+	local session_name="$1"
+	local window_number="$2"
+	local pane_index="$3"
+	local pane_custom_id="${session_name}:${window_number}:${pane_index}"
+	local delimiter=$'\t'
+	EXISTING_PANES_VAR="${EXISTING_PANES_VAR}${delimiter}${pane_custom_id}"
+}
+
+is_pane_registered_as_existing() {
+	local session_name="$1"
+	local window_number="$2"
+	local pane_index="$3"
+	local pane_custom_id="${session_name}:${window_number}:${pane_index}"
+	[[ "$EXISTING_PANES_VAR" =~ "$pane_custom_id" ]]
+}
+
+window_exists() {
+	local session_name="$1"
+	local window_number="$2"
+	tmux list-windows -t "$session_name" -F "#{window_index}" 2>/dev/null |
+		\grep -q "^$window_number$"
+}
+
+session_exists() {
+	local session_name="$1"
+	tmux has-session -t "$session_name" 2>/dev/null
+}
+
+first_window_num() {
+	tmux show -gv base-index
+}
+
+tmux_socket() {
+	echo $TMUX | cut -d',' -f1
+}
+
+new_window() {
+	local session_name="$1"
+	local window_number="$2"
+	local window_name="$3"
+	local dir="$4"
+	tmux new-window -d -t "${session_name}:${window_number}" -n "$window_name" -c "$dir"
+}
+
+new_session() {
+	local session_name="$1"
+	local window_number="$2"
+	local window_name="$3"
+	local dir="$4"
+	TMUX="" tmux -S "$(tmux_socket)" new-session -d -s "$session_name" -n "$window_name" -c "$dir"
+	# change first window number if necessary
+	local created_window_num="$(first_window_num)"
+	if [ $created_window_num -ne $window_number ]; then
+		tmux move-window -s "${session_name}:${created_window_num}" -t "${session_name}:${window_number}"
+	fi
+}
+
+new_pane() {
+	local session_name="$1"
+	local window_number="$2"
+	local window_name="$3"
+	local dir="$4"
+	tmux split-window -t "${session_name}:${window_number}" -c "$dir" -h
+	tmux resize-pane  -t "${session_name}:${window_number}" -L "999"
+}
+
+restore_pane() {
+	local pane="$1"
+	while IFS=$'\t' read line_type session_name window_number window_name window_active window_flags pane_index dir pane_active pane_command pane_full_command; do
+		dir="$(remove_first_char "$dir")"
+		window_name="$(remove_first_char "$window_name")"
+		pane_full_command="$(remove_first_char "$pane_full_command")"
+		if pane_exists "$session_name" "$window_number" "$pane_index"; then
+			# Pane exists, no need to create it!
+			# Pane existence is registered. Later, it's process also isn't restored.
+			register_existing_pane "$session_name" "$window_number" "$pane_index"
+		elif window_exists "$session_name" "$window_number"; then
+			new_pane "$session_name" "$window_number" "$window_name" "$dir"
+		elif session_exists "$session_name"; then
+			new_window "$session_name" "$window_number" "$window_name" "$dir"
+		else
+			new_session "$session_name" "$window_number" "$window_name" "$dir"
+		fi
+	done < <(echo "$pane")
+}
+
+restore_state() {
+	local state="$1"
+	echo "$state" |
+	while IFS=$'\t' read line_type client_session client_last_session; do
+		tmux switch-client -t "$client_last_session"
+		tmux switch-client -t "$client_session"
+	done
+}
+
+restore_all_panes() {
+	while read line; do
+		if is_line_type "pane" "$line"; then
+			restore_pane "$line"
+		fi
+	done < $(last_resurrect_file)
+}
+
+restore_all_pane_processes() {
+	if restore_pane_processes_enabled; then
+		local pane_full_command
+		awk 'BEGIN { FS="\t"; OFS="\t" } /^pane/ && $11 !~ "^:$" { print $2, $3, $7, $8, $11; }' $(last_resurrect_file) |
+			while IFS=$'\t' read session_name window_number pane_index dir pane_full_command; do
+				dir="$(remove_first_char "$dir")"
+				pane_full_command="$(remove_first_char "$pane_full_command")"
+				restore_pane_process "$pane_full_command" "$session_name" "$window_number" "$pane_index" "$dir"
+			done
+	fi
+}
+
+restore_pane_layout_for_each_window() {
+	\grep '^window' $(last_resurrect_file) |
+		while IFS=$'\t' read line_type session_name window_number window_active window_flags window_layout; do
+			tmux select-layout -t "${session_name}:${window_number}" "$window_layout"
+		done
+}
+
+restore_active_pane_for_each_window() {
+	awk 'BEGIN { FS="\t"; OFS="\t" } /^pane/ && $9 == 1 { print $2, $3, $7; }' $(last_resurrect_file) |
+		while IFS=$'\t' read session_name window_number active_pane; do
+			tmux switch-client -t "${session_name}:${window_number}"
+			tmux select-pane -t "$active_pane"
+		done
+}
+
+restore_zoomed_windows() {
+	awk 'BEGIN { FS="\t"; OFS="\t" } /^window/ && $5 ~ /Z/ { print $2, $3; }' $(last_resurrect_file) |
+		while IFS=$'\t' read session_name window_number; do
+			tmux resize-pane -t "${session_name}:${window_number}" -Z
+		done
+}
+
+restore_active_and_alternate_windows() {
+	awk 'BEGIN { FS="\t"; OFS="\t" } /^window/ && $5 ~ /[*-]/ { print $2, $4, $3; }' $(last_resurrect_file) |
+		sort -u |
+		while IFS=$'\t' read session_name active_window window_number; do
+			tmux switch-client -t "${session_name}:${window_number}"
+		done
+}
+
+restore_active_and_alternate_sessions() {
+	while read line; do
+		if is_line_type "state" "$line"; then
+			restore_state "$line"
+		fi
+	done < $(last_resurrect_file)
+}
+
+main() {
+	if supported_tmux_version_ok && check_saved_session_exists; then
+		start_spinner
+		restore_all_panes
+		restore_pane_layout_for_each_window >/dev/null 2>&1
+		restore_all_pane_processes
+		# below functions restore exact cursor positions
+		restore_active_pane_for_each_window
+		restore_zoomed_windows
+		restore_active_and_alternate_windows
+		restore_active_and_alternate_sessions
+		stop_spinner
+		display_message "Tmux restore complete!"
+	fi
+}
+main

scripts/save.sh

@@ -2,6 +2,7 @@
 
 CURRENT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 
+source "$CURRENT_DIR/scripts/variables.sh"
 source "$CURRENT_DIR/helpers.sh"
 
 pane_format() {
@@ -21,9 +22,13 @@ pane_format() {
 	format+="${delimiter}"
 	format+="#{pane_index}"
 	format+="${delimiter}"
-	format+="#{pane_current_path}"
+	format+=":#{pane_current_path}"
 	format+="${delimiter}"
 	format+="#{pane_active}"
+	format+="${delimiter}"
+	format+="#{pane_current_command}"
+	format+="${delimiter}"
+	format+="#{pane_pid}"
 	echo "$format"
 }
 
@@ -55,10 +60,27 @@ state_format() {
 	echo "$format"
 }
 
-dump_panes() {
+dump_panes_raw() {
 	tmux list-panes -a -F "$(pane_format)"
 }
 
+pane_full_command() {
+	pane_pid="$1"
+	\pgrep -lf -P "$pane_pid" |
+		cut -d' ' -f2-
+}
+
+# translates pane pid to process command running inside a pane
+dump_panes() {
+	local full_command
+	local d=$'\t' # delimiter
+	dump_panes_raw |
+		while IFS=$'\t' read line_type session_name window_number window_name window_active window_flags pane_index dir pane_active pane_command pane_pid; do
+			full_command="$(pane_full_command $pane_pid)"
+			echo "${line_type}${d}${session_name}${d}${window_number}${d}${window_name}${d}${window_active}${d}${window_flags}${d}${pane_index}${d}${dir}${d}${pane_active}${d}${pane_command}${d}:${full_command}"
+		done
+}
+
 dump_windows() {
 	tmux list-windows -a -F "$(window_format)"
 }
@@ -67,19 +89,19 @@ dump_state() {
 	tmux display-message -p "$(state_format)"
 }
 
-save_all_sessions() {
-	local session_path="$(session_path)"
-	mkdir -p "$(sessions_dir)"
-	dump_panes   >  $session_path
-	dump_windows >> $session_path
-	dump_state   >> $session_path
-	ln -fs "$session_path" "$(last_session_path)"
-	display_message "Saved all Tmux sessions!"
+save_all() {
+	local resurrect_file_path="$(resurrect_file_path)"
+	mkdir -p "$(resurrect_dir)"
+	dump_panes   >  $resurrect_file_path
+	dump_windows >> $resurrect_file_path
+	dump_state   >> $resurrect_file_path
+	ln -fs "$resurrect_file_path" "$(last_resurrect_file)"
+	display_message "Tmux environment saved!"
 }
 
 main() {
 	if supported_tmux_version_ok; then
-		save_all_sessions
+		save_all
 	fi
 }
 main

scripts/session_restorer.sh

@@ -1,149 +0,0 @@
-#!/usr/bin/env bash
-
-CURRENT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-
-source "$CURRENT_DIR/helpers.sh"
-
-is_line_type() {
-	local line_type="$1"
-	local line="$2"
-	echo "$line" |
-		\grep -q "^$line_type"
-}
-
-check_saved_session_exists() {
-	local saved_session="$(last_session_path)"
-	if [ ! -f $saved_session ]; then
-		display_message "Saved session not found!"
-		exit
-	fi
-}
-
-window_exists() {
-	local session_name="$1"
-	local window_number="$2"
-	tmux list-windows -t "$session_name" -F "#{window_index}" 2>/dev/null |
-		\grep -q "^$window_number$"
-}
-
-session_exists() {
-	local session_name="$1"
-	tmux has-session -t "$session_name" 2>/dev/null
-}
-
-first_window_num() {
-	tmux show -gv base-index
-}
-
-tmux_socket() {
-	echo $TMUX | cut -d',' -f1
-}
-
-remove_first_char() {
-	echo "$1" | cut -c2-
-}
-
-new_window() {
-	local session_name="$1"
-	local window_number="$2"
-	local window_name="$3"
-	local dir="$4"
-	tmux new-window -d -t "${session_name}:${window_number}" -n "$window_name" -c "$dir"
-}
-
-new_session() {
-	local session_name="$1"
-	local window_number="$2"
-	local window_name="$3"
-	local dir="$4"
-	TMUX="" tmux -S "$(tmux_socket)" new-session -d -s "$session_name" -n "$window_name" -c "$dir"
-	# change first window number if necessary
-	local created_window_num="$(first_window_num)"
-	if [ $created_window_num -ne $window_number ]; then
-		tmux move-window -s "${session_name}:${created_window_num}" -t "${session_name}:${window_number}"
-	fi
-}
-
-new_pane() {
-	local session_name="$1"
-	local window_number="$2"
-	local window_name="$3"
-	local dir="$4"
-	tmux split-window -t "${session_name}:${window_number}" -c "$dir"
-}
-
-restore_pane() {
-	local pane="$1"
-	echo "$pane" |
-	while IFS=$'\t' read line_type session_name window_number window_name window_active window_flags pane_index dir pane_active; do
-		window_name="$(remove_first_char $window_name)"
-		if window_exists "$session_name" "$window_number"; then
-			new_pane "$session_name" "$window_number" "$window_name" "$dir"
-		elif session_exists "$session_name"; then
-			new_window "$session_name" "$window_number" "$window_name" "$dir"
-		else
-			new_session "$session_name" "$window_number" "$window_name" "$dir"
-		fi
-	done
-}
-
-restore_state() {
-	local state="$1"
-	echo "$state" |
-	while IFS=$'\t' read line_type client_session client_last_session; do
-		tmux switch-client -t "$client_last_session"
-		tmux switch-client -t "$client_session"
-	done
-}
-
-restore_all_sessions() {
-	while read line; do
-		if is_line_type "pane" "$line"; then
-			restore_pane "$line"
-		fi
-	done < $(last_session_path)
-}
-
-restore_pane_layout_for_each_window() {
-	\grep '^window' $(last_session_path) |
-		while IFS=$'\t' read line_type session_name window_number window_active window_flags window_layout; do
-			tmux select-layout -t "${session_name}:${window_number}" "$window_layout"
-		done
-}
-
-restore_active_pane_for_each_window() {
-	awk 'BEGIN { FS="\t"; OFS="\t" } /^pane/ && $7 != 0 && $9 == 1 { print $2, $3, $7; }' $(last_session_path) |
-		while IFS=$'\t' read session_name window_number active_pane; do
-			tmux switch-client -t "${session_name}:${window_number}"
-			tmux select-pane -t "$active_pane"
-		done
-}
-
-restore_active_and_alternate_windows() {
-	awk 'BEGIN { FS="\t"; OFS="\t" } /^window/ && $5 ~ /[*-]/ { print $2, $4, $3; }' $(last_session_path) |
-		sort -u |
-		while IFS=$'\t' read session_name active_window window_number; do
-			tmux switch-client -t "${session_name}:${window_number}"
-		done
-}
-
-restore_active_and_alternate_sessions() {
-	while read line; do
-		if is_line_type "state" "$line"; then
-			restore_state "$line"
-		fi
-	done < $(last_session_path)
-}
-
-main() {
-	if supported_tmux_version_ok; then
-		check_saved_session_exists
-		restore_all_sessions
-		restore_pane_layout_for_each_window
-		restore_active_pane_for_each_window
-		restore_active_and_alternate_windows
-		restore_active_and_alternate_sessions
-		display_message "Restored all Tmux sessions!"
-	fi
-}
-main

scripts/spinner_helpers.sh

@@ -0,0 +1,8 @@
+start_spinner() {
+	$CURRENT_DIR/tmux_spinner.sh "Restoring tmux..." "Tmux restore complete!" &
+	export SPINNER_PID=$!
+}
+
+stop_spinner() {
+	kill $SPINNER_PID
+}

scripts/tmux_spinner.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+
+# This script shows tmux spinner with a message. It is intended to be running
+# as a background process which should be `kill`ed at the end.
+#
+# Example usage:
+#
+#   ./tmux_spinner.sh "Working..." "End message!" &
+#   SPINNER_PID=$!
+#   ..
+#   .. execute commands here
+#   ..
+#   kill $SPINNER_PID # Stops spinner and displays 'End message!'
+
+MESSAGE="$1"
+END_MESSAGE="$2"
+SPIN='-\|/'
+
+trap "tmux display-message $END_MESSAGE; exit" SIGINT SIGTERM
+
+main() {
+	local i=0
+	while true; do
+	  i=$(( (i+1) %4 ))
+	  tmux display-message " ${SPIN:$i:1} $MESSAGE"
+	  sleep 0.1
+	done
+}
+main

scripts/variables.sh

@@ -0,0 +1,23 @@
+# key bindings
+default_save_key="M-s"
+save_option="@resurrect-save"
+
+default_restore_key="M-r"
+restore_option="@resurrect-restore"
+
+# default processes that are restored
+default_proc_list_option="@resurrect-default-processes"
+default_proc_list='vi vim emacs man less more tail top htop irssi irb pry "~rails console"'
+
+# User defined processes that are restored
+#  'false' - nothing is restored
+#  ':all:' - all processes are restored
+#
+# user defined list of programs that are restored:
+#  'my_program foo another_program'
+restore_processes_option="@resurrect-processes"
+restore_processes=""
+
+# Defines part of the user variable. Example usage:
+#   set -g @resurrect-strategy-vim "session"
+restore_process_strategy_option="@resurrect-strategy-"

strategies/irb_default_strategy.sh

@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+
+# "irb default strategy"
+#
+# Example irb process with junk variables:
+#   irb RBENV_VERSION=1.9.3-p429 GREP_COLOR=34;47 TERM_PROGRAM=Apple_Terminal
+#
+# When executed, the above will fail. This strategy handles that.
+
+ORIGINAL_COMMAND="$1"
+DIRECTORY="$2"
+
+original_command_wo_junk_vars() {
+	echo "$ORIGINAL_COMMAND" |
+		sed 's/RBENV_VERSION[^ ]*//' |
+		sed 's/GREP_COLOR[^ ]*//'    |
+		sed 's/TERM_PROGRAM[^ ]*//'
+}
+
+main() {
+	echo "$(original_command_wo_junk_vars)"
+}
+main

strategies/vim_session.sh

@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+
+# "vim session strategy"
+#
+# Restores a vim session from 'Session.vim' file, if it exists.
+# If 'Session.vim' does not exist, it falls back to invoking the original
+# command (without the `-S` flag).
+
+ORIGINAL_COMMAND="$1"
+DIRECTORY="$2"
+
+vim_session_file_exists() {
+	[ -e "${DIRECTORY}/Session.vim" ]
+}
+
+original_command_contains_session_flag() {
+	[[ "$ORIGINAL_COMMAND" =~ "-S" ]]
+}
+
+main() {
+	if vim_session_file_exists; then
+		echo "vim -S"
+	elif original_command_contains_session_flag; then
+		# Session file does not exist, yet the original vim command contains
+		# session flag `-S`. This will cause an error, so we're falling back to
+		# starting plain vim.
+		echo "vim"
+	else
+		echo "$ORIGINAL_COMMAND"
+	fi
+}
+main