#!/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 # bash array indexes are 0 based.
  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
    : # 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
  # the cleanup phase.

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

  unset rvm_ruby_strings rvm_head_flag rvm_prior_cc

  [[ ${rvm_dump_environment_flag:-0} -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 dump_environment_type rvm_dump_environment_flag

  dump_environment_file="${rvm_dump_environment_flag/,*/}"

  dump_environment_type="${rvm_dump_environment_flag/*,/}"

  if [[ -n "$dump_environment_file" && -n "$dump_environment_type" ]]; then

    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_path/scripts/environment-convertor" "$dump_environment_type" "$(__rvm_environment_identifier)" > "$dump_environment_file"
      if [[ "$?" -gt 0 && -f "$dump_environment_file" ]] ; then
        \rm -f "$dump_environment_file"
      fi
    fi
  fi

  return 0
}

# Return a list of directories under a given base path.
# Derived from rvm_ruby_string.
__rvm_ruby_string_paths_under() {
  local path path_parts

  path="$1"

  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() {
  local value key variable

  key=${1:-""}
  variable=${2:-""}

  if [[ -f "$rvm_config_path/user" ]] ; then
    value="$($rvm_path/scripts/db "$rvm_config_path/user" "$key")"
  fi

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

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

  return 0
}

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'

  return 0
}

__rvm_quote_args_with_shift() {

  local shift_value="$1"; shift

  while [[ "$shift_value" -gt 0 && $# -gt 0 ]]; do

    shift

    ((shift_value--))

  done

  __rvm_quote_args "$@"

  return 0
}

__rvm_warn_on_rubyopt() {

  if [[ -n "${RUBYOPT:-""}" ]]; then
    "$rvm_path/scripts"/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() {
  local strings ruby_strings

  ruby_strings=($(echo ${rvm_ruby_args:-$rvm_ruby_string}))

  for rvm_ruby_string in "${ruby_strings[@]}" ; do
    strings="$strings $(__rvm_select ; echo $rvm_ruby_string)"
  done

  echo $strings

  return 0
}

# Push an item onto a given array.
__rvm_push() {

  local array item

  array=$1 ; shift ; item=$2

  # TODO: allow loop over more arguments.
  eval "index=\$((\${#${array}[*]} + $__shell_array_start))"

  eval "${array}[${index}]=${item}"

  return 0
}

# 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="${PATH//${rvm_path}*rvm\/bin:}"

  export PATH

  builtin hash -r
}

# Run a specified command and log it.
__rvm_run() {

  local log_file_name command message

  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_path/scripts/log" "info" "$message" ; fi

  if [[ ${rvm_debug_flag:-0} -gt 0 ]] ; then
    "$rvm_path/scripts/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
  )
  local result=$?

  if [[ $result -gt 0 ]] ; then
    "$rvm_path/scripts/log" "error" \
      "Error running '$command', please check $rvm_ruby_log_path/$log_file_name*.log"
  fi

  return $result
}

# Runs a command in a given env.
__rvm_run_with_env() {

  local log_file_name env_name comand message

  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_path/scripts/log" "info" "$message" ; fi

  if [[ ${rvm_debug_flag:-0} -gt 0 ]] ; then
    "$rvm_path/scripts/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:-""}" || $rvm_niceness -eq 0 ]] ; 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_path/scripts/log" "error" \
      "Error running '$command' under $env_name, please check $rvm_ruby_log_path/$log_file_name*.log"
  fi

  return $result
}

__rvm_nuke_rvm_variables() {
  unset rvm_head_flag $(env | awk -F= '/^rvm_/{print $1" "}')
}

# Unset ruby-specific variables
__rvm_unset_ruby_variables() {
  unset rvm_ruby_flag $(env | awk -F= '/^rvm_ruby_/{printf $1" "}')
}

# TODO: Should be able to...
#   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_cleanse_variables() {

  __rvm_unset_ruby_variables

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

# Usage: __rvm_with_env 'env-name' 'command'
__rvm_with_env() {
  local environment_id command

  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() {
  local rubies ruby_name

  rubies=($( cd "$rvm_rubies_path" ; find . -maxdepth 1 -mindepth 1 -type d ))

  for ruby_name in "${rubies[@]//.\/}"; do

    if [[ ! -L "$rvm_rubies_path/$ruby_name" ]] ; then

      case $ruby_name in
        *1.8.*|rbx-*|ree-*) rubies="$rubies $ruby_name" ;;
      esac
    fi
  done

  echo $rubies | \tr ' ' '\n' | \sort | \tail -n1

  return 0
}

__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_path/scripts/manage" install 1.8.7 ); then

      "$rvm_path/scripts/log" "fail" \
        "To proceed rvm requires a 1.8-compatible ruby is installed. We attempted to install 1.8.7 automatically but it failed.\
        Please install it manually (or a compatible alternative) to proceed."

      compat_result=1

    fi
    # unset original_ruby
    # Question: Why *were* we unsetting original_ruby here
    return $compat_result
  fi

  return 0
}

