#!/usr/bin/env bash

__rvm_select_rbx_nightly()
{
  (( ${rvm_nightly_flag:=0} == 1 )) || return 0

  typeset org_rvm_ruby_patch_level _rvm_ruby_name
  if [[ "$rvm_ruby_version" == head ]]
  then rvm_ruby_version=""
  fi
  rvm_debug "searching for binary rbx ${rvm_ruby_version:-}${rvm_ruby_version:+-}${rvm_ruby_patch_level}*${rvm_ruby_name:+-}${rvm_ruby_name:-}"
  org_rvm_ruby_patch_level="$rvm_ruby_patch_level"
  _rvm_ruby_name="${rvm_ruby_name:-${detected_rvm_ruby_name:-}}"
  rvm_ruby_patch_level="$(
    __list_remote_rbx_for $( __rvm_system_path_for rbx ) |
      __rvm_grep ${rvm_ruby_version:-}${rvm_ruby_version:+-}${org_rvm_ruby_patch_level}.*${_rvm_ruby_name:+-}${_rvm_ruby_name:-} |
      __rvm_tail -n 1
  )"
  [[ -n "${rvm_ruby_patch_level:-}" ]] ||
  {
    rvm_error "Could not find rbx binary '${rvm_ruby_version:-}${rvm_ruby_version:+-}${org_rvm_ruby_patch_level}*${rvm_ruby_name:+-}${rvm_ruby_name:-}' release for '$( __rvm_system_path_for rbx )'."
    return 1
  }
  rvm_ruby_patch_level="${rvm_ruby_patch_level##*/}"
  rvm_ruby_patch_level="${rvm_ruby_patch_level%.tar.*}"
  if
    [[ -z "${rvm_ruby_version:-}" ]]
  then
    rvm_ruby_patch_level="${rvm_ruby_patch_level#rubinius-}"
    rvm_ruby_version="${rvm_ruby_patch_level%%-*}"
  fi
  if
    [[ -z "${rvm_ruby_name:-}" ]]
  then
    rvm_ruby_name="${rvm_ruby_patch_level##*-}"
  fi
  rvm_ruby_patch_level="${rvm_ruby_patch_level##*${org_rvm_ruby_patch_level}}"
  rvm_ruby_patch_level="${rvm_ruby_patch_level%%-*}"
  rvm_ruby_patch_level="${org_rvm_ruby_patch_level}${rvm_ruby_patch_level}"
  rvm_ruby_string="rubinius-${rvm_ruby_version}-${rvm_ruby_patch_level}-${rvm_ruby_name}"
  rvm_debug "detected rbx ${rvm_ruby_string}"
  rvm_verify_downloads_flag=1
}

__rvm_select_rbx_compatibility_branch()
{
  case "${rvm_ruby_version}" in
    (2.0pre)      rvm_ruby_repo_branch="master"              ;;
    (2.0.testing) rvm_ruby_repo_branch="${rvm_ruby_version}" ;;
  esac

  if
    [[ ${rvm_19_flag:-0} == 1 ]]
  then
    rvm_ruby_repo_branch="1.9.3"
    rvm_head_flag=1
  elif
    [[ ${rvm_18_flag:-0} == 1 ]]
  then
    rvm_ruby_repo_branch="1.8.7"
    rvm_head_flag=1
  fi
}

__rvm_select_macruby_nightly_selected()
{
  typeset __string_version
  __string_version="${rvm_ruby_version//./-}"
  __string_version="${__string_version#nightly_}"

  rvm_ruby_package_name="${rvm_ruby_interpreter}_nightly-${__string_version}"
  rvm_ruby_package_file="$rvm_ruby_package_name.pkg"
}

__rvm_select_macruby_nightly_detect()
{
  typeset __string_version
  rvm_ruby_version="$(
    __rvm_curl -s "$rvm_ruby_url" |
    __rvm_grep -oE "<a href=\"macruby_nightly-[^<]+\.pkg</a>" |
    __rvm_awk -F"[<>]" '{print $3}' | sort | __rvm_tail -n 1
  )"
  [[ -n "${rvm_ruby_version}" ]] ||
  {
    rvm_error "Could not find MacRuby nightly binary."
    return 1
  }
  rvm_ruby_package_file="${rvm_ruby_version}"
  rvm_ruby_package_name="${rvm_ruby_package_file%.pkg}"

  __string_version="${rvm_ruby_package_name#macruby_nightly-}"
  __string_version="${__string_version//-/.}"

  rvm_ruby_version="nightly_${__string_version}"
  rvm_ruby_string="macruby-${rvm_ruby_version}${rvm_ruby_name:+-}${rvm_ruby_name:-}"
}

