utility

#!/usr/bin/env bash

__rvm_setup() {
  # ZSH has 1 based array indexing, bash has 0 based.
  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
  fi ; export __shell_array_start
}

__rvm_teardown() {
  if [[ -n "$ZSH_VERSION" ]] ; then
    if [[ "$rvm_zsh_clobber" -eq 0 ]] ; then
      setopt noclobber
    fi ; unset rvm_zsh_clobber
  else
    :
  fi
  # Ruby strings are scoped to their action.
  # Hence, we ensure we remove them at in
  # the cleanup phase.

  # Clean up after CC switch
  if [[ -n "$rvm_clang_flag" ]] ; then
    if [[ -n "$rvm_prior_cc" ]] ; then
      export CC="$rvm_prior_cc"
    else
      unset CC
    fi
    unset rvm_prior_cc
  fi

  unset rvm_ruby_strings

  [[ -n "$rvm_dump_environment_flag" ]] && __rvm_dump_environment

}

__rvm_dump_environment() {
  local dump_environment_file="$(echo "$rvm_dump_environment_flag" | awk -F, '{print $1}')"
  local dump_environment_type="$(echo "$rvm_dump_environment_flag" | awk -F, '{print $2}')"
  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
    else
      $rvm_scripts_path/environment-convertor "$dump_environment_type" "$(__rvm_environment_identifier)" > "$dump_environment_file"
      [[ "$?" -gt 0 ]] && \rm -rf "$dump_environment_file"
    fi
  fi
  unset rvm_dump_environment_flag
}

# 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)"
  done
}

# 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
  if [[ -f "$rvm_config_path/user" ]] ; then
    value="$($rvm_scripts_path/db "$rvm_config_path/user" "$key")"
  fi

  if [[ -z "$value" ]] ; then
    value="$($rvm_scripts_path/db "$rvm_config_path/db" "$key")"
  fi

  if [[ -n "$value" ]] ; then
    if [[ -z $variable ]] ; then
      echo $value
    else
      eval "$variable='$value'"
    fi
  fi
  unset key value variable
}

is_a_function() { type $1 | head -n 1 | \grep -q "function" ; }

__rvm_quote_args() {
  local quoted_string=""
  for quoted_argument in "$@"; do
    if printf "%s" "$quoted_argument" | \grep -vq "^[[:alnum:]]$"; then
      quoted_string="$quoted_string '$(printf "%s" "$quoted_argument" | sed "s/'/\'\\\'\'/g")'"
    else
      quoted_string="$quoted_string $quoted_argument"
    fi
  done
  echo "$quoted_string" | sed -e 's/^ *//g' -e 's/ *$//g'
}

__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
  done
  __rvm_quote_args "$@"
}

__rvm_warn_on_rubyopt() {
  if [[ -n "$RUBYOPT" ]]; then
    $rvm_scripts_path/log "warn" "Please note: You have the RUBYOPT environment variable set and this may interfere with normal rvm operations. We sugges unsetting it."
    return 1
  else
    return 0
  fi
}

__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
  done
  echo $results
  unset results
  return 0
}

# Push an item onto a given array.
__rvm_push() {
  array=$1 ; shift ; item=$2
  # TODO: allow loop over more arguments.
  eval "index=\$((\${#${array}[*]} + $__shell_array_start))"
  eval "${array}[${index}]=${item}"
  unset array item
}

__rvm_set_path_variable() {
  if [[ -d "$1" ]] ; then
    eval "${path_variable}=${1}"
  else
    $rvm_scripts_path/log "error" "'$1' is not a valid path."
  fi ; unset path_variable
}

# Clean all *duplicate* items out of the path. (keep first occurrence of each)
__rvm_clean_path() {
  PATH=$(echo $PATH | \tr -s ':' '\n' | awk '!($0 in a){a[$0];print}' | \tr -s '\n' ':' | sed 's#:$##')
  export PATH
  builtin hash -r
}

# Clean all rvm items out of the current working path.
__rvm_remove_rvm_from_path() {
  PATH=$(echo $PATH | \tr -s ':' '\n' | \grep -v "\.rvm" | \tr -s '\n' ':' | sed 's#:$##')
  export PATH
  builtin hash -r
}

# Run a specified command and log it.
__rvm_run() {
  log_file_name="$1" ; command="$2" ; 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"
  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
  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
}

# Runs a command in a given env.
__rvm_run_with_env() {
  log_file_name="$1" ; env_name="$2" ; command="$3" ; 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
    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
  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
}

