cli

#!/usr/bin/env bash

__rvm_usage() { ${PAGER:-less} "${rvm_path:-$HOME/.rvm}/README" ; }

__rvm_run_script() {
  local rvm_script_name="${1:-"$rvm_action"}"
  eval "$rvm_scripts_path/$rvm_script_name $rvm_ruby_args"
  return $?
}

__rvm_parse_args() {
  # TODO:
  #       Make this more robust '__rvm_history' so that it stores *unique* rvm commands.
  #       Otherwise this file gets big rather fast.
  #echo "$@" >> $HOME/.rvm_history

  if echo "$@" | \grep -q 'trace' ; then echo "$@" ; __rvm_version ; fi

  rvm_action="${rvm_action:-""}"
  export rvm_ruby_string="${rvm_ruby_string:-""}"

  local rvm_parse_break=0
  local rvm_error_message=""

  while [[ $# -gt 0 ]] ; do
    rvm_token="$next_token" ; shift

    if [[ $# -gt 0 ]] ; then next_token="$1" ; else next_token="" ; fi

    case "$rvm_token" in
      fetch|version|srcdir|reset|debug|reload|update|monitor|notes|implode|seppuku|question|answer|env)
        rvm_action=$rvm_token
      ;;

      package)
        rvm_action="$rvm_token"
        if [[ "$next_token" = "--only-path" ]]; then
          shift; rvm_only_path_flag=1
        fi
        rvm_ruby_args="$*"
        rvm_parse_break=1
      ;;

      use)
        rvm_action="$rvm_token"
        rvm_verbose_flag=1
        if [[ "ruby" = "$next_token" ]] ; then shift ; fi
      ;;

      install|uninstall)
        export ${rvm_token}_flag=1
        rvm_action=$rvm_token
        export rvm_install_arguments="$(__rvm_quote_args_with_shift 1 "$@")"
      ;;

      rm|remove)
        rvm_action="remove"
        rvm_remove_flag=1
      ;;

      # Can likely remove this due to the *) case
      jruby*|ree*|macruby*|rbx*|rubinius*|mput*|shyouhei*|ironruby*|default*|maglev*|all)
        if [[ "rubinius" = "$rvm_token" ]] ; then rvm_token="rbx"; fi
        rvm_ruby_interpreter="$rvm_token"
        rvm_ruby_string="$rvm_token"
        rvm_ruby_strings="$rvm_token"
        rvm_action="${rvm_action:-use}"
        if "$rvm_scripts_path"/match "$next_token" "^[0-9]\.[0-9]" ; then rvm_ruby_version=$next_token ; shift ; fi
      ;;

      gemset)
        rvm_action=$rvm_token

        rvm_ruby_gem_home="$GEM_HOME"

        if [[ -z "$next_token" ]] ; then
          rvm_ruby_args="help"

        elif [[ "clear" = "$next_token" ]] ; then
          __rvm_gemset_clear
          rvm_ruby_args="clear"

        elif [[ "use" = "$next_token" ]] ; then
          rvm_use_flag=1
          rvm_ruby_args="$@"
          rvm_gemset_name="$next_token"
          shift # Clear next_token

          if [[ $# -gt 0 ]] ; then rvm_gemset_name="$1" ; else rvm_gemset_name="" ; fi

          if echo $rvm_gemset_name | \grep -q $rvm_gemset_separator ; then
            rvm_ruby_string=$(echo $rvm_gemset_name | sed -e 's/\(.*\)'${rvm_gemset_separator}'.*/\1/')
            rvm_gemset_name=$(echo $rvm_gemset_name | sed -e 's/.*'${rvm_gemset_separator}'\(.*\)/\1/')

            if [[ "${rvm_ruby_string:-""}" != "${rvm_gemset_name:-""}" ]] ; then
              rvm_ruby_string="$rvm_ruby_string${rvm_gemset_separator}$rvm_gemset_name"
            fi

            rvm_ruby_gem_home="$rvm_ruby_gem_home${rvm_gemset_separator}$rvm_gemset_name"
          fi

        elif [[ "delete" = "$next_token" ]] ; then
          rvm_delete_flag=1
          rvm_ruby_args="$@" ; shift
          rvm_gemset_name="$next_token"; shift
          if echo "$rvm_gemset_name" | \grep -q "$rvm_gemset_separator" ; then
            rvm_ruby_string=$(echo "$rvm_gemset_name" | sed 's/\(.*\)'${rvm_gemset_separator}'.*/\1/')
            rvm_gemset_name=$(echo "$rvm_gemset_name" | sed 's/.*'${rvm_gemset_separator}'\(.*\)/\1/')
            if [[ "$rvm_ruby_string" != "$rvm_gemset_name" ]] ; then
              rvm_ruby_string="$rvm_ruby_string${rvm_gemset_separator}$rvm_gemset_name"
            fi
            rvm_ruby_gem_home="$rvm_ruby_gem_home${rvm_gemset_separator}$rvm_gemset_name"
          fi

        else
          rvm_gemset_name="${rvm_gemset_name:-""}"
          if [[ "$rvm_ruby_string" != "$rvm_gemset_name" ]] ; then __rvm_ruby_string ;  fi
          rvm_ruby_args="$@"
        fi
        rvm_parse_break=1
      ;;

      gemdir|gempath|gemhome)
        rvm_action=$rvm_token
        rvm_gemdir_flag=1
        if [[ "system" = "$next_token" ]] ; then rvm_system_flag=1 ; shift ; fi
        if [[ "user" = "$next_token" ]]   ; then rvm_user_flag=1  ;  shift ; fi
      ;;

      inspect|list|info|strings)
        rvm_action="$rvm_token"
        rvm_ruby_args="$@"
        rvm_parse_break=1
      ;;

      -S)
        rvm_action="ruby"
        rvm_ruby_args="$rvm_token $(__rvm_quote_args "$@")"
        rvm_parse_break=1
      ;;

      -e)
        rvm_action="ruby"
        rvm_ruby_args="$rvm_token $(__rvm_quote_args "$@")"
        rvm_parse_break=1
      ;;

      docs|alias|rubygems|exec|cleanup|tools|disk-usage|snapshot|repair|migrate|upgrade)
        rvm_action="$rvm_token"
        rvm_ruby_args="$(__rvm_quote_args "$@")"
        rvm_parse_break=1
      ;;

      load-rvmrc)
        rvm_action="rvmrc"
        rvm_ruby_args="'load' $(__rvm_quote_args "$@")"
        rvm_parse_break=1
      ;;

      rvmrc)
        rvm_action="rvmrc"
        rvm_ruby_args="$(__rvm_quote_args "$@")"
        rvm_parse_break=1
      ;;

      do|ruby|rake|gem|rubydo|rakedo|gemdo)
        if [[ "do" = "${rvm_action:-""}" ]] ; then rvm_action="ruby" ; fi

        rvm_action=${rvm_token//do}

        if [[ "rake" = "${rvm_action:-""}" || "gem" = "${rvm_action:-""}" || "ruby" = "${rvm_action:-""}" ]] ; then

          if [[ -z "$next_token" ]] ; then

            if [[ "gem" = "${rvm_action:-""}" ]]  ; then
              rvm_action="error"
              rvm_error_message="'rvm $rvm_action' must be followed by arguments."
            elif [[ "ruby" = "${rvm_action:-""}" ]] ; then
              if echo "${rvm_ruby_strings:-""}" | \grep -q ',' ; then
                rvm_action="ruby"
                rvm_ruby_args=""
              else
                rvm_action="error"
                rvm_error_message="rvm X,Y,Z '$rvm_action' must be followed by arguments."
              fi
            fi

          elif [[ "-S" = "$next_token" ]]  ; then
            rvm_action="ruby"
            rvm_ruby_args="$flag $(__rvm_quote_args "$@")"
            rvm_parse_break=1

          elif [[ "-e" = "$next_token" ]] ; then
            rvm_action="ruby"
            rvm_ruby_args="$flag $(__rvm_quote_args "$@")"
            rvm_parse_break=1

          else
            rvm_ruby_args="$(__rvm_quote_args "$@")"
            rvm_parse_break=1
          fi
        else
          if "$rvm_scripts_path"/match "$next_token" "^-" ; then
            unset rvm_ruby_strings

          else
            if "$rvm_scripts_path"/match "$next_token" "^[0-9]" ; then
              rvm_ruby_strings="${1//,/ }" ; shift
              unset rvm_ruby_interpreter

            else
              if [[ "ruby rbx jruby macruby ree rubinius maglev mput shyouhei ironruby" =~ $next_token ]] ; then
                rvm_ruby_strings=$next_token
                rvm_ruby_interpreter=$next_token
                shift
              else
                unset rvm_ruby_interpreter rvm_ruby_strings
              fi
            fi
          fi
        fi
      ;;

      benchmark|bench)
        rvm_action="benchmark"
      ;;

      specs|tests)
        rvm_action="rake"
        rvm_ruby_args="$(echo $rvm_token | sed -e 's/s$//')"
      ;;

      -v|--version)
        if [[ -z "$next_token" ]] ; then
          rvm_action="version"
        else
          rvm_ruby_version="$next_token"
          shift
        fi
      ;;

      --repository|--repo|--url)
        rvm_ruby_repo_url=$rvm_token
      ;;

      --ree-options)
        if [[ ! -z "$next_token" ]] ; then
          export rvm_ree_options="${1//,/ }" ; shift
        else
          rvm_action="error"
          rvm_error_message="--ree-options *must* be followed by... well... options."
        fi
      ;;

      --patches|--patch)
        rvm_patch_names="$next_token ${rvm_patch_names:-""}"; shift
        rvm_patch_original_pwd="$PWD"
      ;;

      --head) rvm_head_flag=1 ;;

      --bin)
        if [[ "update" = "${rvm_action:-""}" ]] ; then
          rvm_bin_flag=1
        else
          rvm_bin_path="$next_token" ; shift
        fi
        ;;

      -r|--require)
        if [[ -z "$next_token" ]] ; then
          rvm_action="error"
          rvm_error_message="-r|--require *must* be followed by a library name."
        else
          rvm_ruby_require="$rvm_ruby_require -r$next_token"
          shift
        fi
      ;;

      --rdoc|--yard)
        rvm_docs_type="$rvm_token"
        rvm_docs_type
      ;;

      -f|--file)
        rvm_action="ruby"
        rvm_ruby_file="$next_token"
        shift
      ;;

      system|default)
        rvm_action=${rvm_action:-use}
        rvm_ruby_interpreter="$rvm_token"
        rvm_ruby_string="$rvm_token"
        rvm_ruby_strings="$rvm_token"
      ;;

      help)
        rvm_action="$rvm_token"
        rvm_ruby_args="$@"
        rvm_parse_break=1
      ;;

      --passenger|--editor)
        rvm_wrapper_name="${rvm_token/--/}"
      ;;

      --alias)
        if [[ -n "$next_token" ]]; then
          rvm_ruby_aliases="$(echo "${rvm_ruby_aliases//,/ } ${1//,/ }" | __rvm_strip)"
          shift
        fi
      ;;

      --symlink)
        "$rvm_scripts_path/log" "warn" "--symlink has been removed, please see 'rvm wrapper'."
        shift
      ;;

      wrapper)
        rvm_action="$rvm_token"
        rvm_ruby_string="$next_token" ;
        [[ -n "$next_token" ]] && shift
        rvm_wrapper_name="$next_token"
        [[ -n "$next_token" ]] && shift
        rvm_ruby_args="$@" # list of binaries, or none
        rvm_parse_break=1
      ;;

      -G)                   path_variable="rvm_gems_path"     ; __rvm_set_path_variable "$next_token"; shift  ;;
      --source)             path_variable="rvm_src_path"      ; __rvm_set_path_variable "$next_token"; shift  ;;
      --archives)           path_variable="rvm_archives_path" ; __rvm_set_path_variable "$next_token"; shift  ;;
      -h|--help|usage)      rvm_action=help                      ;;
      --make)               rvm_ruby_make="$next_token"         ; shift   ;;
      --make-install)       rvm_ruby_make_install="$next_token" ; shift   ;;
      --nice)               rvm_niceness="$next_token"          ; shift   ;;
      -l|--level)           rvm_ruby_patch_level="p$next_token" ; shift   ;;
      # TODO: handle this below better (if $next_token is null)
      --sdk)                rvm_sdk="$next_token"               ; shift   ;;
      --archflags)          rvm_archflags="$next_token"         ; shift   ;;
      --install)            rvm_install_on_use_flag=1            ;;
      --trace)
          rvm_trace_flag=1
          if [[ -z "${ZSH_VERSION:-""}" ]] ; then
            local option="" ;
            for option in verbose xtrace errexit errtrace noclobber nounset pipefail ; do
              set -o $option
            done
            export PS4='+(${BASH_SOURCE}:${LINENO}): ${FUNCNAME[0]:+${FUNCNAME[0]}(): }'
          else
            set -x
          fi
        ;;
      --debug)
          rvm_debug_flag=1
          local option="" ;
          for option in verbose errtrace ; do
            set -o $option
          done
      ;;
      -q|--quiet)           rvm_quiet_flag=1                     ;;
      -s|--silent)          rvm_silent_flag=1                    ;;
      --proxy)              rvm_proxy="$next_token"      ; shift          ;;
      --disable-llvm|--disable-jit) rvm_llvm_flag=0              ;;
      --enable-llvm|--enable-jit)   rvm_llvm_flag=1              ;;

      reboot|damnit|wtf|argh|BOOM|boom|wth) $rvm_action="reboot" ;;

      --self|--gem|--rubygems|--reconfigure|--default|--force|--export|--summary|--latest|--yaml|--json|--archive|--shebang|--env|--path|--tail|--delete|--verbose|--import|--rvmrc|--sticky|--create|--gems|--docs)
        export "rvm_${rvm_token//-/}_flag"=1
      ;;

      --dump-environment)
        export rvm_dump_environment_flag="$next_token"; shift
      ;;

      --clang)
        export rvm_clang_flag=1
        export rvm_prior_cc="$CC"
        export CC="clang"
      ;;

      -j)
        if [[ ! -z "$next_token" ]] ; then
          rvm_make_flags="$rvm_make_flags -j$next_token"
          shift
        else
          rvm_action="error"
          rvm_error_message="-j *must* be followed by an integer (normally the # of CPU's in your machine)."
        fi
      ;;

      --with-rubies)
        rvm_ruby_strings="$next_token"
        shift
      ;;

      -C|--configure)
        if [[ ! -z "$next_token" ]] ; then
          rvm_ruby_configure_flags="$(echo $next_token | sed -e 's#,--# --#g')"
          shift
        else
          rvm_action="error"
          rvm_error_message="--configure *must* be followed by configure flags."
        fi
      ;;

      --with-*)    rvm_ruby_configure_flags="$rvm_ruby_configure_flags $rvm_token" ;;
      --without-*) rvm_ruby_configure_flags="$rvm_ruby_configure_flags $rvm_token" ;;
      --enable-*)  rvm_ruby_configure_flags="$rvm_ruby_configure_flags $rvm_token" ;;
      --disable-*) rvm_ruby_configure_flags="$rvm_ruby_configure_flags $rvm_token" ;;

      -I|--include)
        if [[ -z "$next_token" ]] ; then
          rvm_action="error"
          rvm_error_message="-I|--include *must* be followed by a path."
        else
          rvm_ruby_load_path="$rvm_ruby_load_path:$next_token"
          shift
        fi
      ;;

      --) rvm_ruby_args="$*" ; rvm_parse_break=1                ;;

      *)
        if [[ -n "$rvm_token" ]] ; then
          if [[ "gemset" = "$rvm_action" ]] ; then
            if "$rvm_scripts_path/match" "$rvm_token" "^.+${rvm_gemset_separator}.+$" ; then
              rvm_gemset_name="${rvm_token/*${rvm_gemset_separator}/}"
              rvm_ruby_string="${rvm_token/${rvm_gemset_separator}*/}"

            elif echo "$rvm_token" | \grep -q '.gems$' ; then
              rvm_file_name="${rvm_token/.gems/}.gems" # Account for possible .gems.gems
              # elif [[ ! -z "$(echo "$rvm_token" | awk '/\.gems$/')" ]] ; then
            else
              rvm_gemset_name="${rvm_token/.gems/}"
              rvm_file_name="$rvm_gemset_name.gems"
            fi

          elif echo "$rvm_token" | \grep -q ',' ; then
            rvm_ruby_strings="$rvm_token"
            if [[ -z "${rvm_action:-""}" ]] ; then
              rvm_action="ruby" # Not sure if we really want to do this but we'll try it out.
            fi

          elif "$rvm_scripts_path/match" "$rvm_token" "^${rvm_gemset_separator}" ; then
            rvm_action="${rvm_action:-use}"
            rvm_gemset_name="${rvm_token/*${rvm_gemset_separator}/}"
            rvm_ruby_string="${rvm_ruby_string:-""}"
            rvm_ruby_strings="${rvm_ruby_string}${rvm_gemset_separator}${rvm_gemset_name}"

          elif "$rvm_scripts_path/match" "$rvm_token" "^.+${rvm_gemset_separator}.+$" ; then
            gemset_name="${rvm_token/*${rvm_gemset_separator}/}"
            rvm_ruby_string="$rvm_token"
            rvm_ruby_strings="$rvm_token"

          elif "$rvm_scripts_path/match" "$rvm_token" "^.+\\+.+$" ; then
            rvm_ruby_alias="${rvm_token/*+/}"
            rvm_ruby_string="${rvm_token/+*/}"
            rvm_ruby_strings="$rvm_ruby_string"

          elif "$rvm_scripts_path/match" "$rvm_token" "-" ; then
            rvm_ruby_string="$rvm_token"
            rvm_ruby_strings="$rvm_token"

          elif "$rvm_scripts_path/match" "$rvm_token" "^[0-9].[0-9]" ; then
            rvm_ruby_string="$rvm_token"
            rvm_ruby_strings="$rvm_token"
            rvm_action="${rvm_action:-use}"

          elif "$rvm_scripts_path/match" "$rvm_token" "^ree-" ; then
            rvm_ruby_string="$rvm_token"
            rvm_ruby_strings="$rvm_token"
            rvm_action="${rvm_action:-use}"

          elif [[ -L "$rvm_rubies_path/$rvm_token" ]] ; then # Alias
            rvm_ruby_string=$rvm_token
            rvm_ruby_strings="$rvm_token"
            rvm_action="${rvm_action:-use}"

          else
            if "$rvm_scripts_path/match" "$rvm_token" ".rb$" ; then # we have a specified ruby script
              rvm_ruby_args=$rvm_token
              rvm_ruby_file=$rvm_token
              if [[ -z "${rvm_action:-""}" ]] ; then rvm_action="ruby" ; fi
            else
              rvm_action="error"
              rvm_error_message="Unrecognized command line argument: '$rvm_token'"
            fi
          fi
        else
          rvm_action="error"
          rvm_error_message="Unrecognized command line argument(s): '$rvm_token $@'"
        fi

        if [[ "error" = "${rvm_action:-""}" ]] ; then
          break;
        fi
    esac

    if [[ -z "${rvm_action:-""}" && -n "${rvm_ruby_string:-""}" ]]  ; then rvm_action="use" ; fi

    if [[ ${rvm_parse_break:-0} -eq 1 || -n "${rvm_error_message:-""}" ]] ; then break ; fi
  done

  # Empty args list.
  while [[ $# -gt 0 ]] ; do shift ; done

  if [[ -n "${rvm_error_message:-""}" ]] ; then
    __rvm_pushpop
    "$rvm_scripts_path"/log "fail" "$rvm_error_message ( see: 'rvm usage' )"
    return 1
  fi

}

rvm() {
  local next_token

  __rvm_setup

  case $- in *i*) rvm_interactive_flag=1 ;;
               *) rvm_interactive_flag=0 ;;
  esac ; export rvm_interactive_flag

  if [[ -z "${ZSH_VERSION:-""}" ]] ; then
    trap '\rm -rf "$rvm_tmp_path/$$" >/dev/null 2>&1' 0 1 2 3 15
  fi

  # Check that this is the current version.
  disk_version=$(tail -n 3 < "${rvm_path:-$HOME/.rvm}/lib/VERSION.yml" | sed -e 's/^.*: //g' | \tr "\n" '.' | sed -e 's/\.$//')

  if [[ $# -gt 0 ]] ; then next_token="$1" ; else next_token="" ; fi

  if [[ "${rvm_version}" != "${disk_version}" ]] && [[ "reload" != "$next_token" ]]; then
    printf "\nA RVM version ${disk_version} is installed yet ${rvm_version} is loaded.\n Please do one of the following:\n  * 'rvm reload'\n  * open a new shell\n  * source your shell init scripts"
    return 1
  fi

  __rvm_cleanse_variables
  __rvm_load_rvmrc
  __rvm_initialize
  __rvm_parse_args "$@"

  rvm_action="${rvm_action:-usage}"

  export BUNDLE_PATH GEM_HOME GEM_PATH rvm_ruby_string rvm_action rvm_bin_flag rvm_debug_flag rvm_delete_flag rvm_docs_type rvm_file_name rvm_gemset_name rvm_head_flag rvm_install_on_use_flag rvm_interactive_flag rvm_llvm_flag rvm_make_flags rvm_proxy rvm_remove_flag rvm_ruby_args rvm_ruby_configure_flags rvm_ruby_file rvm_ruby_gem_home rvm_ruby_interpreter rvm_ruby_name rvm_ruby_version rvm_system_flag rvm_trace_flag rvm_use_flag rvm_user_flag rvm_verbose_flag rvm_patch_names rvm_patch_original_pwd rvm_clang_flag rvm_install_arguments rvm_path rvm_rubies_path rvm_scripts_path rvm_archives_path rvm_src_path rvm_patches_path rvm_patches_path rvm_patchsets_path rvm_log_path rvm_bin_path rvm_gems_path rvm_config_path rvm_tmp_path rvm_hooks_path rvm_gems_cache_path rvm_gemset_separator rvm_ruby_aliases rvm_quiet_flag rvm_silent_flag

  result=0

  case "$rvm_action" in
    use)             __rvm_use               ; result=$? ;;
    srcdir)          __rvm_source_dir        ; result=$? ;;
    strings)         __rvm_strings           ; result=$? ;;
    version)         __rvm_version           ; result=$? ;;
    reset)           __rvm_reset             ; result=$? ;;
    update)          __rvm_update            ; result=$? ;;
    reboot)          __rvm_reboot            ; result=$? ;;
    usage)           __rvm_usage             ; result=$? ;;
    benchmark)       __rvm_benchmark         ; result=$? ;;
    inspect)         __rvm_inspect           ; result=$? ;;
    implode|seppuku) __rvm_implode           ; result=$? ;;

    list)  "$rvm_scripts_path"/list $rvm_ruby_args ; result=$? ;;
    # TODO: Make debug run in the current environment.
    debug) "$rvm_scripts_path/info" '' debug ; result=$? ;;
    help)  "$rvm_scripts_path/help" $rvm_ruby_args ; result=$? ;;
    env)   "$rvm_scripts_path/env" "$rvm_ruby_string" ; result=$?  ;;
    info)
      if [[ $# -gt 0 ]] ; then next_token="$1" ; else next_token="" ; fi
      if [[ "$next_token" = "info" ]]; then shift; fi
      "$rvm_scripts_path/info" $rvm_ruby_args
      result=$?
    ;;

    answer)   __rvm_Answer_to_the_Ultimate_Question_of_Life_the_Universe_and_Everything ; result=42 ;;
    question) __rvm_ultimate_question ; result=42 ;;

    wrapper)
      "$rvm_scripts_path/wrapper" "$rvm_ruby_string" "$rvm_wrapper_name" $rvm_ruby_args
      result=$? ; unset rvm_wrapper_name
    ;;

    gemdir|gemhome|gempath)
      "$rvm_scripts_path/gemsets" "$rvm_action" ; result=$?
    ;;

    ruby|gem|rake|exec)
      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
    ;;

    cleanup|tools|snapshot|disk-usage|repair|alias|docs|rubygems|migrate|upgrade)
      __rvm_run_script "$rvm_action" ; result=$?
    ;;

    rvmrc) eval "__rvm_rvmrc_tools $rvm_ruby_args" ; result=$? ;;

    gemset)
      #if "$rvm_scripts_path/match" $rvm_ruby_args use ; then
      if [[ ${rvm_use_flag:-0} -eq 1 ]] ; then
        __rvm_gemset_select
        result=$? ; if [[ $result -eq 0 ]] ; then
          __rvm_gemset_use
        fi
      else
        export rvm_ruby_strings

        "$rvm_scripts_path/gemsets" $rvm_ruby_args ; result=$?

        rvm_ruby_strings=""

        # Clear the gemset.
        if [[ ${rvm_delete_flag:-0} -eq 1 ]] ; then
          gem_prefix="$(echo "${GEM_HOME:-""}" | sed 's/'${rvm_gemset_separator}'.*$//')"

          if [[ "${GEM_HOME:-""}" = "${gem_prefix}${rvm_gemset_separator}${rvm_gemset_name}" ]] ; then
            rvm_ruby_gem_home="$gem_prefix"
            GEM_HOME="$rvm_ruby_gem_home"
            BUNDLE_PATH="$rvm_ruby_gem_home"
            GEM_PATH="$rvm_ruby_gem_home/bin:$rvm_ruby_gem_home${rvm_gemset_separator}global/bin"
            export rvm_ruby_gem_home GEM_HOME BUNDLE_PATH GEM_PATH
          fi ; unset gem_prefix
        fi
      fi
      result=$?
    ;;

    monitor)
      export rvm_ruby_strings rvm_ruby_string
      "$rvm_scripts_path"/monitor ; result=$?
    ;;

    notes)       "$rvm_scripts_path/notes"   ; result=$?  ;;
    reload)      rvm_loaded_flag=0 ; rvm_reload_flag=1    ;;
    tests|specs) rvm_action="rake" ; __rvm_do ; result=$? ;;
    package)     "$rvm_scripts_path/package" $rvm_ruby_args ; result=$?  ;;

    fetch|install|uninstall|remove)
      if [[ -n "$rvm_ruby_strings" ]]; then
        "$rvm_scripts_path"/manage "$rvm_action" "$rvm_ruby_strings"
      else
        "$rvm_scripts_path"/manage "$rvm_action"
      fi
      result=$?
    ;;

    error)
      __rvm_pushpop
      result=1
    ;;

    *)
      if [[ -n "${rvm_action:-""}" ]] ; then
        "$rvm_scripts_path/log" "fail"  "unknown action '$rvm_action'"
      else
        __rvm_usage
      fi
      result=1
  esac

  if [[ ${rvm_reload_flag:-0} -eq 1 ]] ; then
    source "$rvm_scripts_path/rvm"
    # Note: Not using builtin on purpose. Done so we can trigger a reload the rvmrc.
    __rvm_project_rvmrc
  fi

  __rvm_teardown

  if [[ ${rvm_trace_flag:-0} -eq 1 ]] ; then
    set +x
    rvm_trace_flag=0
  fi

  return $result
}