# Cleans up temp folders for a given prefix,
# typically the current process id.
__rvm_cleanup_temp_for() {
  result=$? # Capture last command status

  local prefix

  prefix="$1"

  [[ -z "$prefix" ]] && return 1

  if [[ -d "$rvm_tmp_path/" ]]; then
    \rm -rf "$rvm_tmp_path/$prefix"* >/dev/null 2>&1
  fi

  return $result
}

__rvm_set_rvmrc() {
  if [[ "$HOME" != "$PWD" ]] ; then

    if [[ ${rvm_verbose_flag:-0} -gt 0 ]] ; then flags="use " ; fi

    if [[ -s .rvmrc ]] ; then
      mv .rvmrc .rvmrc.$(date +%m.%d.%Y-%H:%M:%S)
      "$rvm_path/scripts/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_path/scripts/log" "error" ".rvmrc cannot be set in your home directory. \n The home .rvmrc is for global rvm settings only."
  fi
}
__rvm_load_rvmrc() {
  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
        "$rvm_path/scripts/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

  return 0
}

# 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 [[ ${rvm_debug_flag:0} -gt 0 ]] ; then printf "\n$rvm_tmp_path/$$.rb:\n$(cat $rvm_tmp_path/$$.rb)" ; fi
  # Override ruby string stuff, pass through.
  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_path/scripts/set" "$rvm_action" $rvm_ruby_args
  result=$?
  # Restore the state pre-sets.
  [[ -n "$old_rvm_ruby_string" ]] && rvm_ruby_string=$old_rvm_ruby_string

  return $result
}

# 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
  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_path/scripts/wrapper" "$rvm_ruby_string"
  return $?
}

# Add bin path if not present
__rvm_conditionally_add_bin_path() {
  if echo "${PATH//:/ }" | \grep -vqF "$rvm_bin_path " ; then
    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

  builtin hash -r

  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}"
    [[ -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_path/scripts/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*

  return 0
}

# Implode removes the entire rvm installation under $rvm_path.
__rvm_implode() {
  while : ; do
    "$rvm_path/scripts/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_path/scripts/log" "error" "remove '/' ?!... Ni!"
      else
        if [[ -d "$rvm_path" ]] ; then
          "$rvm_path/scripts/log" "info" "Hai! Removing $rvm_path"
          \rm -rf "$rvm_path/"
          echo "$rvm_path has been removed."
        else
          "$rvm_path/scripts/log" "info" "It appears that $rvm_path is already non existant."
        fi
      fi
      break
    elif [[ "no" = "$response" ]] ; then
      "$rvm_path/scripts/log" "info" "Cancelling implosion, no harm done :)"
      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_path/scripts/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.
__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"

  return 0
}

# Update rubygems or binscripts based on CLI selection.
__rvm_update() {
  (
    builtin cd "$rvm_path"

    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

    [[ ${rvm_bin_flag:-0} -eq 1 ]] && __rvm_bin_scripts

    # Update to the latest rubygems.
    [[ ${rvm_rubygems_flag:-0} -eq 1 ]] && "$rvm_path/scripts/rubygems" current

  )
  unset rvm_update_flag rvm_action rvm_self_flag rvm_ruby_revision rvm_bin_flag rvm_rubygems_flag
  return 0
}

# Update rvm using rubygems
# If --head was specified, update from git repository master branch.
__rvm_update_rvm() {
  \mkdir -p "$rvm_src_path"
  (
    builtin cd "$rvm_src_path"
    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
        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_path/scripts/fetch 'http://rvm.beginrescueend.com/releases/rvm-${stable_version}.tar.gz'" "fetching rvm-${stable_version}.tar.gz"

      __rvm_run "extract" "gunzip < \"$rvm_archives_path/rvm-${stable_version}.tar.gz\" | 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_hook="after_update" ; source "$rvm_path/scripts/hook"

  return 0
}

__rvm_reboot() {
  "$rvm_path/scripts/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_path/scripts/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_path/scripts/log" "info" "Carry on then..."
  fi

  return 0
}

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

# 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

  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_path/scripts/log" "info" "$actual_file:"

    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
# 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_configure_flags="${rvm_configure_flags} --build=x86_64-apple-darwin$(uname -r) --host=x86_64-apple-darwin$(uname -r)"
      elif [[ "-arch i386" = "${rvm_archflags:-""}" ]] ; then
        rvm_configure_flags="${rvm_configure_flags} --build=i386-apple-darwin$(uname -r) --host=i386-apple-darwin$(uname -r)"
      else
        rvm_archflags="-arch x86_64"
        rvm_configure_flags="${rvm_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

  return 0
}

__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

  return 0
}