__rvm_select_macruby_nightly()
{
  __rvm_db "macruby_nightly_url" "rvm_ruby_url"

  case "${rvm_ruby_version:-}" in
    (nightly_*)
      __rvm_select_macruby_nightly_selected
      ;;
    (*)
      __rvm_select_macruby_nightly_detect
      ;;
  esac

  rvm_ruby_url+="/${rvm_ruby_package_file}"
  rvm_verify_downloads_flag=1
  rvm_debug "selected macruby $rvm_ruby_string => $rvm_ruby_url"
}

__rvm_select_interpreter_macruby()
{
  if
    [[ "Darwin" == "${_system_type}" ]]
  then
    rvm_ruby_package_name="${rvm_ruby_interpreter}-${rvm_ruby_version}"
    if
      (( ${rvm_head_flag:=0} == 1 ))
    then
      rvm_ruby_version=""
      rvm_ruby_tag=""
      rvm_ruby_revision="head"
      __rvm_db "macruby_repo_url" "rvm_ruby_repo_url"
      rvm_ruby_url="$rvm_ruby_repo_url"
      rvm_disable_binary_flag=1
    elif
      [[ "${rvm_ruby_version:-}" == *"nightly"* ]]
    then
      __rvm_select_macruby_nightly
    elif
      [[ -n "${rvm_ruby_version:-}" ]]
    then
      __rvm_db "macruby_${rvm_ruby_version}_url" "rvm_ruby_url"
      [[ -n "${rvm_ruby_url:-}" ]] || __rvm_db "macruby_url" "rvm_ruby_url"
      rvm_ruby_package_name="MacRuby%20${rvm_ruby_version}.zip"
      rvm_ruby_package_file="$rvm_ruby_package_name"
      rvm_ruby_url="$rvm_ruby_url/$rvm_ruby_package_name"
    else
      __rvm_db "macruby_version" "rvm_ruby_version"
      __rvm_db "macruby_url" "rvm_ruby_url"
      rvm_ruby_package_name="MacRuby%20${rvm_ruby_version}.zip"
      rvm_ruby_package_file="$rvm_ruby_package_name"
      rvm_ruby_url="$rvm_ruby_url/$rvm_ruby_package_name"
    fi
    rvm_ruby_patch_level=""
  else
    rvm_error "MacRuby can only be installed on a Darwin OS."
  fi
}

__rvm_select_interpreter_rbx()
{
  __rvm_select_rbx_nightly || return $?

  rvm_ruby_interpreter="rbx"
  rvm_ruby_string="${rvm_ruby_string//rubinius/rbx}"

  __rvm_select_rbx_compatibility_branch

  if
    (( ${rvm_head_flag:=1} == 0 )) &&
    [[ -z "${rvm_ruby_repo_branch:-}" ]] &&
    [[ "${rvm_ruby_version}" != "head" ]]
  then
    if
      __rvm_version_compare "${rvm_ruby_version}" -ge "2.0.0"
    then
      rbx_url="$( __rvm_db "rbx_2.0.0_url" )"
      rvm_archive_extension="tar.bz2"
      rvm_ruby_package_file="rubinius-${rvm_ruby_version}"
      rvm_ruby_url="${rbx_url}/${rvm_ruby_package_file}.${rvm_archive_extension}"
    else
      rbx_url=${rbx_url:-$(__rvm_db "rbx_url")}
      rvm_archive_extension="tar.gz"
      rvm_ruby_package_file="rubinius-${rvm_ruby_version}"
      rvm_ruby_url="${rbx_url}/$rvm_ruby_package_file.${rvm_archive_extension}"
    fi
  else
    rvm_ruby_repo_url=${rvm_rbx_repo_url:-$(__rvm_db "rubinius_repo_url")}
    rvm_head_flag=1
    rvm_ruby_patch_level=""
    rvm_ruby_version="head"
    rvm_disable_binary_flag=1
  fi

  if [[ -n "${rvm_rbx_opt:-}" ]]
  then export RBXOPT="${RBXOPT:=${rvm_rbx_opt}}"
  fi
}

__rvm_select_interpreter_rubinius()
{
  __rvm_select_interpreter_rbx || return $?
}

