rvm 1.0.2 → 1.0.3

data/scripts/set

@@ -100,7 +100,8 @@ __rvm_summary() {
     summary="$summary \033[0;31m${#errors[*]} errors: $(echo "${errors[*]}" | sed 's# #, #g')\033[0m\n"
   fi
   total=${#rubies[*]}
-  if [[ ! -z "$ZSH_VERSION" ]] ; then array_start=1 ; else array_start=0 ; fi
+  if [[ -n "${ZSH_VERSION:-""}" ]] ; then array_start=1 ; else array_start=0 ; fi
+
   printf "$summary" | tee -a log/summary.log
   return ${#errors[*]}
 }
@@ -114,7 +115,7 @@ __rvm_yaml() {
   for var in ${errors[*]} ; do yaml="$yaml\n  - $var" ; done
   yaml="$yaml\nrubies:"
   total=${#rubies[*]}
-  if [[ ! -z "$ZSH_VERSION" ]] ; then array_start=1 ; else array_start=0 ; fi
+  if [[ -n "${ZSH_VERSION:-""}" ]] ; then array_start=1 ; else array_start=0 ; fi
   for (( index = $array_start ; index < $total + $array_start ; index++ )) ; do
     if [[ ! -z "$rvm_debug_flag" ]] ; then
       "$rvm_scripts_path/log" "debug" "${rubies[$index]}: ${statuses[$index]}"
@@ -136,7 +137,8 @@ __rvm_json() {
   json="$json\n  \"rubies\": {"
 
   total=${#rubies[*]}
-  if [[ ! -z "$ZSH_VERSION" ]] ; then array_start=1 ; else array_start=0 ; fi
+  if [[ -n "${ZSH_VERSION:-""}" ]] ; then array_start=1 ; else array_start=0 ; fi
+
   for (( index = $array_start ; index < $total + $array_start ; index++ )) ; do
     if [[ ! -z "$rvm_debug_flag" ]] ; then
       "$rvm_scripts_path/log" "debug" "${rubies[$index]}: ${statuses[$index]}"
@@ -157,10 +159,9 @@ __rvm_json() {
 
 rubies=() ; successes=() ; errors=() ; statuses=()
 
-
-action="$1";
-[[ "$#" -gt 0 ]] && shift
-args="$*"
+args=($*)
+action="${args[0]}"
+args="$(echo ${args[@]:1}) " # Strip trailing / leading / extra spacing.
 
 if [[ "$action" == "ruby" ]] && echo "$args" | \grep -q  "^'--[^[:space:]]*'$" ; then
   "$rvm_scripts_path/log" "warn" "You called rvm ruby with the arguments $args which look like use options."

data/scripts/snapshot

@@ -178,12 +178,14 @@ snapshot_usage() {
   return 1
 }
 
-action="$1"
-[[ "$#" -gt 0 ]] && shift
+
+args=($*)
+action="${args[0]}"
+args="$(echo ${args[@]:1}) " # Strip trailing / leading / extra spacing.
 
 case "$action" in
-  save) snapshot_save "$@" ;;
-  load) snapshot_load "$@" ;;
+  save) snapshot_save "$args" ;;
+  load) snapshot_load "$args" ;;
   *)    snapshot_usage ;;
 esac
 

data/scripts/tools

@@ -38,14 +38,16 @@ tools_strings() {
   done
 }
 
-[[ -z "$1" ]] && usage
+args=($*)
+action="${args[0]}"
+args="$(echo ${args[@]:1}) " # Strip trailing / leading / extra spacing.
 
-action="$1"; shift
+[[ -z "$action" ]] && usage
 
 case "$action" in
   identifier)      tools_identifier ;;
-  path-identifier) tools_path_identifier "$@" ;;
-  strings)         tools_strings "$@" ;;
+  path-identifier) tools_path_identifier "$args" ;;
+  strings)         tools_strings "$args" ;;
   *)               usage ;;
 esac
 

data/scripts/update

@@ -201,7 +201,7 @@ fi
 spinner
 if [[ -d gemsets/ ]] ; then
   \mkdir -p "$rvm_gemsets_path"
-  for gemset_file in $(cd gemsets ; find \. -iname '*.gems' | sed 's/^\.\///') ; do
+  for gemset_file in $(builtin cd gemsets ; find \. -iname '*.gems' | sed 's/^\.\///') ; do
     destination="$rvm_gemsets_path/$gemset_file"
     destination_path="$(dirname "$destination")"
     if [[ ! -s "$destination" ]] ; then
@@ -214,7 +214,7 @@ fi
 spinner
 if [[ -d patchsets/ ]] ; then
   \mkdir -p "$rvm_patchsets_path"
-  for patchset_file in $(cd patchsets ; find \. -iname '*' | sed 's/^\.\///') ; do
+  for patchset_file in $(builtin cd patchsets ; find \. -iname '*' | sed 's/^\.\///') ; do
     destination="$rvm_patchsets_path/$patchset_file"
     destination_path="$(dirname "$destination")"
     if [[ ! -s "$destination" ]] ; then
@@ -318,6 +318,7 @@ if [[ "$upgrade_flag" -eq 1 ]] ; then
   printf "\n  * 'rvm notes' tells you OS dependency packages for installing rubies."
   printf "\n  * If you encounter any issues with a ruby your best bet is to 'rvm remove X ; rvm install X' "
   printf "\n  * Gemset separator is '@' and will remain unless any rubies error using it."
+  printf "\n  * If you wish to have the 'pretty colors' again, set 'export rvm_pretty_print=1' in ~/.rvmrc.\n"
   printf "\n$(tput sgr0)\n"
   check_rubyopt_conditions
   printf "\nUpgrade of RVM in $rvm_path/ is complete.\n\n"

data/scripts/upgrade

@@ -4,7 +4,7 @@ unset GREP_OPTIONS
 source "$rvm_scripts_path/base"
 
 usage() {
-  echo "Usage: rvm upgrade prefix [existing-ruby]" >&2
+  echo "Usage: rvm upgrade prefix [specific version]" >&2
   echo "Upgrades the latest installed ruby with a given prefix (e.g. ree) to a new version." >&2
   exit 1
 }