__rvm_become() {
  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
        printf "unset ${variable}\n" >> "$file_name"
      fi
    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 [[ ${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_path/scripts/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_path/scripts/db" "$rvm_config_path/user" "use_gemset_globalcache" | \grep -q '^true$'
  return $?
}

__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
  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 "
  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() {
  local string="$1"
  if [[ -f "$rvm_environments_path/$string" ]]; then
    # Restore the path to it's state minus rvm
    __rvm_remove_rvm_from_path

    # source the environment file
    \. "$rvm_environments_path/$string"

    # clear the PATH cache
    builtin hash -r
  elif [[ -n "$string" ]] ; then
    rvm "$string"
  else
    : # 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
  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_path/scripts/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_path/scripts/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_path/scripts/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_path/scripts/db" "$rvm_config_path/rvmrcs" "$(__rvm_rvmrc_key "$1")"
  return $?
}

__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_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() {
  # Trust when they have the flag... of doom!
  [[ -z "$1" || "$rvm_trust_rvmrcs" = "1" ]] && return 0
  value="$(__rvm_rvmrc_stored_trust "$1")"
  if [[ -z "$value" ]] ; then
    __rvm_ask_to_trust "$1"
  else
    [[ "$value" = "1" ]]
  fi
  return $?
}

__rvm_ask_to_trust() {

  local trusted value

  [[ -n "$rvm_promptless" ]] && return 2

  printf "
  ============================================================
  RVM has encountered a not yet trusted .rvmrc file in the
  current working directory which contains the following code:
  ============================================================

$(cat $1)

  ============================================================
  Trusting an .rvmrc file means that whenever you cd into the
  directory RVM will excecute this .rvmrc script in your shell

  Do you wish to trust this .rvmrc from now on?
  ============================================================
  (y for yes, n for no)"

  # TODO: Eliminate infinite loop possibility.
  while [[ -z "$trusted" ]] ; do

    printf " > "

    read -r response

    value="$(echo "$response" | tr '[[:upper:]]' '[[:lower:]]' | __rvm_strip)"

    if [[ "$response" = "y"* ]]; then
      trusted=1

    elif [[ "$response" = "n"* ]]; then
      trusted=0
    fi
  done

  if [[ ${trusted:-0} -gt 0 ]] ; 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:-0} -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
      break
    else

      if [[ -f "$cwd/.rvmrc" ]] ; then

        if [[ "${rvm_rvmrc_cwd:-""}" != "$cwd" ]] ; then

          __rvm_check_rvmrc_trustworthiness "$cwd/.rvmrc"

          local rvm_trustworthiness_result="$?"

          if  [[ "$rvm_trustworthiness_result" = 0 ]]; then

            rvm_previous_environment="$(__rvm_environment_identifier)"

            rvm_rvmrc_cwd="$cwd"

            source "$cwd/.rvmrc"

            return 0
          else
            return "$rvm_trustworthiness_result"
          fi
        fi
        break

      else
        cwd="$(dirname "$cwd")"
      fi
    fi
  done

  return $?
}

__rvm_record_install() {

  local recorded_ruby_name rvm_install_record_file rvm_install_command

  [[ -z "$1" ]] && return

  recorded_ruby_name="$($rvm_path/scripts/tools strings "$1")"

  rvm_install_record_file="$rvm_config_path/installs"

  rvm_install_command="$(echo "$recorded_ruby_name $rvm_install_arguments" | __rvm_strip)"

  \touch "$rvm_install_record_file"

  \rm -f "$rvm_install_record_file.tmp"

  \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"

  return 0
}

__rvm_remove_install_record() {
  local recorded_ruby_name rvm_install_record_file

  recorded_ruby_name="$($rvm_path/scripts/tools strings "$1")"

  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"

    \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() {

  local recorded_ruby_name recorded_ruby_match

  recorded_ruby_name="$($rvm_path/scripts/tools strings "$1" | awk -F"${rvm_gemset_separator:-"@"}" '{print $1}')"

  [[ -z "$recorded_ruby_name" ]] && return 1

  recorded_ruby_match="^$recorded_ruby_name "

  if [[ -s "$rvm_config_path/installs" ]] && \grep -q "$recorded_ruby_match" "$rvm_config_path/installs" ; then

    \grep "$recorded_ruby_match" < "$rvm_config_path/installs" | head -n1

  else
    return 1
  fi
  return $?
}

__rvm_environment_identifier() {

  local path string

  path="${GEM_HOME:-""}"

  string="${path//*gems\//}"
  string="${string//\/*/}"

  echo "${string:-system}"

  return $?
}

__rvm_expand_ruby_string() {

  local string="$1"

  if [[ -z "$string" || "$string" = "all" ]]; then
    "$rvm_path/scripts/list" strings | tr ' ' "\n"

  elif [[ "$string" = "all-gemsets" ]]; then
    "$rvm_path/scripts/list" gemsets strings

  elif [[ "$string" = "default-with-rvmrc" || "$string" = "rvmrc" ]]; then
    "$rvm_path/scripts/tools" path-identifier "$PWD"

  elif [[ "$string" == "all-rubies" || "$string" = "rubies" ]]; then
    "$rvm_path/scripts/list" rubies strings

  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_path/scripts/gemsets" list | sed "s/^/$current_ruby${rvm_gemset_separator:-"@"}/"

  elif [[ "$string" = "current" ]]; then
    __rvm_environment_identifier

  elif [[ "$string" = "aliases" ]]; then
    awk -F= '{print $string}' < "$rvm_config_path/alias"

  else

    echo "$string" | tr "," "\n" | __rvm_strip
  fi
  return $?
}