__rvm_select_interpreter_jruby()
{
  rvm_ruby_patch_level=""
  rvm_ruby_repo_url="${rvm_ruby_repo_url:-$(__rvm_db "jruby_repo_url")}"
  rvm_ruby_url="${rvm_ruby_repo_url:-$(__rvm_db "jruby_repo_url")}"
  if (( ${rvm_head_flag:=0} == 1 ))
  then
    (( ${rvm_remote_flag:-0} == 1 )) || rvm_disable_binary_flag=1
    rvm_ruby_version="head"
  else
    if (( ${rvm_18_flag:-0} || ${rvm_19_flag:-0} || ${rvm_20_flag:-0} || ${#rvm_patch_names[@]} ))
    then rvm_disable_binary_flag=1
    fi
    rvm_ruby_version="${rvm_ruby_version:-"$(__rvm_db "jruby_version")"}"
    rvm_ruby_tag="${rvm_ruby_tag:-${rvm_ruby_version}}"
  fi

  alias jruby_ng="jruby --ng"
  alias jruby_ng_server="jruby --ng-server"
}

__rvm_select_interpreter_maglev()
{
  rvm_ruby_patch_level=""
  maglev_url="$(__rvm_db "maglev_url")"

  system="${_system_type}"
  if [[ "$MACHTYPE" == x86_64-apple-darwin* ]]
  then arch="i386" # x86_64-apple-darwin supports both i386 and x86_64 maglev implements only i386
  else arch="${_system_arch}"
  fi

  if
    (( ${rvm_head_flag:=0} == 1 )) || [[ "$rvm_ruby_version" == "head" ]]
  then
    rvm_head_flag=1
    rvm_ruby_version="head"
    rvm_ruby_repo_url="${rvm_ruby_repo_url:-$(__rvm_db "maglev_repo_url")}"
    rvm_ruby_url="${rvm_ruby_repo_url:-$(__rvm_db "maglev_repo_url")}"
    rvm_gemstone_version=$(
      __rvm_curl -s https://raw.github.com/MagLev/maglev/master/version.txt |
        __rvm_grep "^GEMSTONE" | cut -f2 -d-
    )
    rvm_gemstone_package_file="GemStone-${rvm_gemstone_version}.${system}-${arch}"
    rvm_disable_binary_flag=1
  else
    rvm_ruby_package_file="MagLev-${rvm_ruby_version}" # removed from 1.0: .${system}-${arch}
    rvm_ruby_version="${rvm_ruby_version:-"$(__rvm_db "maglev_version")"}"
    rvm_ruby_package_name="${rvm_ruby_interpreter}-${rvm_ruby_version}"
    rvm_ruby_url="${rvm_ruby_url:-"$maglev_url/${rvm_ruby_package_file}.${rvm_archive_extension}"}"
    rvm_gemstone_version=$(
      __rvm_curl -s https://raw.github.com/MagLev/maglev/MagLev-${rvm_ruby_version}/version.txt |
        __rvm_grep "^GEMSTONE" | cut -f2 -d-
    )
    rvm_gemstone_package_file="GemStone-${rvm_gemstone_version}.${system}-${arch}"
  fi

  export MAGLEV_HOME="$rvm_ruby_home"
  export GEMSTONE_GLOBAL_DIR=$MAGLEV_HOME

  rvm_gemstone_url="$maglev_url/${rvm_gemstone_package_file}.${rvm_archive_extension}"
}

__rvm_select_interpreter_ironruby()
{
  rvm_ruby_patch_level=""
  if
    (( ${rvm_head_flag:=0} == 1 ))
  then
    rvm_ruby_version="head"
    rvm_ruby_package_name="${rvm_ruby_string}"
    rvm_ruby_repo_url="${rvm_ruby_repo_url:-$(__rvm_db "ironruby_repo_url")}"
    rvm_ruby_url="${rvm_ruby_repo_url:-$(__rvm_db "ironruby_repo_url")}"
    rvm_disable_binary_flag=1
  else
    rvm_archive_extension="zip"
    rvm_ruby_version=${rvm_ruby_version:-"$(__rvm_db "ironruby_version")"}
    rvm_ruby_package_name="${rvm_ruby_interpreter}-${rvm_ruby_version}"
    rvm_ruby_package_file="${rvm_ruby_interpreter}-${rvm_ruby_version}.${rvm_archive_extension}"
    rvm_ruby_url="$(__rvm_db "ironruby_${rvm_ruby_version}_url")"
  fi
  export rvm_ruby_version rvm_ruby_string rvm_ruby_package_name rvm_ruby_repo_url rvm_ruby_url rvm_archive_extension
}

__rvm_select_interpreter_ree()
{
  rvm_ruby_interpreter=ree
  rvm_ruby_version=${rvm_ruby_version:-"$(__rvm_db "ree_version")"}

  case "$rvm_ruby_version" in
    1.8.*) true ;; # all good!
    *) rvm_error "Unknown Ruby Enterprise Edition version: $rvm_ruby_version" ;;
  esac

  if [[ -n "${rvm_ruby_patch_level:-0}" ]]
  then rvm_ruby_patch_level="${rvm_ruby_patch_level#p}"
  fi

  rvm_ruby_package_file="ruby-enterprise-$rvm_ruby_version-$rvm_ruby_patch_level"
  rvm_ruby_url="$(__rvm_db "${rvm_ruby_interpreter}_${rvm_ruby_version}_${rvm_ruby_patch_level}_url")"
  rvm_ruby_url="${rvm_ruby_url:-$(__rvm_db "${rvm_ruby_interpreter}_${rvm_ruby_version}_url")}"
  rvm_ruby_url="${rvm_ruby_url}/$rvm_ruby_package_file.tar.gz"
}

__rvm_select_interpreter_common()
{
  rvm_ruby_interpreter="${1}"
  rvm_ruby_version="head"
  rvm_ruby_patch_level=""
  export rvm_head_flag=1
  rvm_ruby_repo_url="${rvm_ruby_repo_url:-$(__rvm_db "${1}_repo_url")}"
  rvm_ruby_url=$rvm_ruby_repo_url
  rvm_ruby_configure=""
  rvm_ruby_make=""
  rvm_ruby_make_install=""
}

__rvm_select_interpreter_opal()
{
  __rvm_select_interpreter_common "opal"
}

__rvm_select_interpreter_topaz()
{
  __rvm_select_interpreter_common "topaz"
}

__rvm_select_interpreter_kiji()
{
  __rvm_select_interpreter_common "kiji"
  rvm_ruby_string="kiji-head"
}

__rvm_select_interpreter_goruby()
{
  __rvm_select_interpreter_common "goruby"
  rvm_ruby_string="goruby"
}

__rvm_select_interpreter_mruby()
{
  __rvm_select_interpreter_common "mruby"
  rvm_ruby_string="mruby-head"
  rvm_disable_binary_flag=1
  export rvm_skip_autoreconf_flag=1
}

__rvm_select_interpreter_tcs()
{
  __rvm_select_interpreter_common "tcs"
  rvm_ruby_string="tcs"
  rvm_disable_binary_flag=1
}

__rvm_select_interpreter_jamesgolick()
{
  __rvm_select_interpreter_common "jamesgolick"
  rvm_ruby_string="jamesgolick"
  rvm_ruby_repo_branch="${rvm_ruby_repo_branch:-"$(__rvm_db "jamesgolick_repo_branch")"}"
  rvm_disable_binary_flag=1
}

__rvm_select_interpreter_ruby()
{
  if
    [[ -n "${rvm_ruby_patch_level}" ]]
  then
    if
      [[ "${rvm_ruby_patch_level}" == "p0" ]] &&
      __rvm_version_compare "${rvm_ruby_version}" -ge 2.1.0
    then
      rvm_ruby_package_name="${rvm_ruby_interpreter}-${rvm_ruby_version}"
    else
      rvm_ruby_package_name="${rvm_ruby_interpreter}-${rvm_ruby_version}-${rvm_ruby_patch_level}"
    fi
  else
    rvm_ruby_package_name="${rvm_ruby_interpreter}-${rvm_ruby_version}"
  fi
  rvm_ruby_package_file="${rvm_ruby_package_name}"
  if
    [[ -z "${rvm_ruby_version:-""}" ]] &&
    (( ${rvm_head_flag:=0} == 0 ))
  then
    rvm_error "Ruby version was not specified!"
  else
    rvm_ruby_repo_url="${rvm_ruby_repo_url:-"$(__rvm_db "ruby_repo_url")"}"
    if
      (( ${rvm_head_flag:=0} == 0 ))
    then
      if __rvm_version_compare "${rvm_ruby_version}" -lt "1.8.5"
      then rvm_archive_extension="tar.gz"
      else rvm_archive_extension="tar.bz2"
      fi
    else
      rvm_disable_binary_flag=1
    fi
  fi
}

__rvm_select_interpreter_ext()
{
  if
    [[ -z "${rvm_ruby_name:-${detected_rvm_ruby_name:-}}" ]]
  then
    rvm_error "External ruby name was not specified!"
    return 1
  fi
}

__rvm_select_interpreter_current()
{
  ruby_binary="$(builtin command -v ruby)"
  if
    (( $? == 0)) &&
    __rvm_string_match "$ruby_binary" "*rvm*"
  then
    rvm_ruby_string="$(dirname "$ruby_binary" | __rvm_xargs dirname | __rvm_xargs basename)"
  else
    rvm_ruby_interpreter="system"
  fi
}

__rvm_select_interpreter_default()
{
  true # do nothing
}

__rvm_select_interpreter_system()
{
  true # do nothing
}

__rvm_select_interpreter_user()
{
  true # do nothing
}

__rvm_select_interpreter_missing()
{
  return 2
}

__rvm_select_set_variable_defaults()
{
  export -a rvm_configure_flags rvm_patch_names rvm_ree_options rvm_make_flags
  export GEM_HOME GEM_PATH MY_RUBY_HOME RUBY_VERSION IRBRC
  export rvm_env_string rvm_action rvm_alias_expanded rvm_archive_extension rvm_bin_flag rvm_bin_path rvm_debug_flag rvm_default_flag rvm_delete_flag rvm_docs_type rvm_dump_environment_flag rvm_error_message rvm_expanding_aliases rvm_file_name rvm_gemdir_flag rvm_gemset_name rvm_gemstone_package_file rvm_gemstone_url rvm_head_flag rvm_hook rvm_install_on_use_flag rvm_llvm_flag rvm_loaded_flag rvm_niceness rvm_nightly_flag rvm_only_path_flag rvm_parse_break rvm_patch_original_pwd rvm_pretty_print_flag rvm_proxy rvm_quiet_flag rvm_reload_flag rvm_remove_flag rvm_ruby_alias rvm_ruby_args rvm_ruby_binary rvm_ruby_bits rvm_ruby_configure rvm_ruby_file rvm_ruby_gem_home rvm_ruby_gem_path rvm_ruby_global_gems_path rvm_ruby_home rvm_ruby_interpreter rvm_ruby_irbrc rvm_ruby_major_version rvm_ruby_make rvm_ruby_make_install rvm_ruby_minor_version rvm_ruby_mode rvm_ruby_name rvm_ruby_package_file rvm_ruby_package_name rvm_ruby_patch rvm_ruby_patch_level rvm_ruby_release_version rvm_ruby_repo_url rvm_ruby_revision rvm_ruby_selected_flag rvm_ruby_sha rvm_ruby_string rvm_ruby_strings rvm_ruby_tag rvm_ruby_url rvm_ruby_user_tag rvm_ruby_version rvm_script_name rvm_sdk rvm_silent_flag rvm_sticky_flag rvm_system_flag rvm_token rvm_trace_flag rvm_use_flag rvm_user_flag rvm_verbose_flag rvm_wrapper_name
}

__rvm_select_detect_ruby_string()
{
  rvm_ruby_string="${1:-${rvm_ruby_string:-}}"
  if
    [[ -z "${rvm_ruby_string:-}" ]]
  then
    rvm_ruby_string="${rvm_ruby_interpreter:-}"
    rvm_ruby_string="${rvm_ruby_string:-}${rvm_ruby_version:+-}${rvm_ruby_version:-}"
    rvm_ruby_string="${rvm_ruby_string:-}${rvm_ruby_patch_level:+-}${rvm_ruby_patch_level:-}"
    rvm_ruby_string="${rvm_ruby_string:-}${rvm_ruby_revision:+-}${rvm_ruby_revision:-}"
    if [[ -n "${rvm_ruby_name:-}" ]]
    then rvm_ruby_name="$rvm_ruby_string-$rvm_ruby_name"
    fi
  fi
}

__rvm_select_interpreter_variables()
{
  rvm_archive_extension="tar.gz"

  if [[ -z "${rvm_ruby_interpreter:-}" ]]
  then rvm_ruby_interpreter="${rvm_ruby_string//-*/}"
  fi

  rvm_ruby_interpreter="${rvm_ruby_interpreter:-missing}"

  if
    is_a_function __rvm_select_interpreter_${rvm_ruby_interpreter}
  then
    __rvm_select_interpreter_${rvm_ruby_interpreter} || return $?
  elif
    [[ -n "${MY_RUBY_HOME:-""}" ]]
  then
    __rvm_select $(basename $MY_RUBY_HOME) || return $?
  elif
    [[ -z "${rvm_ruby_string:-""}" ]]
  then
    rvm_error "Ruby implementation '$rvm_ruby_interpreter' is not known."
    return 1
  fi
}

__rvm_select_version_variables()
{
  case "$rvm_ruby_version" in
    (+([0-9]).+([0-9]).+([0-9]))
      rvm_ruby_release_version="${rvm_ruby_version/.*/}"
      rvm_ruby_major_version=${rvm_ruby_version%.*}
      rvm_ruby_major_version=${rvm_ruby_major_version#*.}
      rvm_ruby_minor_version="${rvm_ruby_version//*.}"
      ;;
    (+([0-9]).+([0-9]))
      rvm_ruby_release_version="${rvm_ruby_version/.*/}"
      rvm_ruby_major_version="${rvm_ruby_version#*.}"
      rvm_ruby_minor_version=""
      ;;
  esac
}

__rvm_select_default_variables()
{
  if [[ "${rvm_ruby_interpreter}" != ext ]]
  then rvm_ruby_package_name="${rvm_ruby_package_name:-${rvm_ruby_string//-n*}}"
  fi

  rvm_ruby_home="$rvm_rubies_path/$rvm_ruby_string"
  rvm_ruby_binary="$rvm_ruby_home/bin/ruby"
  rvm_ruby_irbrc="$rvm_ruby_home/.irbrc"
}

# __rvm_select implementation-version-patch_level
__rvm_select()
{
  true ${rvm_gemset_name:=}
  typeset _original_env_string
  _original_env_string=${rvm_env_string}

  __rvm_select_set_variable_defaults   &&
  __rvm_select_detect_ruby_string "$1" &&
  __rvm_ruby_string                    &&
  __rvm_select_interpreter_variables   &&
  __rvm_select_version_variables       &&
  __rvm_select_default_variables       ||
  return $?

  [[ "system" == "$rvm_ruby_interpreter" ]] ||
  {
    __rvm_gemset_select ||
    case $? in
      2) true      ;;
      *) return $? ;;
    esac
  }

  rvm_ruby_selected_flag=1
}