@@ -13,7 +13,7 @@ confirm() {
   printf "$1 (Y/n): "
   local confirmation_response
   read -r confirmation_response
-  [[ -z "$confirmation_response" ]] || echo "$confirmation_response" | \grep -qi '^y'
+  [[ -z "$confirmation_response" ]] || echo $confirmation_response | \grep -qi '^y\|^Y'
 }
 
 die_with_error() {
@@ -30,8 +30,7 @@ expand_existing_ruby() {
   local ruby_name
   while read -r ruby_name; do
     if [[ "$ruby_name" != "$expanded_destination"* ]]; then
-      echo "$ruby_name"
-      return 0
+      echo "$ruby_name" ; return 0
     fi
   done < <("$rvm_scripts_path/list" strings | tr ' ' '\n'  | sort -ur | \grep "^$prefix" | \grep -v '-head$' | head -n1)
   return 1
@@ -48,24 +47,26 @@ upgrade_ruby() {
   if [[ ! -d "$rvm_rubies_path/$expanded_destination" ]]; then
     "$rvm_scripts_path/log" "info" "Installing new ruby $expanded_destination"
     $rvm_bin_path/rvm install "$expanded_destination"
-    result="$?"
-    [[ "$result" -gt 0 ]] && die_with_error "Unable to install ruby $expanded_destination. Please install it manually to continue." "$result"
+    result="$?" ; [[ "$result" -gt 0 ]] && die_with_error "Unable to install ruby $expanded_destination. Please install it manually to continue." "$result"
   fi
 
   "$rvm_scripts_path/log" "info" "Migrating gems from $expanded_source to $expanded_destination"
   "$rvm_scripts_path/migrate" "$expanded_source" "$expanded_destination"
-  result="$?"
-  [[ "$result" -gt 0 ]] && die_with_error "Error migrating gems." "$result"
+  result="$?" ; [[ "$result" -gt 0 ]] && die_with_error "Error migrating gems." "$result"
 
   "$rvm_scripts_path/log" "info" "Upgrade complete!"
 }
 
-[[ -z "$1" ]] && usage
+args=($*)
+destination_ruby="${args[0]}"
+source_ruby="${args[1]:-"$(expand_existing_ruby "$destination_ruby")"}"
+args="$(echo ${args[@]:2}) " # Strip trailing / leading / extra spacing.
+
+[[ -z "$source_ruby" ]] && usage
 
-destination_ruby="$1"; shift
 expanded_destination="$(expand_ruby_name "$destination_ruby")"
-[[ -z "$expanded_destination" ]] && die_with_error "The destination ruby was not a valid ruby string."
 
-source_ruby="${1:-"$(expand_existing_ruby "$destination_ruby")"}"
+[[ -z "$source_ruby" ]] && die_with_error "The Source ruby was not specified, a valid ruby string, or not found."
+[[ -z "$expanded_destination" ]] && die_with_error "The destination ruby was not a valid ruby string, or not found."
 
 upgrade_ruby

data/scripts/utility

@@ -2,24 +2,28 @@
 
 __rvm_setup() {
   # ZSH has 1 based array indexing, bash has 0 based.
-  if [[ -n "$ZSH_VERSION" ]] ; then
+  if [[ -n "${ZSH_VERSION:-""}" ]] ; then
     __shell_array_start=1
     # Set clobber for zsh users, for compatibility with bash's append operator ( >> file ) behavior
     setopt | \grep -qs '^noclobber$'
     rvm_zsh_clobber=$?
     setopt clobber
   else
-    __shell_array_start=0
+    __shell_array_start=0 # bash array indexes are 0 based.
   fi ; export __shell_array_start
 }
 
 __rvm_teardown() {
-  if [[ -n "$ZSH_VERSION" ]] ; then
+  declare rvm_dump_environment_flag=${rvm_dump_environment_flag:-0}
+  declare rvm_clang_flag=${rvm_clang_flag:-0}
+  declare rvm_prior_cc=${rvm_prior_cc:-""}
+
+  if [[ -n "${ZSH_VERSION:-""}" ]] ; then
     if [[ "$rvm_zsh_clobber" -eq 0 ]] ; then
       setopt noclobber
     fi ; unset rvm_zsh_clobber
   else
-    :
+    : # currently we are not doing any option setting for bash.
   fi
   # Ruby strings are scoped to their action.
   # Hence, we ensure we remove them at in
@@ -37,39 +41,53 @@ __rvm_teardown() {
 
   unset rvm_ruby_strings
 
-  [[ -n "$rvm_dump_environment_flag" ]] && __rvm_dump_environment
+  [[ $rvm_dump_environment_flag -eq 1 ]] && __rvm_dump_environment
 
+  return 0
 }
 
+# Dump the current environment to a file.
 __rvm_dump_environment() {
   # Note: This assumes that there is a ','
   local dump_environment_file="${rvm_dump_environment_flag/,*/}"
   local dump_environment_type="${rvm_dump_environment_flag/*,/}"
   if [[ -n "$dump_environment_file" && -n "$dump_environment_type" ]]; then
-    if [[ "$dump_environment_type" == "atheis"* ]]; then
-      \rm -rf "$dump_environment_file" && ln -s /dev/null "$dump_environment_file" >/dev/null 2>&1
+    if [[ "$dump_environment_type" == "atheis"* ]] && [[ -f "$dump_environment_file" ]] ; then
+      # TODO: Query Darcy about the ln.
+      \rm -f "$dump_environment_file" && ln -s /dev/null "$dump_environment_file" >/dev/null 2>&1
     else
       "$rvm_scripts_path/environment-convertor" "$dump_environment_type" "$(__rvm_environment_identifier)" > "$dump_environment_file"
-      [[ "$?" -gt 0 ]] && \rm -rf "$dump_environment_file"
+      if [[ "$?" -gt 0 ]] && [[ -f "$dump_environment_file" ]] ; then
+        \rm -f "$dump_environment_file"
+      fi
     fi
   fi ; unset rvm_dump_environment_flag
+  return 0
 }
 
 # Return a list of directories under a given base path.
 # Derived from rvm_ruby_string.
 __rvm_ruby_string_paths_under() {
-  local patch_parts="$(echo "$rvm_ruby_string" | \tr '-' ' ' | __rvm_strip)"
-  while true; do
-    echo "$1/$patch_parts" | \tr ' ' '/' | sed 's#\/$##'
-    [[ -z "$patch_parts" ]] && break
-    patch_parts="$(echo "$patch_parts" | awk '{$NF=""; print}' | __rvm_strip)"
+  local path="$1"
+  local path_parts="${rvm_ruby_string//-/ }"
+
+  while true ; do
+    echo "$path/$path_parts" | sed -e 's# #/#g' -e 's#/$##g'
+    [[ -z "$path_parts" ]] && break
+    path_parts="$(echo "$path_parts" | awk '{$NF=""; print}' | __rvm_strip)"
   done
+
+  return 0
 }
 
 # Query the rvm key-value database for a specific key
 # Allow overrides from user specifications in $rvm_config_path/user
 __rvm_db() {
-  key=$1 ; variable=$2
+  local value="" key="" variable=""
+
+  key=${1:-""}
+  variable=${2:-""}
+
   if [[ -f "$rvm_config_path/user" ]] ; then
     value="$($rvm_scripts_path/db "$rvm_config_path/user" "$key")"
   fi
@@ -79,13 +97,14 @@ __rvm_db() {
   fi
 
   if [[ -n "$value" ]] ; then
-    if [[ -z $variable ]] ; then
+    if [[ -z "$variable" ]] ; then
       echo $value
     else
       eval "$variable='$value'"
     fi
   fi
-  unset key value variable
+
+  return 0
 }
 
 is_a_function() { type $1 | head -n 1 | \grep -q "function" ; }
@@ -100,15 +119,16 @@ __rvm_quote_args() {
     fi
   done
   echo "$quoted_string" | sed -e 's/^ *//g' -e 's/ *$//g'
+  return 0
 }
 
 __rvm_quote_args_with_shift() {
   local shift_value="$1"; shift
   while [[ "$shift_value" -gt 0 && "$#" -gt 0 ]]; do
-    shift
-    let shift_value=shift_value-1
+    shift ; ((shift_value--))
   done
   __rvm_quote_args "$@"
+  return 0
 }
 
 __rvm_warn_on_rubyopt() {
@@ -121,17 +141,11 @@ __rvm_warn_on_rubyopt() {
 }
 
 __rvm_strings() {
-  unset results
-  for rvm_ruby_string in $(echo $rvm_ruby_args) ; do
-    #__rvm_ruby_string
-    if [[ $? -gt 0 ]] ; then
-      return 1
-    else
-      results="$results $(__rvm_select ; echo $rvm_ruby_string)"
-    fi
+  local strings=""
+  for rvm_ruby_string in $(echo ${rvm_ruby_args:-$rvm_ruby_string}) ; do
+    strings="$strings $(__rvm_select ; echo $rvm_ruby_string)"
   done
-  echo $results
-  unset results
+  echo $strings
   return 0
 }
 
@@ -168,45 +182,71 @@ __rvm_remove_rvm_from_path() {
 
 # Run a specified command and log it.
 __rvm_run() {
-  log_file_name="$1" ; command="$2" ; message="$3"
+  local log_file_name="$1"
+  local command="$2"
+  local message="$3"
+
   if [[ -z "$rvm_ruby_log_path" ]] ; then rvm_ruby_log_path="$rvm_log_path" ; fi
+
   if [[ -n "$message" ]] ; then "$rvm_scripts_path/log" "info" "$message" ; fi
+
   if [[ -n "$rvm_debug_flag" ]] ; then
     "$rvm_scripts_path/log" "debug" "Executing: $command"
   fi
 
   \mkdir -p "$(dirname "$rvm_ruby_log_path/$log_file_name.log")"
+
   \touch "$rvm_ruby_log_path/$log_file_name.log" "$rvm_ruby_log_path/$log_file_name.error.log" # for zsh :(
-  echo "[$(date +'%Y-%m-%d %H:%M:%S')] $command" | tee "$rvm_ruby_log_path/$log_file_name.log" >> "$rvm_ruby_log_path/$log_file_name.error.log"
+
+  echo "[$(date +'%Y-%m-%d %H:%M:%S')] $command" | \tee "$rvm_ruby_log_path/$log_file_name.log" >> "$rvm_ruby_log_path/$log_file_name.error.log"
+
   if [[ -z "$rvm_niceness" ]] || [[ "0" = "$rvm_niceness" ]] ; then
     eval "$command" >> "$rvm_ruby_log_path/$log_file_name.log" 2>> "$rvm_ruby_log_path/$log_file_name.error.log"
   else
     eval "nice -n $rvm_niceness $command" >> $rvm_ruby_log_path/$log_file_name.log 2>> $rvm_ruby_log_path/$log_file_name.error.log
+  fi ; local result=$?
+
+  if [[ $result -gt 0 ]] ; then
+    "$rvm_scripts_path/log" "error" "Error running '$command', please check $rvm_ruby_log_path/$log_file_name*.log" ; __rvm_pushpop
   fi
-  if [[ $? -gt 0 ]] ; then "$rvm_scripts_path/log" "error" "Error running '$command', please check $rvm_ruby_log_path/$log_file_name*.log" ; __rvm_pushpop ; return 1 ; fi
-  unset log_file command
+
+  return $result
 }
 
 # Runs a command in a given env.
 __rvm_run_with_env() {
-  log_file_name="$1" ; env_name="$2" ; command="$3" ; message="$4"
+  local log_file_name="${1:-""}"
+  local env_name="${2:-""}"
+  local command="${3:-""}"
+  local message="${4:-""}"
+
   if [[ -z "$env_name" ]]; then env_name="$(__rvm_environment_identifier)"; fi
+
   if [[ -z "$rvm_ruby_log_path" ]] ; then rvm_ruby_log_path="$rvm_log_path" ; fi
+
   if [[ -n "$message" ]] ; then "$rvm_scripts_path/log" "info" "$message" ; fi
+
   if [[ -n "$rvm_debug_flag" ]] ; then
     "$rvm_scripts_path/log" "debug" "Executing: $command in environment "$env_name""
   fi
 
   \mkdir -p "$(dirname "$rvm_ruby_log_path/$log_file_name.log")"
+
   \touch "$rvm_ruby_log_path/$log_file_name.log" "$rvm_ruby_log_path/$log_file_name.error.log" # for zsh :(
+
   echo "[$(date +'%Y-%m-%d %H:%M:%S')] $command # under $env_name" | tee "$rvm_ruby_log_path/$log_file_name.log" >> "$rvm_ruby_log_path/$log_file_name.error.log"
-  if [[ -z "$rvm_niceness" ]] || [[ "0" = "$rvm_niceness" ]] ; then
+
+  if [[ -z "$rvm_niceness" || "0" = "$rvm_niceness" ]] ; then
     eval "__rvm_with_env '$env_name' '$command'" >> "$rvm_ruby_log_path/$log_file_name.log" 2>> "$rvm_ruby_log_path/$log_file_name.error.log"
   else
     eval "nice -n $rvm_niceness __rvm_with_env '$env_name' '$command'" >> $rvm_ruby_log_path/$log_file_name.log 2>> $rvm_ruby_log_path/$log_file_name.error.log
+  fi ; result=$?
+
+  if [[ $result -gt 0 ]] ; then
+    "$rvm_scripts_path/log" "error" "Error running '$command' under $env_name, please check $rvm_ruby_log_path/$log_file_name*.log" ; __rvm_pushpop
   fi
-  if [[ $? -gt 0 ]] ; then "$rvm_scripts_path/log" "error" "Error running '$command' under $env_name, please check $rvm_ruby_log_path/$log_file_name*.log" ; __rvm_pushpop ; return 1 ; fi
-  unset log_file command env_name
+
+  return $result
 }
 
 # Unset both rvm variables as well as ruby-specific variables
@@ -214,7 +254,7 @@ __rvm_run_with_env() {
 __rvm_cleanse_variables() {
   __rvm_unset_ruby_variables
 
-  if [[ "$rvm_sticky_flag" = "1" ]] ; then export rvm_gemset_name ; else unset rvm_gemset_name  ; fi
+  if [[ ${rvm_sticky_flag:-0} -eq 1 ]] ; then export rvm_gemset_name ; else unset rvm_gemset_name  ; fi
 
   unset rvm_action rvm_irbrc_file rvm_command rvm_error_message rvm_url rvm_force_flag rvm_all_flag rvm_reconfigure_flag rvm_make_flags rvm_bin_flag rvm_import_flag rvm_export_flag rvm_self_flag rvm_gem_flag rvm_rubygems_flag rvm_debug_flag rvm_delete_flag rvm_summary_flag rvm_test_flag _rvm_spec_flag rvm_json_flag rvm_yaml_flag rvm_shebang_flag rvm_env_flag rvm_tail_flag rvm_use_flag rvm_dir_flag rvm_list_flag rvm_empty_flag rvm_file_name rvm_benchmark_flag rvm_clear_flag rvm_name_flag rvm_verbose_flag rvm_user_flag rvm_system_flag rvm_ruby_configure_flags rvm_uninstall_flag rvm_install_flag rvm_llvm_flag rvm_ruby_bits rvm_sticky_flag rvm_rvmrc_flag rvm_gems_flag rvm_only_path_flag rvm_docs_flag rvm_ruby_aliases rvm_patch_names rvm_clang_flag rvm_install_arguments rvm_dump_environment_flag rvm_ruby_alias
 }
@@ -226,27 +266,23 @@ __rvm_unset_ruby_variables() {
 
 # Usage: __rvm_with_env 'env-name' 'command'
 __rvm_with_env() {
-  [[ -n "$rvm_trace_flag" ]] && rvm_env_args="--trace"
-  rvm_env_command="$(echo "$2" | sed "s/rvm /rvm $rvm_env_args /")"
-  # Subshells!
-  (
-    source "$rvm_scripts_path/rvm"
-    rvm "$rvm_env_args" use $1 && eval "$rvm_env_command"
-  )
-  unset rvm_env_args rvm_env_command
+  local environment_id="$1" command="$2"
+  ( rvm use "$environment_id" ; eval "$command" )
 }
 
 # Returns the first 1.8.7-compatible (partly) ruby for use
 # with things like rbx etc which require a ruby be installed.
 __rvm_18_compat_ruby() {
-  rubies=""
+  local rubies=""
   for ruby_name in $(\ls "$rvm_rubies_path"); do
     if [[ ! -L "$rvm_rubies_path/$ruby_name" ]] && [[ "$ruby_name" =~ 1.8. || "$ruby_name" =~ rbx- || "$ruby_name" =~ ree- ]] ; then
       rubies="$rubies $ruby_name"
     fi
   done; unset ruby_name
+
   echo "$rubies" | sed 's/^ //' | \tr ' ' '\n' | sort | tail -n1
-  unset rubies
+
+  return 0
 }
 
 __rvm_ensure_has_18_compat_ruby() {
@@ -258,23 +294,32 @@ __rvm_ensure_has_18_compat_ruby() {
       "$rvm_scripts_path/log" "fail" "Please install it manually (or a compatible alternative) to proceed."
       compat_result=1
     fi ; unset original_ruby
+    # TODO: Why are we unsetting original_ruby here
     return $compat_result
   fi
+
+  return 0
 }
 
 __rvm_inherit_trace_flag() {
   if [[ -n "$rvm_trace_flag" ]]; then
     set -x ; export rvm_trace_flag
   fi
+  return 0
 }
 
 # Cleans up temp folders for a given prefix,
 # typically the current process id.
 __rvm_cleanup_temp_for() {
-  [[ -z "$1" ]] && return 1
+  local prefix="$1"
+
+  [[ -z "$prefix" ]] && return 1
+
   if [[ -d "$rvm_tmp_path/" ]]; then
-    \rm -rf "$rvm_tmp_path/$1"* >/dev/null 2>&1
-  fi ; exit
+    \rm -rf "$rvm_tmp_path/$prefix"* >/dev/null 2>&1
+  fi
+
+  exit
 }
 
 __rvm_cleanup_temp_on_exit() {
@@ -283,7 +328,7 @@ __rvm_cleanup_temp_on_exit() {
 
 __rvm_set_rvmrc() {
   if [[ "$HOME" != "$PWD" ]] ; then
-    if [[ "$rvm_verbose_flag" -eq 1 ]] ; then flags="use " ; fi
+    if [[ ${rvm_verbose_flag:-0} -eq 1 ]] ; then flags="use " ; fi
 
     if [[ -s .rvmrc ]] ; then
       mv .rvmrc .rvmrc.$(date +%m.%d.%Y-%H:%M:%S)
@@ -291,6 +336,7 @@ __rvm_set_rvmrc() {
     fi
 
     local identifier=$(__rvm_environment_identifier)
+
     printf "if [[ -n \"\$rvm_environments_path\" && -s \"\$rvm_environments_path/$identifier\" ]] ; then\n  \\. \"\$rvm_environments_path/$identifier\"" > .rvmrc
     printf "\nelse\n  rvm --create $flags \"$identifier\"\nfi" >> .rvmrc
 
@@ -300,7 +346,9 @@ __rvm_set_rvmrc() {
   fi
 }
 __rvm_load_rvmrc() {
-  [[ -z "$rvm_ignore_rvmrc" ]] && return
+  rvm_ignore_rvmrc=${rvm_ignore_rvmrc:-0}
+  [[ $rvm_ignore_rvmrc -eq 1 ]] && return 0
+
   for rvmrc in /etc/rvmrc $HOME/.rvmrc ; do
     if [[ -f "$rvmrc" ]] ; then
       if \grep -q '^\s*rvm .*$' $rvmrc ; then
@@ -311,6 +359,8 @@ __rvm_load_rvmrc() {
       fi
     fi
   done
+
+  return 0
 }
 
 # Wrap the specified ruby code file in a Benchmark.bmbm block and execute it.
@@ -325,14 +375,16 @@ __rvm_benchmark() {
   rvm_action="ruby"
   if [[ -n "$rvm_debug_flag" ]] ; then printf "\n$rvm_tmp_path/$$.rb:\n$(cat $rvm_tmp_path/$$.rb)" ; fi
   # Override ruby string stuff, pass through.
-  old_rvm_ruby_string=$rvm_ruby_string
+  local old_rvm_ruby_string=$rvm_ruby_string
+  # TODO: We can likely do this in a subshell in order to preserve the original environment?
   unset rvm_ruby_string
   export rvm_ruby_strings
   "$rvm_scripts_path/set" "$rvm_action" $rvm_ruby_args
   result=$?
   # Restore the state pre-sets.
   [[ -n "$old_rvm_ruby_string" ]] && rvm_ruby_string=$old_rvm_ruby_string
-  unset old_rvm_ruby_string
+
+  return $result
 }
 
 # Loop over the currently installed rubies and refresh their binscripts.
@@ -344,12 +396,14 @@ __rvm_bin_scripts() {
       __rvm_bin_script
     fi
   done
+  return 0
 }
 
 # Write the bin/ wrapper script for currently selected ruby.
 # TODO: Adjust binscript to be able to handle all rubies not just the standard interpreteres.
 __rvm_bin_script() {
   "$rvm_scripts_path/wrapper" "$rvm_ruby_string"
+  return $?
 }
 
 # Add bin path if not present
@@ -358,18 +412,20 @@ __rvm_conditionally_add_bin_path() {
     PATH="${rvm_bin_path}:$PATH"
     builtin hash -r
   fi
+  return 0
 }
 
 # Reset any rvm gathered information about the system and its state.
 # rvm will refresh the stored information the next time it is called after reset.
 __rvm_reset() {
-  __rvm_remove_rvm_from_path
-  __rvm_conditionally_add_bin_path
-  export PATH
+  __rvm_remove_rvm_from_path ; __rvm_conditionally_add_bin_path ; export PATH
+
   builtin hash -r
 
-  for flag in default passenger editor ; do \rm -f "$rvm_bin_path"/${flag}_* ; done
-  unset flag
+  local flag=""
+  for flag in default passenger editor ; do
+    \rm -f "$rvm_bin_path"/${flag}_*
+  done
 
   for file in system default ; do
     [[ -f "${rvm_path}/${file}" ]] && \rm -f "$rvm_path/${file}"
@@ -386,13 +442,17 @@ __rvm_reset() {
   done ; unset system_config variable
 
   \rm -f $rvm_bin_path/ruby $rvm_bin_path/gem $rvm_bin_path/rake $rvm_bin_path/irb $rvm_bin_path/default*
+
+  return 0
 }
 
 # Implode removes the entire rvm installation under $rvm_path.
 __rvm_implode() {
   while : ; do
     "$rvm_scripts_path/log" "warn" "Are you SURE you wish for rvm to implode? This will remove $rvm_path ? (type 'yes' or 'no')"
+
     read response
+
     if [[ "yes" = "$response" ]] ; then
       if [[ "/" = "$rvm_path" ]] ; then
         "$rvm_scripts_path/log" "error" "remove '/' ?!... Ni!"
@@ -411,16 +471,21 @@ __rvm_implode() {
       break
     fi
   done
+
+  return 0
 }
 
 # Output the current ruby's rvm source path.
 __rvm_source_dir() {
   if [[ -z "$rvm_ruby_selected_flag" ]] ; then __rvm_select ; fi
+
   if [[ -z "$rvm_ruby_src_path" ]] ; then
     "$rvm_scripts_path/log" "fail" "No source directory exists for the default implementation."
   else
     echo "$rvm_ruby_src_path"
   fi
+
+  return 0
 }
 
 # Initialize rvm, ensuring that the path and directories are as expected.
@@ -428,36 +493,43 @@ __rvm_initialize() {
   rvm_ruby_load_path="."
   rvm_ruby_require=""
 
-  __rvm_clean_path
-
-  __rvm_conditionally_add_bin_path
-  export PATH
+  __rvm_clean_path ; __rvm_conditionally_add_bin_path ; export PATH
 
   \mkdir -p "$rvm_src_path" "$rvm_bin_path" "$rvm_archives_path" "$rvm_gems_path" "$rvm_tmp_path" "$rvm_repo_path"
+
+  return 0
 }
 
 # Update rubygems or binscripts based on CLI selection.
 __rvm_update() {
   __rvm_pushpop $rvm_path
-  if [[ "$rvm_head_flag" == "1" ]] || [[ -n "$rvm_self_flag" ]] || [[ "update" = "$rvm_action" ]] || [[ -n "$rvm_update_flag" ]] ; then
+
+  if [[ ${rvm_head_flag:-0} -eq 1 || ${rvm_self_flag:-0} -eq 1 || "update" = "${rvm_action:-""}" || ${rvm_update_flag:-0} -eq 1 ]] ; then
     __rvm_version
     __rvm_update_rvm
   fi
-  [[ -n "$rvm_bin_flag" ]] && __rvm_bin_scripts
+
+  [[ ${rvm_bin_flag:-0} -eq 1 ]] && __rvm_bin_scripts
+
   # Update to the latest rubygems.
-  [[ -n "$rvm_rubygems_flag" ]] && "$rvm_scripts_path/rubygems" current
+  [[ ${rvm_rubygems_flag:-0} -eq 1 ]] && "$rvm_scripts_path/rubygems" current
 
   unset rvm_update_flag rvm_action rvm_self_flag rvm_ruby_revision rvm_bin_flag rvm_rubygems_flag
+
   __rvm_pushpop
+
+  return 0
 }
 
 # Update rvm using rubygems
 # If --head was specified, update from git repository master branch.
 __rvm_update_rvm() {
+
   \mkdir -p "$rvm_src_path"
+
   __rvm_pushpop "$rvm_src_path"
 
-  if [[ "$rvm_head_flag" == "1" ]] ; then
+  if [[ ${rvm_head_flag:-0} -eq 1 ]] ; then
     if [[ -d "$rvm_src_path/rvm/.git" ]] ; then
       builtin cd "$rvm_src_path/rvm/" && git pull origin master && ./scripts/install
     else
@@ -474,34 +546,50 @@ __rvm_update_rvm() {
   fi
 
   __rvm_pushpop
+
   rvm_hook="after_update" ; source "$rvm_scripts_path/hook"
+
+  return 0
 }
 
 __rvm_reboot() {
   "$rvm_scripts_path/log" "warn" "Do you wish to reboot rvm? ('yes', or 'no')"
+
+  local response="no"
+
   read response
+
   if [[ "yes" = "$response" ]] ; then
     builtin cd $rvm_path
+
     __rvm_reset
+
     mv "$rvm_path/archives" "$HOME/.archives"
+
     if [[ "/" = "$rvm_path" ]] ; then
       "$rvm_scripts_path/log" "error" "remove '/' ?!... NO!"
     else
       if [[ -d "$rvm_path" ]] ; then \rm -rf "$rvm_path/" ; fi
     fi
+
     gem install rvm $rvm_gem_options
+
     __rvm_update_rvm
-    source $rvm_path/scripts/rvm
+
+    source "$rvm_path/scripts/rvm"
   else
     "$rvm_scripts_path/log" "info" "Carry on then..."
-  fi ; unset response
+  fi
+
+  return 0
 }
 
 # Create the irbrc for the currently selected ruby installation.
 __rvm_irbrc() {
-  if [[ -d "$rvm_ruby_home" ]] && [[ ! -s "$rvm_ruby_irbrc" ]] ; then
+  if [[ -d "$rvm_ruby_home" && ! -s "$rvm_ruby_irbrc" ]] ; then
     \cp "$rvm_scripts_path/irbrc" "$rvm_ruby_irbrc"
   fi
+  return $?
 }
 
 # Push or Pop a directory based on zero or one directory argument provided.
@@ -511,6 +599,8 @@ __rvm_pushpop() {
   else
     pushd "$1" > /dev/null 2>&1
   fi
+
+  return $?
 }
 
 # Save or restore the rvm's state. This is a toggle action.
@@ -530,20 +620,33 @@ __rvm_state() {
     __rvm_use
     unset rvm_state
   fi
+
+  return 0
 }
 
 # Output an inspection of selected 'binary' scripts, based on CLI selection.
 __rvm_inspect() {
+  rvm_shebang_flag=${rvm_shebang_flag:-0}
+  rvm_env_flag=${rvm_env_flag:-0}
+  rvm_path_flag=${rvm_path_flag:-0}
+  rvm_head_flag=${rvm_head_flag:-0}
+  rvm_tail_flag=${rvm_tail_flag:-0}
+  rvm_all_flag=${rvm_all_flag:-0}
+
   for binary in $rvm_ruby_args ; do
     actual_file="$(command -v $binary)"
+
     "$rvm_scripts_path/log" "info" "$actual_file:"
-    if [[ -n "$rvm_shebang_flag" ]] ; then head -n 1    < "$actual_file" ; fi
-    if [[ -n "$rvm_env_flag" ]]     ; then awk '/ENV/'  < "$actual_file" ; fi
-    if [[ -n "$rvm_path_flag" ]]    ; then awk '/PATH/' < "$actual_file" ; fi
-    if [[ -n "$rvm_head_flag" ]]    ; then head -n 5    < "$actual_file" ; fi
-    if [[ -n "$rvm_tail_flag" ]]    ; then tail -n 5    < "$actual_file" ; fi
-    if [[ -n "$rvm_all_flag" ]]     ; then cat $actual_file              ; fi
+
+    if [[ $rvm_shebang_flag -eq 1 ]] ; then head -n 1    < "$actual_file" ; fi
+    if [[ $rvm_env_flag -eq 1 ]]     ; then awk '/ENV/'  < "$actual_file" ; fi
+    if [[ $rvm_path_flag -eq 1 ]]    ; then awk '/PATH/' < "$actual_file" ; fi
+    if [[ $rvm_head_flag -eq 1 ]]    ; then head -n 5    < "$actual_file" ; fi
+    if [[ $rvm_tail_flag -eq 1 ]]    ; then tail -n 5    < "$actual_file" ; fi
+    if [[ $rvm_all_flag -eq 1 ]]     ; then cat $actual_file              ; fi
   done
+
+  return 0
 }
 
 # Attempt to override the Darwin build settings for rubies
@@ -577,6 +680,8 @@ __rvm_make_flags() {
       # CXXFLAGS="-mmacosx-version-min="$(sw_vers -productVersion | awk -F'.' '{print $1"."$2}')" -isysroot /Developer/SDKs/$rvm_sdk " ; export CXXFLAGS
     fi
   fi
+
+  return 0
 }
 
 __rvm_mono_env() {
@@ -587,23 +692,35 @@ __rvm_mono_env() {
   export PKG_CONFIG_PATH="$rvm_usr_path/lib/pkgconfig:$PKG_CONFIG_PATH"
   PATH="$rvm_usr_path/bin:$PATH"
   builtin hash -r
+
+  return 0
 }
 
 __rvm_become() {
-  [[ -n "$1" ]] && rvm_ruby_string="$1"
+  local string="$1"
+
+  [[ -n "$string" ]] && rvm_ruby_string="$string"
+
   { __rvm_ruby_string && __rvm_select && __rvm_use; } > /dev/null 2>&1
+
+  return 0
 }
 
 __rvm_ensure_has_environment_files() {
   local environment_identifier="$(__rvm_environment_identifier)"
+
   local file_name="${rvm_environments_path}/$environment_identifier"
 
   if [[ ! -s "$file_name" ]] ; then
     \mkdir -p "${rvm_environments_path}"
+
     echo "export PATH=\"${rvm_ruby_gem_home}/bin:${rvm_ruby_global_gems_path}/bin:${rvm_ruby_home}/bin:${rvm_bin_path}:\$PATH\"" > "$file_name"
+
     for variable in RUBY_VERSION GEM_HOME GEM_PATH BUNDLE_PATH MY_RUBY_HOME IRBRC rvm_ruby_string rvm_gemset_name MAGLEV_HOME ; do
       eval "export $variable"
+
       eval "value=\$${variable}"
+
       if [[ -n "$value" ]] ; then
         printf "${variable}='$value'\nexport ${variable}\n" >> "$file_name"
       else
@@ -612,28 +729,37 @@ __rvm_ensure_has_environment_files() {
     done ; unset variable value
   fi ; unset file_name
 
+  local directory_name=""
+  local wrapper_identifier=""
   # Next, ensure we have default wrapper files. Also, prevent it from recursing.
-  if [[ -z "$rvm_creating_default_wrappers" ]]; then
+  if [[ ${rvm_creating_default_wrappers:-0} -eq 1 ]]; then
     # We need to generate wrappers for both the default gemset and the global gemset.
     for wrapper_identifier in "$environment_identifier" "${environment_identifier}@global" ; do
-    rvm_creating_default_wrappers=1
-    directory_name="$rvm_wrappers_path/$wrapper_identifier"
-    if [[ ! -L "$directory_name" && ! -d "$directory_name" ]]; then
-      \mkdir -p "$directory_name"
-      "$rvm_scripts_path/wrapper" "$wrapper_identifier" &> /dev/null
-    fi
-    unset rvm_creating_default_wrappers directory_name
-    done; unset wrapper_identifier
+
+      rvm_creating_default_wrappers=1
+
+      directory_name="$rvm_wrappers_path/$wrapper_identifier"
+
+      if [[ ! -L "$directory_name" && ! -d "$directory_name" ]]; then
+        \mkdir -p "$directory_name"
+
+        "$rvm_scripts_path/wrapper" "$wrapper_identifier" &> /dev/null
+      fi
+      rvm_creating_default_wrappers=0
+    done
   fi
+  return 0
 }
 
 # Strip whitespace and normalize it all.
 __rvm_strip() {
   sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//' -e 's/[[:space:]]\{1,\}/ /g'
+  return $?
 }
 
 __rvm_using_gemset_globalcache() {
   "$rvm_scripts_path/db" "$rvm_config_path/user" "use_gemset_globalcache" | \grep -q '^true$'
+  return $?
 }
 
 __rvm_current_gemcache_dir() {
@@ -642,62 +768,85 @@ __rvm_current_gemcache_dir() {
   else
     echo "${rvm_ruby_gem_home:-"$GEM_HOME"}/cache"
   fi
+  return 0
 }
 
 __rvm_Answer_to_the_Ultimate_Question_of_Life_the_Universe_and_Everything() {
   for index in {1..750} ; do sleep 0.25 ; echo -n '.' ; done ; printf "%d" 0x2A ; echo
+  return 0
 }
 
 __rvm_ultimate_question() {
-  printf "\nI do not know the Ultimate Question, "
-  printf "\nhowever I can help you build a more "
-  printf "\npowerful Ruby which can compute the "
-  printf "\nUltimate Question.\n"
+  printf "
+  I do not know the Ultimate Question,
+  however I can help you build a more
+  powerful Ruby which can compute the
+  Ultimate Question.
+  "
+  return 0
 }
 
 __rvm_load_env_file() {
-  if [[ -f "$rvm_environments_path/$1" ]]; then
+  local string="$1"
+  if [[ -f "$rvm_environments_path/$string" ]]; then
     # Restore the path to it's state minus rvm
     __rvm_remove_rvm_from_path
-    \. "$rvm_environments_path/$1"
+
+    # source the environment file
+    \. "$rvm_environments_path/$string"
+
+    # clear the PATH cache
     builtin hash -r
+  elif [[ -n "$string" ]] ; then
+    rvm "$string"
   else
-    rvm use "$1" >/dev/null 2>&1
+    : # TODO: This should have some error handling in the context.
   fi
+  return 0
 }
 
 __rvm_md5_for() {
   if command -v md5 > /dev/null; then
     echo "$1" | md5
-  else
+  elif command -v md5sum > /dev/null ; then
     echo "$1" | md5sum | awk '{print $1}'
+  else
+    "$rvm_path/scripts/log" "error" "Neither md5 nor md5sum were found in the PATH"
+    return 1
   fi
+
+  return 0
 }
 
 __rvm_rvmrc_key() {
   __rvm_md5_for "$1"
+  return $?
 }
 
 __rvm_reset_rvmrc_trust() {
   touch "$rvm_config_path/rvmrcs"
   "$rvm_scripts_path/db" "$rvm_config_path/rvmrcs" "$(__rvm_rvmrc_key "$1")" "delete" >/dev/null 2>&1
+  return $?
 }
 
 __rvm_trust_rvmrc() {
   touch "$rvm_config_path/rvmrcs"
   __rvm_reset_rvmrc_trust "$1"
   "$rvm_scripts_path/db" "$rvm_config_path/rvmrcs" "$(__rvm_rvmrc_key "$1")" "1" >/dev/null 2>&1
+  return $?
 }
 
 __rvm_untrust_rvmrc() {
   touch "$rvm_config_path/rvmrcs"
   __rvm_reset_rvmrc_trust "$1"
   "$rvm_scripts_path/db" "$rvm_config_path/rvmrcs" "$(__rvm_rvmrc_key "$1")" "0" >/dev/null 2>&1
+  return $?
 }
 
 __rvm_rvmrc_stored_trust() {
   touch "$rvm_config_path/rvmrcs"
   "$rvm_scripts_path/db" "$rvm_config_path/rvmrcs" "$(__rvm_rvmrc_key "$1")"
+  return $?
 }
 
 __rvm_rvmrc_tools() {
@@ -728,13 +877,14 @@ __rvm_rvmrc_tools() {
       fi
     ;;
     load)
-      rvm_rvmrc_cwd="" rvm_trust_rvmrcs=1 __rvm_project_rvmrc "$(dirname "$rvmrc_path")"
+      rvm_rvmrc_cwd="" rvm_trust_rvmrcs=1  __rvm_project_rvmrc "$(dirname "$rvmrc_path")"
     ;;
     *)
       echo "Usage: rvm rvmrc {trust,untrust,trusted,load,reset}"
       return 1
     ;;
   esac
+  return $?
 }
 
 __rvm_check_rvmrc_trustworthiness() {
@@ -746,13 +896,15 @@ __rvm_check_rvmrc_trustworthiness() {
   else
     [[ "$value" = "1" ]]
   fi
+  return $?
 }
 
 __rvm_ask_to_trust() {
   [[ -n "$rvm_promptless" ]] && return 2
   printf "
   ============================================================
-  RVM has encountered a new untrusted .rvmrc file containing:
+  RVM has encountered a not yet trusted .rvmrc file in the
+  current working directory which contains the following code:
   ============================================================
 
 $(cat $1)
@@ -789,17 +941,24 @@ $(cat $1)
 # Checks the rvmrc for the given directory. Note that if
 # argument is passed, it will be used instead of pwd.
 __rvm_project_rvmrc() {
+  declare -i rvm_project_rvmrc_default=${rvm_project_rvmrc_default:-0}
+  declare rvm_rvmrc_cwd="${rvm_rvmrc_cwd:-""}"
+  declare rvm_previous_environment="${rvm_previous_environment:-""}"
+
   local cwd
+
   # Get the first argument or the pwd.
   cwd="${1:-"$PWD"}"
   while : ; do
     if [[ -z "$cwd" || "$HOME" = "$cwd" || "/" = "$cwd" ]] ; then
       if [[ -n "$rvm_rvmrc_cwd" ]] ; then
-        if [[ "$rvm_project_rvmrc_default" = "1" ]]; then
+        if [[ $rvm_project_rvmrc_default -eq 1 ]]; then
           __rvm_load_env_file "default"
         elif [[ -n "$rvm_previous_environment" ]] ; then
           __rvm_load_env_file "$rvm_previous_environment"
-        fi ; unset rvm_rvmrc_cwd rvm_previous_environment
+        fi
+        rvm_rvmrc_cwd=""
+        rvm_previous_environment=""
       fi
       break
     else
@@ -822,6 +981,7 @@ __rvm_project_rvmrc() {
       fi
     fi
   done
+  return $?
 }
 
 __rvm_record_install() {
@@ -834,17 +994,18 @@ __rvm_record_install() {
   \grep -v "^$recorded_ruby_name " < "$rvm_install_record_file" > "$rvm_install_record_file.tmp"
   echo "$rvm_install_command" >> "$rvm_install_record_file.tmp"
   \rm -f "$rvm_install_record_file"
-  mv "$rvm_install_record_file.tmp" "$rvm_install_record_file"
+  \mv "$rvm_install_record_file.tmp" "$rvm_install_record_file"
 }
 
 __rvm_remove_install_record() {
   local recorded_ruby_name="$($rvm_scripts_path/tools strings "$1")"
   local rvm_install_record_file="$rvm_config_path/installs"
   if [[ -s "$rvm_install_record_file" ]]; then
-    mv "$rvm_install_record_file" "$rvm_install_record_file.tmp"
+    \mv "$rvm_install_record_file" "$rvm_install_record_file.tmp"
     \grep -v "^$recorded_ruby_name " < "$rvm_install_record_file.tmp" > "$rvm_install_record_file"
     \rm -f "$rvm_install_record_file.tmp"
   fi
+  return 0
 }
 
 __rvm_recorded_install_command() {
@@ -856,35 +1017,39 @@ __rvm_recorded_install_command() {
   else
     return 1
   fi
+  return $?
 }
 
 __rvm_environment_identifier() {
-  ruby_string="$(command -v ruby)"
-
-  if [ -n "$ruby_string" ] && echo "$ruby_string" | \grep -q -F "$rvm_rubies_path"; then
-    echo "$GEM_HOME" | xargs basename
-  else
-    echo "system"
-  fi ; unset ruby_string
+  local path
+  local string
+  path="$(command -v ruby)"
+  string="${path//*rubies\//}"
+  string="${string//\/*/}"
+  echo "${string:-system}"
+  return $?
 }
 
 __rvm_expand_ruby_string() {
-  if [[ -z "$1" || "$1" = "all" ]]; then
+  local string="$1"
+  if [[ -z "$string" || "$string" = "all" ]]; then
     "$rvm_scripts_path/list" strings | tr ' ' "\n" | __rvm_strip
-  elif [[ "$1" = "all-gemsets" ]]; then
+  elif [[ "$string" = "all-gemsets" ]]; then
     "$rvm_scripts_path/list" gemsets strings | __rvm_strip
-  elif [[ "$1" = "default-with-rvmrc" || "$1" = "rvmrc" ]]; then
+  elif [[ "$string" = "default-with-rvmrc" || "$string" = "rvmrc" ]]; then
     "$rvm_scripts_path/tools" path-identifier "$PWD"
-  elif [[ "$1" == "all-rubies" || "$1" = "rubies" ]]; then
+  elif [[ "$string" == "all-rubies" || "$string" = "rubies" ]]; then
     "$rvm_scripts_path/list" rubies strings | __rvm_strip
-  elif [[ "$1" == "current-ruby" || "$1" = "gemsets" ]]; then
-    local current_ruby="$(__rvm_environment_identifier | awk -F"$rvm_gemset_separator" '{print $1}')"
+  elif [[ "$string" == "current-ruby" || "$string" = "gemsets" ]]; then
+    local current_ruby="$(__rvm_environment_identifier | awk -F"$rvm_gemset_separator" '{print $string}')"
     rvm_silence_logging=1 "$rvm_scripts_path/gemsets" list | sed "s/^/$current_ruby$rvm_gemset_separator/"  | __rvm_strip
-  elif [[ "$1" = "current" ]]; then
+  elif [[ "$string" = "current" ]]; then
     __rvm_environment_identifier
-  elif [[ "$1" = "aliases" ]]; then
-    awk -F= '{print $1}' < "$rvm_config_path/alias" | __rvm_strip
+  elif [[ "$string" = "aliases" ]]; then
+    awk -F= '{print $string}' < "$rvm_config_path/alias" | __rvm_strip
   else
-    echo "$1" | tr "," "\n" | __rvm_strip
+    echo "$string" | tr "," "\n" | __rvm_strip
   fi
+  return $?
 }
+