# Unset both rvm variables as well as ruby-specific variables
# Preserve gemset if 'rvm_sticky' is set (persist gemset unless clear is explicitely called).
__rvm_cleanup_variables() {
  __rvm_unset_ruby_variables

  if [[ "$rvm_sticky_flag" = "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
}

# Unset ruby-specific variables
__rvm_unset_ruby_variables() {
  unset rvm_ruby_interpreter rvm_ruby_version rvm_url rvm_ruby_repo_url rvm_ruby_package_name rvm_ruby_patch_level rvm_ruby_make rvm_ruby_make_install rvm_ruby_revision rvm_ruby_tag rvm_release_version rvm_major_version rvm_minor_version rvm_ruby_gem_home rvm_ruby_binary rvm_ruby_home rvm_ruby_log_path rvm_ruby_src_path rvm_ruby_irbrc rvm_ruby_selected_flag rvm_ruby_src_path rvm_ruby_repo_url rvm_major_version rvm_minor_version rvm_ruby_gem_home rvm_head_flag rvm_ruby_configure rvm_ruby_mode rvm_ruby_package_file rvm_ruby_package_name rvm_ruby_gem_path rvm_ruby_name rvm_ruby_strings rvm_ruby_repo_path
}

# 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
}

# 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=""
  for ruby_name in $(\ls $rvm_rubies_path); do
    if [[ ! -L "$rvm_rubies_path/$ruby_name" ]] && $rvm_scripts_path/match "$ruby_name" '^(ruby-1.8.[[:digit:]]|rbx|ree)-'; then
      rubies="$rubies $ruby_name"
    fi
  done; unset ruby_name
  echo "$rubies" | sed 's/^ //' | \tr ' ' '\n' | sort | tail -n1
  unset rubies
}

__rvm_ensure_has_18_compat_ruby() {
  if [[ -z "$(__rvm_18_compat_ruby)" ]]; then
    # TODO: install currently doesn't return the correct status.
    local compat_result=0
    if ! ( $rvm_scripts_path/manage install 1.8.7 ); then
      $rvm_scripts_path/log "fail" "To proceed rvm requires a 1.8-compatible ruby is installed. We attempted to install 1.8.7 automatically but it failed."
      $rvm_scripts_path/log "fail" "Please install it manually (or a compatible alternative) to proceed."
      compat_result=1
    fi
    unset original_ruby
    return $compat_result
  fi
}

__rvm_inherit_trace_flag() {
  if [[ -n "$rvm_trace_flag" ]]; then
    set -x
    export rvm_trace_flag
  fi
}

# Cleans up temp folders for a given prefix,
# typically the current process id.
__rvm_cleanup_temp_for() {
  [[ -z "$1" ]] && return 1
  if [[ -d "$rvm_tmp_path/" ]]; then
    \rm -rf "$rvm_tmp_path/$1"* >/dev/null 2>&1
  fi
  exit
}

__rvm_cleanup_temp_on_exit() {
  trap "__rvm_cleanup_temp_for '$$'" 0 1 2 3 15
}

__rvm_set_rvmrc() {
  if [[ "$HOME" != "$(pwd)" ]] ; then
    if [[ "$rvm_verbose_flag" -eq 1 ]] ; then flags="use " ; fi

    if [[ -s .rvmrc ]] ; then
      mv .rvmrc .rvmrc.$(date +%m.%d.%Y-%H:%M:%S)
      $rvm_scripts_path/log "warning" ".rvmrc is not empty, moving aside to preserve."
    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

    unset flags
  else
    $rvm_scripts_path/log "error" ".rvmrc cannot be set in your home directory. \n The home .rvmrc is for global rvm settings only."
  fi

}
__rvm_load_rvmrc() {
  [[ -z "$rvm_ignore_rvmrc" ]] && return
  for rvmrc in /etc/rvmrc $HOME/.rvmrc ; do
    if [[ -f "$rvmrc" ]] ; then
      if \grep -q '^\s*rvm .*$' $rvmrc ; then
        $rvm_scripts_path/log "error" "$rvmrc is for rvm settings only.\nrvm CLI may NOT be called from within $rvmrc. \nSkipping the loading of $rvmrc"
        return 1
      else
        source "$rvmrc"
      fi
    fi
  done
}