__rvm_use_system() {

  unset GEM_HOME GEM_PATH MY_RUBY_HOME RUBY_VERSION IRBRC

  new_path="$(__rvm_remove_rvm_from_path ; printf "%b" "$PATH"):${rvm_bin_path}"

  if
    [[ -s "$rvm_path/config/system" ]]
  then
    if
      __rvm_grep "MY_RUBY_HOME='$rvm_rubies_path" "$rvm_path/config/system" > /dev/null
    then
      # 'system' should *not* point to an rvm ruby.
      if [[ -f "$rvm_path/config/system" ]]
      then \rm -f "$rvm_path/config/system"
      fi
    else
      source "$rvm_path/config/system"
    fi
  fi

  if
    (( ${rvm_default_flag:=0} == 1 ))
  then
    "$rvm_scripts_path/alias" delete default &> /dev/null
    __rvm_find "${rvm_bin_path}" -maxdepth 0 -name 'default_*' -delete
    \rm -f "$rvm_path/config/default"
    \rm -f "$rvm_environments_path/default"
    __rvm_rm_rf "$rvm_wrappers_path/default"
  fi

  if (( ${rvm_verbose_flag:=0} == 1 ))
  then rvm_log "Now using system ruby."
  fi

  __rvm_remove_rvm_from_path
  new_path="$PATH:${rvm_bin_path}"
  export rvm_ruby_string="system"
}

__rvm_use()
{
  typeset new_path binary full_binary_path rvm_ruby_gem_home

  __rvm_select "$@" || return $?

  if
    [[ "system" == ${rvm_ruby_interpreter:="system"} ]]
  then
    __rvm_use_system
  else
    if
      [[ ! -d "$rvm_ruby_home" ]]
    then
      if
        [[ ${rvm_install_on_use_flag:-0} -eq 1 ]]
      then
        rvm_warn "$rvm_ruby_string is not installed."
        __rvm_run_wrapper manage "install" "$rvm_ruby_string"
      else
        rvm_error "$rvm_ruby_string is not installed."
        rvm_log "To install do: 'rvm install $rvm_ruby_string'"
        export rvm_recommended_ruby="rvm install $rvm_ruby_string"
        return 1
      fi
    fi

    if
      [[ ! -d "$rvm_ruby_gem_home" || -n "${rvm_expected_gemset_name}" ]]
    then
      if (( ${rvm_gemset_create_on_use_flag:=0} == 1 || ${rvm_create_flag:=0} == 1 ))
      then
        rvm_warn "gemset $rvm_gemset_name is not existing, creating."
        "$rvm_scripts_path/gemsets" create "$rvm_gemset_name"
      else
        rvm_error "Gemset '${rvm_expected_gemset_name}' does not exist, 'rvm $rvm_ruby_string do rvm gemset create ${rvm_expected_gemset_name}' first, or append '--create'."
        return 2
      fi
    fi

    export GEM_HOME GEM_PATH MY_RUBY_HOME RUBY_VERSION IRBRC
    GEM_HOME="$rvm_ruby_gem_home"
    GEM_PATH="$rvm_ruby_gem_path"
    MY_RUBY_HOME="$rvm_ruby_home"
    RUBY_VERSION="$rvm_ruby_string"
    IRBRC="$rvm_ruby_irbrc"
    unset BUNDLE_PATH # Ensure that BUNDLE_PATH is not set!

    # Handle MagLev pre-installed gems
    if [[ "maglev" == "$rvm_ruby_interpreter" ]]
    then GEM_PATH="$GEM_PATH:$MAGLEV_HOME/lib/maglev/gems/1.8/"
    fi

    [[ -n "${IRBRC:-}" ]] || unset IRBRC

    # Ensure the environment file for the selected ruby exists.
    __rvm_ensure_has_environment_files

    if
      (( ${rvm_use_flag:-1} >= 2 )) ||
      (( ${rvm_use_flag:-1} == 1 && ${rvm_verbose_flag:-0} == 1 ))
    then
      rvm_log "Using ${GEM_HOME/${rvm_gemset_separator:-'@'}/ with gemset }"
    fi

    if [[ "$GEM_HOME" != "$rvm_ruby_global_gems_path" ]]
    then new_path="$GEM_HOME/bin:$rvm_ruby_global_gems_path/bin:${rvm_ruby_binary%/*}:${rvm_bin_path}:$(__rvm_remove_rvm_from_path ;printf "%b" "$PATH")"
    else new_path="$GEM_HOME/bin:${rvm_ruby_binary%/*}:${rvm_bin_path}:$(__rvm_remove_rvm_from_path ;printf "%b" "$PATH")"
    fi
  fi

  [[ -z "${rvm_ruby_string:-}" ]] || export rvm_ruby_string
  [[ -z "${rvm_gemset_name:-}" ]] || export rvm_gemset_name

  if
    [[ -n "$new_path" ]]
  then
    export PATH="$new_path"
    unset new_path
    builtin hash -r
  fi

  if
    [[ "$rvm_ruby_string" != "system" ]]
  then
    case "${rvm_rvmrc_flag:-0}" in
      (rvmrc|versions_conf|ruby_version) __rvm_set_${rvm_rvmrc_flag} ;;
    esac

    typeset environment_id
    environment_id="$(__rvm_env_string)"
    if
      (( ${rvm_default_flag:=0} == 1 )) &&
      [[ "default" != "${rvm_ruby_interpreter:-}" ]] &&
      [[ "system"  != "${rvm_ruby_interpreter:-}" ]]
    then
      # Switch the default alias to the new environment id
      "$rvm_scripts_path/alias" delete default &> /dev/null
      "$rvm_scripts_path/alias" create default "$environment_id" >& /dev/null
    fi
    rvm_default_flag=0
    if
      [[ -n "${rvm_wrapper_name:-}" ]]
    then
      "$rvm_scripts_path/wrapper" "$environment_id" "$rvm_wrapper_name" > /dev/null 2>&1
      rvm_wrapper_name=""
    fi
    if
      [[ -n "${rvm_ruby_alias:-}" ]]
    then
      rvm_log "Attempting to alias $environment_id to $rvm_ruby_alias"
      "$rvm_scripts_path/alias" delete "$rvm_ruby_alias" > /dev/null 2>&1
      rvm_alias_expanded=1 "$rvm_scripts_path/alias" create "$rvm_ruby_alias" "$environment_id" > /dev/null 2>&1
      ruby_alias="" ; rvm_ruby_alias=""
    fi
  else
    if
      (( ${rvm_default_flag:=0} == 1 ))
    then
      builtin command -v __rvm_reset >> /dev/null 2>&1 || source "$rvm_scripts_path/functions/reset"
      __rvm_reset
    fi
  fi
  rvm_hook="after_use"
  source "$rvm_scripts_path/hook"
  return 0
}