# Wrap the specified ruby code file in a Benchmark.bmbm block and execute it.
__rvm_benchmark() {
  code="require \"benchmark\" \n Benchmark.bmbm do |benchmark| \n benchmark.report(\"${rvm_ruby_file}\") do \n"
  printf "\n$code" > "$rvm_tmp_path/$$.rb"
  unset code
  cat $rvm_ruby_file >> "$rvm_tmp_path/$$.rb"
  printf "\n end \nend\n" >> "$rvm_tmp_path/$$.rb"
  rvm_ruby_args="$rvm_tmp_path/$$.rb"
  rvm_benchmark_flag=1
  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
  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
}

# Loop over the currently installed rubies and refresh their binscripts.
__rvm_bin_scripts() {
  for rvm_ruby_binary in $rvm_rubies_path/*/bin/ruby ; do
  if [[ -x "$rvm_ruby_binary" ]] ; then
    rvm_ruby_string=$(dirname "$rvm_ruby_binary" | xargs dirname | xargs basename)
    __rvm_select
    __rvm_bin_script
  fi
  done
}

# 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"
}

# Add bin path if not present
__rvm_conditionally_add_bin_path() {
  if echo "$PATH" | \tr ':' ' ' | \grep -vqF "$rvm_bin_path " ; then
    PATH="$rvm_bin_path:$PATH"
    builtin hash -r
  fi
}

# 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() {
  PATH="$(echo $PATH | \tr ':' '\n' | awk '$0 !~ /rvm/' | paste -sd : -)"
  __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

  for file in system default ; do
    [[ -f "${rvm_path}/${file}" ]] && \rm -f "$rvm_path/${file}"
    [[ -f "${rvm_config_path}/${file}" ]] && \rm -f "$rvm_config_path/${file}"
    [[ -f "${rvm_environments_path}/${file}" ]] && \rm -f "$rvm_environments_path/${file}"
  done; unset file

  # Go back to a clean state.
  __rvm_become "system"
  __rvm_unset_ruby_variables

  for system_config in system_ruby system_gem_path system_user_gem_path ; do
    $rvm_scripts_path/db "$rvm_config_path/user" "$system_config" "delete"
  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*
}

# 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 '/' ?!... NO!"
      else
        if [[ -d "$rvm_path" ]] ; then
          $rvm_scripts_path/log "info" "Hai! Removing $rvm_path"
          \rm -rf $rvm_path/
          echo "$rvm_path has been removed."
        else
          $rvm_scripts_path/log "info" "It appears that $rvm_path is already non existant."
        fi
      fi
      break
    elif [[ "no" = "$response" ]] ; then
      $rvm_scripts_path/log "info" "Cancelling implosion, no harm done :)"
      break
    fi
  done
}

# 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
}

# Initialize rvm, ensuring that the path and directories are as expected.
__rvm_initialize() {
  rvm_ruby_load_path="."
  rvm_ruby_require=""

  __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"
}

# 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
    __rvm_version
    __rvm_update_rvm
  fi
  [[ -n "$rvm_bin_flag" ]] && __rvm_bin_scripts
  # Update to the latest rubygems.
  [[ -n "$rvm_rubygems_flag" ]] && $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
}

# 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 [[ -d "$rvm_src_path/rvm/.git" ]] ; then
      builtin cd "$rvm_src_path/rvm/" && git pull origin master && ./scripts/install
    else
      builtin cd "$rvm_src_path" && ( git clone --depth 1 git://github.com/wayneeseguin/rvm.git || git clone http://github.com/wayneeseguin/rvm.git ) && builtin cd rvm/ && ./scripts/install
    fi
  else
    stable_version="$(curl -s http://rvm.beginrescueend.com/releases/stable-version.txt)"

    __rvm_run "fetch" "$rvm_scripts_path/fetch 'http://rvm.beginrescueend.com/releases/rvm-${stable_version}.tar.gz'" "fetching rvm-${stable_version}.tar.gz"

    __rvm_run "extract" "cat $rvm_archives_path/rvm-${stable_version}.tar.gz | gunzip | tar xf - -C $rvm_src_path" "Extracting rvm-${stable_version}.tar.gz ..."

    __rvm_run "install" "builtin cd $rvm_src_path/rvm-${stable_version}/ ; ./install" "Installing rvm-${stable_version}..."
  fi

  __rvm_pushpop
  rvm_hook="after_update" ; source "$rvm_scripts_path/hook"
}

__rvm_reboot() {
  $rvm_scripts_path/log "warn" "Do you wish to reboot rvm? ('yes', or 'no')"
  read response
  if [[ "yes" = "$response" ]] ; then
    builtin cd $rvm_path
    __rvm_reset
    mv $rvm_path/archives ~/.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
  else
    $rvm_scripts_path/log "info" "Carry on then..."
  fi ; unset response
}

# Create the irbrc for the currently selected ruby installation.
__rvm_irbrc() {
  if [[ -d "$rvm_ruby_home" ]] && [[ ! -s "$rvm_ruby_irbrc" ]] ; then
    \cp $rvm_scripts_path/irbrc $rvm_ruby_irbrc
  fi
}

# Push or Pop a directory based on zero or one directory argument provided.
__rvm_pushpop() {
  if [[ -z "$1" ]] ; then
    popd > /dev/null 2>&1
  else
    pushd "$1" > /dev/null 2>&1
  fi
}

# Save or restore the rvm's state. This is a toggle action.
# Meant for use before and after an operation that might reset the currently selected ruby.
__rvm_state() {
  if [[ -z "$rvm_state" ]] ; then
    rvm_state="$(__rvm_environment_identifier)"
    rvm_state="${rvm_state:-"system"}"
    if [[ -n "$1" ]]; then
      rvm_ruby_string="$1"
      __rvm_select
      __rvm_use
    fi
  else
    rvm_ruby_string="$rvm_state"
    __rvm_select
    __rvm_use
    unset rvm_state
  fi
}

# Output an inspection of selected 'binary' scripts, based on CLI selection.
__rvm_inspect() {
  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 cat $actual_file | head -n 1    ; fi
    if [[ -n "$rvm_env_flag" ]]     ; then cat $actual_file | awk '/ENV/'  ; fi
    if [[ -n "$rvm_path_flag" ]]    ; then cat $actual_file | awk '/PATH/' ; fi
    if [[ -n "$rvm_head_flag" ]]    ; then cat $actual_file | head -n 5    ; fi
    if [[ -n "$rvm_tail_flag" ]]    ; then cat $actual_file | tail -n 5    ; fi
    if [[ -n "$rvm_all_flag" ]]     ; then cat $actual_file                ; fi
  done
}

# Attempt to override the Darwin build settings for rubies
# This should only be used in extreme edge cases that will not work via the default way.
__rvm_make_flags() {
  # This is only an issue with Darwin :/
  if [[ "Darwin" = "$(uname)" ]] ; then
    # \ls /usr/lib/gcc/x86_64-apple-darwin10

    # Set the build & host type
    if [[ "Power Macintosh" = "$(sysctl -n hw.machine)" ]] ; then
      : # Do nothing ?
    elif [[ "$(sysctl -n hw.cpu64bit_capable)" = 1 || "$(sysctl -n hw.optional.x86_64)" = 1 ]] ; then
      #   64 bit capable
      if [[ "-arch x86_64" = "$rvm_archflags" ]] ; then
        rvm_ruby_configure_flags="${rvm_ruby_configure_flags} --build=x86_64-apple-darwin$(uname -r) --host=x86_64-apple-darwin$(uname -r)"
      elif [[ "-arch i386" = "$rvm_archflags" ]] ; then
        rvm_ruby_configure_flags="${rvm_ruby_configure_flags} --build=i386-apple-darwin$(uname -r) --host=i386-apple-darwin$(uname -r)"
      else
        rvm_archflags="-arch x86_64"
        rvm_ruby_configure_flags="${rvm_ruby_configure_flags} --build=x86_64-apple-darwin$(uname -r) --host=x86_64-apple-darwin$(uname -r)"
      fi
    fi

    if [[ -n "$rvm_archflags" ]] ; then
      ARCHFLAGS="$rvm_archflags" ; export ARCHFLAGS
      # Use the latest sdk available.
      if [[ -z "$rvm_sdk" ]] ; then rvm_sdk="$(/usr/bin/basename -a /Developer/SDKs/* | awk '/^M/' | sort | tail -n 1)" ; fi
      CFLAGS="${CFLAGS:-"-isysroot /Developer/SDKs/$rvm_sdk $rvm_archflags"}" ; export CFLAGS
      LDFLAGS="${LDFLAGS:-"-Wl,-syslibroot /Developer/SDKs/$rvm_sdk $rvm_archflags"}" ; export LDFLAGS
      # CXXFLAGS="-mmacosx-version-min="$(sw_vers -productVersion | awk -F'.' '{print $1"."$2}')" -isysroot /Developer/SDKs/$rvm_sdk " ; export CXXFLAGS
    fi
  fi
}

__rvm_mono_env() {
  export DYLD_LIBRARY_PATH="$rvm_usr_path/lib:$DYLD_LIBRARY_PATH"
  export C_INCLUDE_PATH="$rvm_usr_path/include:$C_INCLUDE_PATH"
  export ACLOCAL_PATH="$rvm_usr_path/share/aclocal"
  export ACLOCAL_FLAGS="-I $ACLOCAL_PATH"
  export PKG_CONFIG_PATH="$rvm_usr_path/lib/pkgconfig:$PKG_CONFIG_PATH"
  PATH="$rvm_usr_path/bin:$PATH"
  builtin hash -r
}

__rvm_become() {
  [[ -n "$1" ]] && rvm_ruby_string="$1"
  { __rvm_ruby_string && __rvm_select && __rvm_use; } > /dev/null 2>&1
}

__rvm_ensure_has_environment_files() {
  local environment_identifier="$(__rvm_environment_identifier)"
  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
        printf "unset ${variable}\n" >> $file_name
      fi
    done ; unset variable value
  fi ; unset file_name

  # Next, ensure we have default wrapper files. Also, prevent it from recursing.
  if [[ -z "$rvm_creating_default_wrappers" ]]; 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
  fi
}

# Strip whitespace and normalize it all.
__rvm_strip() {
  sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//' -e 's/[[:space:]]\{1,\}/ /g'
}

__rvm_using_gemset_globalcache() {
  $rvm_scripts_path/db "$rvm_config_path/user" "use_gemset_globalcache" | \grep -q '^true$'
}

__rvm_current_gemcache_dir() {
  if __rvm_using_gemset_globalcache; then
    echo "$rvm_gems_cache_path"
  else
    echo "${rvm_ruby_gem_home:-"$GEM_HOME"}/cache"
  fi
}

__rvm_Answer_to_the_Ultimate_Question_of_Life_the_Universe_and_Everything() {
  for index in {1..750} ; do perl -e 'sleep 0.2'; echo -n '.' ; done ; printf "%d" 0x2A ; echo
}

__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."
}

__rvm_load_env_file() {
  if [[ -f "$rvm_environments_path/$1" ]]; then
    # Restore the path to it's state minus rvm
    PATH="$(echo $PATH | \tr ':' '\n' | awk '$0 !~ /rvm/' | paste -sd : -)"
    . "$rvm_environments_path/$1"
    builtin hash -r
  else
    rvm use "$1" >/dev/null 2>&1
  fi
}

__rvm_md5_for() {
  if command -v md5 > /dev/null; then
    echo "$1" | md5
  else
    echo "$1" | md5sum | awk '{print $1}'
  fi
}

__rvm_rvmrc_key() {
  __rvm_md5_for "$1"
}

__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
}

__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
}

__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
}

__rvm_rvmrc_stored_trust() {
  touch "$rvm_config_path/rvmrcs"
  $rvm_scripts_path/db "$rvm_config_path/rvmrcs" "$(__rvm_rvmrc_key "$1")"
}

__rvm_rvmrc_tools() {
  local rvmrc_action="$1"
  [[ $# -gt 0 ]] && shift
  local rvmrc_path="$(builtin cd "${1:-$PWD}" >/dev/null 2>&1; pwd)/.rvmrc"
  case "$rvmrc_action" in
    reset)
      __rvm_reset_rvmrc_trust "$rvmrc_path"
      echo "Reset trust for $rvmrc_path"
    ;;
    trust)
      __rvm_trust_rvmrc "$rvmrc_path"
      echo "Marked $rvmrc_path as trusted"
    ;;
    untrust)
      __rvm_untrust_rvmrc "$rvmrc_path"
      echo "Marked $rvmrc_path as untrusted"
    ;;
    trusted)
      local trusted_value="$(__rvm_rvmrc_stored_trust "$rvmrc_path")"
      if [[ "$trusted_value" = "1" ]]; then
        echo "The rvmrc at '$rvmrc_path' is currently trusted."
      elif [[ "$trusted_value" = "0" ]]; then
        echo "The rvmrc at '$rvmrc_path' is currently untrusted."
      else
        echo "The trustiworthiness of '$rvmrc_path' is currently unknown."
      fi
    ;;
    load)
      rvm_trust_rvmrcs=1 __rvm_project_rvmrc "$(dirname "$rvmrc_path")"
    ;;
    *)
      echo "Usage: rvm rvmrc {trust,untrust,trusted,load,reset}"
      return 1
    ;;
  esac
}

__rvm_check_rvmrc_trustworthiness() {
  # Trust when they have the flag... of doom!
  [[ -z "$1" || "$rvm_trust_rvmrcs" = "1" ]] && return
  value="$(__rvm_rvmrc_stored_trust "$1")"
  if [[ -z "$value" ]] ; then
    __rvm_ask_to_trust "$1"
  else
    [[ "$value" = "1" ]]
  fi
}

__rvm_ask_to_trust() {
  echo "Changing into a directory with an untrusted .rvmrc"
  echo "Do you wish to trust the rvmrc in this directory? It contains:"
  echo "---"
  echo ""
  cat "$1"
  echo ""
  echo "---"
  echo "So, do you wish to trust it? (y for yes, n for no)"
  local trusted=""
  while [[ -z "$trusted" ]] ; do
    printf ">> "
    read -r value
    value="$(echo "$value" | tr '[[:upper:]]' '[[:lower:]]' | __rvm_strip)"
    if [[ "$value" = "y"* ]]; then
      trusted=1
    elif [[ "$value" = "n"* ]]; then
      trusted=0
    fi
  done
  unset value
  if [[ "$trusted" == "1" ]] ; then
    __rvm_trust_rvmrc "$1"
    return 0
  else
    __rvm_untrust_rvmrc "$1"
    return 1
  fi
}

# Checks the rvmrc for the given directory. Note that if
# argument is passed, it will be used instead of pwd.
__rvm_project_rvmrc() {
  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
          __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
      break
    else
      if [[ -f "$cwd/.rvmrc" ]] ; then
        if [[ "$rvm_rvmrc_cwd" != "$cwd" ]] ; then
          if __rvm_check_rvmrc_trustworthiness "$cwd/.rvmrc" ; then
            rvm_previous_environment="$(__rvm_environment_identifier)"
            rvm_rvmrc_cwd="$cwd"
            source "$cwd/.rvmrc"
          fi
        fi
        break
      else
        cwd="$(dirname "$cwd")"
      fi
    fi
  done
}

__rvm_record_install() {
  [[ -z "$1" ]] && return
  local recorded_ruby_name="$($rvm_scripts_path/tools strings "$1")"
  local rvm_install_record_file="$rvm_config_path/installs"
  local rvm_install_command="$(echo "$recorded_ruby_name $rvm_install_arguments" | __rvm_strip)"
  \touch "$rvm_install_record_file"
  \rm -f "$rvm_install_record_file.tmp"
  cat "$rvm_install_record_file" | \grep -v "^$recorded_ruby_name " > "$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"
}

__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"
    cat "$rvm_install_record_file.tmp" | \grep -v "^$recorded_ruby_name " > "$rvm_install_record_file"
    \rm -f "$rvm_install_record_file.tmp"
  fi
}

__rvm_recorded_install_command() {
  local recorded_ruby_name="$($rvm_scripts_path/tools strings "$1" | awk -F"$rvm_gemset_separator" '{print $1}')"
  [[ -z "$recorded_ruby_name" ]] && return 1
  local recorded_ruby_match="^$recorded_ruby_name "
  if [[ -s "$rvm_config_path/installs" ]] && \grep -q "$recorded_ruby_match" "$rvm_config_path/installs" ; then
    cat "$rvm_config_path/installs" | \grep "$recorded_ruby_match" | head -n1
  else
    return 1
  fi
}

__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
}

__rvm_expand_ruby_string() {
  if [[ -z "$1" || "$1" = "all" ]]; then
    $rvm_scripts_path/list strings | tr ' ' "\n" | __rvm_strip
  elif [[ "$1" = "all-gemsets" ]]; then
    $rvm_scripts_path/list gemsets strings | __rvm_strip
  elif [[ "$1" = "default-with-rvmrc" || "$1" = "rvmrc" ]]; then
    $rvm_scripts_path/tools path-identifier "$(pwd)"
  elif [[ "$1" == "all-rubies" || "$1" = "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}')"
    rvm_silence_logging=1 $rvm_scripts_path/gemsets list | sed "s/^/$current_ruby$rvm_gemset_separator/"  | __rvm_strip
  elif [[ "$1" = "current" ]]; then
    __rvm_environment_identifier
  elif [[ "$1" = "aliases" ]]; then
    cat "$rvm_config_path/alias" | awk -F= '{print $1}' | __rvm_strip
  else
    echo "$1" | tr "," "\n" | __rvm_strip
  fi
}