__rvm_ruby_string()
{
  # rvm_ruby_string may designate any of the following items:
  # * rvm_gemset_name
  # * rvm_ruby_interpreter
  # * rvm_ruby_version
  # * rvm_ruby_patch_level
  # * rvm_ruby_revision
  # * rvm_ruby_tag

  true ${rvm_head_flag:=0} ${rvm_delete_flag:=0}
  rvm_expanding_aliases=''
  true \
    "${rvm_ruby_version:=}" "${rvm_gemset_name:=}" "${rvm_ruby_interpreter:=}"\
    "${rvm_ruby_version:=}" "${rvm_ruby_tag:=}" "${rvm_ruby_patch_level:=}"\
    "${rvm_ruby_revision:=}" ${rvm_gemset_separator:="@"} "${rvm_ruby_string:=}"\
    ${rvm_expanding_aliases:=0} ${rvm_head_flag:=0}

  if
    [[ "$rvm_ruby_string" == *"${rvm_gemset_separator}"* ]]
  then
    rvm_gemset_name="${rvm_ruby_string/*${rvm_gemset_separator}/}"
    rvm_ruby_string="${rvm_ruby_string/${rvm_gemset_separator}*/}"
  fi
  # Alias'd rubies
  if
    (( rvm_expanding_aliases == 0 )) &&
    [[ -n "${rvm_ruby_string}" && "$rvm_ruby_string" != "system" ]]
  then
    if
      [[ -f "$rvm_path/config/alias" && -s "$rvm_path/config/alias" ]] &&
      expanded_alias_name="$(__rvm_db_ "$rvm_path/config/alias" "$rvm_ruby_string")" &&
      [[ -n "$expanded_alias_name" ]]
    then
      rvm_ruby_string="$expanded_alias_name"
    elif
      [[ "$rvm_ruby_string" == default ]]
    then
      # Default is not a known value. Instead, we need to therefore set it to system.
      rvm_ruby_string="system"
    fi
    if
      [[ "$rvm_ruby_string" == *"${rvm_gemset_separator}"* ]]
    then
      rvm_gemset_name="${rvm_ruby_string/*${rvm_gemset_separator}/}"
      rvm_ruby_string="${rvm_ruby_string/${rvm_gemset_separator}*/}"
    fi
  fi
  if
    [[ -n "$gemset_name" ]]
  then
    rvm_gemset_name="$gemset_name"
    rvm_sticky_flag=1 # <- not sold on this.
  fi

  __rvm_ruby_string_parse || return $?

  if
    [[ -z "${rvm_ruby_version:-}" && "${rvm_ruby_interpreter}" != "ext" ]] &&
    (( ${rvm_head_flag:=0} == 0 ))
  then
    if
      (( ${rvm_fuzzy_flag:-0} == 1 ))
    then
      rvm_ruby_version="$(
        "${rvm_scripts_path:-$rvm_path/scripts}/list" strings |
          __rvm_grep "^${rvm_ruby_interpreter}-.*${rvm_ruby_name:-}" |
          __rvm_awk -F- '{print $2}' | sort | __rvm_tail -n 1
      )"
    fi
    rvm_ruby_version="${rvm_ruby_version:-"$(
      __rvm_db "${rvm_ruby_interpreter}_version"
    )"}"
  fi
  rvm_ruby_string="${rvm_ruby_interpreter}${rvm_ruby_version:+-}${rvm_ruby_version:-}"
  if
    [[ "${rvm_ruby_interpreter}" == "ext" ]]
  then
    true # skip checking for external rubies
  elif
    [[ "${rvm_head_flag:=0}" == "1" || -n "${rvm_ruby_sha:-}" || -n "${rvm_ruby_tag:-}" ]]
  then
    if [[ "${rvm_head_flag:=0}" == "1" ]]
    then rvm_ruby_string="${rvm_ruby_string}-head"
    fi
    if [[ -n "${rvm_ruby_sha:-}" ]]
    then rvm_ruby_string="${rvm_ruby_string}-s${rvm_ruby_sha}"
    elif [[ -n "${rvm_ruby_tag:-}" ]]
    then rvm_ruby_string="${rvm_ruby_string}-${rvm_ruby_tag}"
    fi
    if
      [[ ! -d "${rvm_rubies_path}/${rvm_ruby_string}" ]] &&
      (( ${rvm_fuzzy_flag:-0} == 1 ))
    then
      typeset new_ruby_string
      new_ruby_string="$(
        "${rvm_scripts_path:-$rvm_path/scripts}/list" strings |
          __rvm_grep "^${rvm_ruby_string}.*${rvm_ruby_name:-}" |
          sort | __rvm_tail -n 1
      )"
      rvm_ruby_string="${new_ruby_string:-$rvm_ruby_string}"
    fi
  elif
    [[ -n "${rvm_ruby_revision:-}" ]]
  then
    rvm_ruby_string="${rvm_ruby_string}-${rvm_ruby_revision}"
  elif
    [[ -n "${rvm_ruby_patch_level:-}" ]]
  then
    rvm_ruby_string="${rvm_ruby_string}-${rvm_ruby_patch_level}"
  elif
    [[ -n "${rvm_ruby_user_tag:-}" ]]
  then
    rvm_ruby_string="${rvm_ruby_string}-${rvm_ruby_user_tag}"
  else
    if
      (( ${rvm_fuzzy_flag:-0} == 1 )) &&
      [[ "${rvm_ruby_interpreter}" == "ruby" || "${rvm_ruby_interpreter}" == "ree" ]]
    then
      rvm_ruby_patch_level="$(
        "${rvm_scripts_path:-$rvm_path/scripts}/list" strings |
          __rvm_grep "^${rvm_ruby_interpreter}-${rvm_ruby_version}-.*${rvm_ruby_name:-}" |
          __rvm_awk -F- '{print $3}' | sort | __rvm_tail -n 1
      )"
    fi
    if
      (( ${rvm_latest_binary_flag:-0} == 1 )) &&
      [[ "${rvm_ruby_interpreter}" == "ruby" || "${rvm_ruby_interpreter}" == "ree" ]]
    then
      #TODO: MRI only implementation, we need a better db/format/handling for this
      rvm_ruby_patch_level="$(
        __list_remote_rubies_for $( __rvm_system_path_for rubies ) |
          __rvm_awk -F/ '{x=$NF; gsub(".tar.*","",x); print x}' |
          __rvm_grep "${rvm_ruby_interpreter}-${rvm_ruby_version}-" |
          __rvm_awk -F- '{print $3}' | sort | __rvm_tail -n 1
      )"
    fi
    [[ -n "${rvm_ruby_patch_level:-""}" ]] ||
    rvm_ruby_patch_level="$(
      __rvm_db "${rvm_ruby_interpreter}_${rvm_ruby_version}_patch_level"
    )"
    if [[ -n "${rvm_ruby_patch_level:-""}" ]]
    then rvm_ruby_string="${rvm_ruby_string}-${rvm_ruby_patch_level}"
    fi
  fi
  if
    [[ -n "${rvm_ruby_name:-}" ]]
  then
    rvm_ruby_string="${rvm_ruby_string}-${rvm_ruby_name}"
    # record the name for validation of -n option
    detected_rvm_ruby_name="${rvm_ruby_name}"
    # clean the name so it is not added again (rbx -n install problem)
    rvm_ruby_name=""
  else
    # record the no name for validation of -n option
    detected_rvm_ruby_name=""
  fi
  true # OSX --trace FIX
}

__rvm_ruby_strings_exist()
{
  for rvm_ruby_string in ${@//,/ }
  do
    rvm_gemset_name=""
    rvm_verbose_flag=0 __rvm_use "${rvm_ruby_string}" >/dev/null 2>&1 || return $?
    printf "%b" "${rvm_ruby_string}${rvm_gemset_name:+@}${rvm_gemset_name:-}\n"
  done
  unset rvm_ruby_string
}
