#!/usr/bin/env bash

original_ruby_version=$rvm_ruby_version
original_ruby_string=$rvm_ruby_string

source "$rvm_scripts_path/base"
source "$rvm_scripts_path/patches"

__rvm_check_for_clang() {
  if [[ -n "$rvm_clang_flag" ]] && ! command -v clang >/dev/null ; then
    $rvm_scripts_path/log "fail" "You passed the --clang option and clang isn't in your path. Please try again / don't use --clang"
    return 1
  fi
}

# Checks for bison, returns zero iff it is found
__rvm_check_for_bison() {
  if [[ "$rvm_head_flag" -gt 0 ]]; then
    if ! command -v bison >/dev/null ; then
      $rvm_scripts_path/log "fail" "bison is not available in your path. Please ensure it exists before compiling from head."
      return 1
    fi
  fi
}

# Returns a number of patches, each on a new name
# Expands patchsets etc.
__rvm_current_patch_names() {
  # TODO: Lookup default patches on rvm_ruby_string heirarchy.
  local patches="$rvm_patch_names default"
  for patch_name in $(echo "$patches" | \tr ',' ' ' | __rvm_strip); do
    __rvm_expand_patch_name "$patch_name"
  done
}

__rvm_apply_patches() {
  local patch_result=0
  local patch_level_seperator="%"
  local patch_fuzziness="25"
  source_directory="${1:-"$rvm_ruby_src_path"}"
  __rvm_pushpop "$source_directory"
  unset source_directory
  for patch_name in $(__rvm_current_patch_names | __rvm_strip); do
    patch_level="1"
    # If set, extract the patch level from the patch name.
    if echo "$patch_name" | \grep -q "$patch_level_seperator"; then
      patch_level="$(echo "$patch_name" | awk -F"$patch_level_seperator" '{print $2}')"
      patch_name="$(echo "$patch_name" | awk -F"$patch_level_seperator" '{print $1}')"
    fi
    full_patch_path="$(__rvm_lookup_full_patch_path "$patch_name")"
    # Expand paths, and for those we found we then apply the patches.
    if [[ -n "$full_patch_path" ]]; then
      __rvm_run "patch.apply.$(basename "$patch_name")" "patch -F$patch_fuzziness -p$patch_level -f < '$full_patch_path'" "Applying patch '$patch_name' (located at $full_patch_path)"
      # Detect failed patches
      [[ "$?" -gt 0 ]] && patch_result=1
    else
      $rvm_scripts_path/log "warn" "Patch '$patch_name' not found."
      patch_result=1
    fi
  done; unset patch_name full_patch_path patch_level
  __rvm_pushpop
  return $patch_result
}

__rvm_install_source() {
  [[ -z "$rvm_ruby_selected_flag" ]] && __rvm_select

  if [[ "$rvm_ruby_string" = "ruby-1.9.2-head" ]] ; then
    # Ensure we have a base ruby.
    __rvm_ensure_has_18_compat_ruby || return 1
  fi

  $rvm_scripts_path/log "info" "Installing Ruby from source to: $rvm_ruby_home"
  __rvm_pushpop "$rvm_src_path"
  if [[ -n "$rvm_force_flag" ]] ; then \rm -rf "$rvm_ruby_home" "$rvm_ruby_src_path" ; fi

  result=0
  __rvm_fetch_ruby
  result=$? ; if [[ "$result" -gt 0 ]] ; then
    $rvm_scripts_path/log "error" "There has been an error fetching the ruby interpreter. Aborting the installation." ; __rvm_pushpop ; return $result
  fi

  builtin cd $rvm_ruby_src_path

  result=$? ; if [[ "$result" -gt 0 ]] ; then
    $rvm_scripts_path/log "error" "There has been an error, source directory is missing. Did the download or extraction fail? Aborting the installation." ; __rvm_pushpop ; return $result
  fi


  if [[ -d "${rvm_path}/usr" ]] ; then
    export PATH="${rvm_path}/usr/bin:${PATH}"
    builtin hash -r
  fi

  __rvm_apply_patches
  result="$?"
  if [[ "$result" -gt 0 ]]; then
    $rvm_scripts_path/log "fail" "There has been an error applying the specified patches. Aborting the installation."
    return $result
  fi

  if [[ -z "$rvm_ruby_configure" ]] && [[ ! -s "$rvm_ruby_src_path/configure" ]] ; then
    if command -v autoconf > /dev/null ; then
      __rvm_run "autoconf" "autoconf" "Running autoconf"
    else
      result=$? ; $rvm_scripts_path/log "fail" "rvm requires autoconf to install the selected ruby interpreter however autoconf was not found in the PATH." ; return $result
    fi
  fi

  if [[ -n "$rvm_ruby_configure" ]] ; then
    __rvm_run "configure" "$rvm_ruby_configure"
    result=$? ; if [[ "$result" -gt 0 ]] ; then
      $rvm_scripts_path/log "error" "There has been an error while configuring. Aborting the installation." ; __rvm_pushpop ; return $result
    fi
  elif [[ -s ./configure ]] ; then
    # REE stores configure flags differently for head vs. the distributed release.
    if [[ "ree" != "$rvm_ruby_interpreter" ]]; then
      __rvm_db "${rvm_ruby_interpreter}_configure_flags" "db_configure_flags"
    fi

    # On 1.9.2, we manually set the --with-baseruby option
    # to point to an expanded path.
    if [[ "$rvm_ruby_string" = "ruby-1.9.2-head" ]] ; then
      local compatible_baseruby="$rvm_wrappers_path/$(__rvm_18_compat_ruby)/ruby"
      if [[ -x "$compatible_baseruby" ]] ; then
        configure_parameters="--with-baseruby=$compatible_baseruby"
      fi
    fi

    local configure_command="./configure --prefix=$rvm_ruby_home $db_configure_flags $rvm_ruby_configure_flags $configure_parameters"
    __rvm_run "configure" "$configure_command" "Configuring $rvm_ruby_string, this may take a while depending on your cpu(s)..."
    unset configure_parameters db_configure_flags
    result=$? ; if [[ "$result" -gt 0 ]] ; then
      $rvm_scripts_path/log "error" "There has been an error while running configure. Aborting the installation." ; __rvm_pushpop ; return $result
    fi
  else
    $rvm_scripts_path/log "error" "Skipping configure step, 'configure' does not exist, did autoconf not run successfully?"
  fi

  rvm_ruby_make=${rvm_ruby_make:-"make"}
  __rvm_run "make" "$rvm_ruby_make $rvm_make_flags" "Compiling $rvm_ruby_string, this may take a while depending on your cpu(s)..."
  result=$? ; if [[ "$result" -gt 0 ]] ; then
    $rvm_scripts_path/log "error" "There has been an error while running make. Aborting the installation." ; __rvm_pushpop ; return $result
  fi

  if [[ -d .ext/rdoc ]] ; then \rm -rf .ext/rdoc ; fi

  rvm_ruby_make_install=${rvm_ruby_make_install:-"make install"}
  __rvm_run "install" "$rvm_ruby_make_install" "Installing $rvm_ruby_string"
  result=$? ; if [[ "$result" -gt 0 ]] ; then
    $rvm_scripts_path/log "error" "There has been an error while running make install. Aborting the installation." ; __rvm_pushpop ; return $result
  fi

  $rvm_scripts_path/log "info" "Installation of $rvm_ruby_string is complete."

  export GEM_HOME="$rvm_ruby_gem_home"
  export GEM_PATH="$rvm_ruby_gem_path"
  export BUNDLE_PATH="$rvm_ruby_gem_home"

  __rvm_rubygems_setup
  __rvm_bin_script
  __rvm_run "chmod.bin" "chmod +x $rvm_ruby_home/bin/*"
  __rvm_post_install
  __rvm_pushpop
}

__rvm_install_ruby() {

  if [[ -z "$rvm_ruby_selected_flag" ]] ; then __rvm_select ; fi

  if [[ -n "$RUBYOPT" ]] ; then ruby_options="$RUBYOPT" ; unset RUBYOPT ; fi

  # Check for clang if the flag is set
  __rvm_check_for_clang
  local result="$?"
  [[ "$result" -gt 0 ]] && return $result

  case "$rvm_ruby_interpreter" in
    macruby)
      if [[ "Darwin" = "$(uname)" ]] ; then
        if [[ "$rvm_head_flag" = 1 ]] ; then
          if [[ -n "$rvm_llvm_flag" ]] ; then
            $rvm_scripts_path/package llvm install
          fi
          macruby_path="/usr/local/bin"
          # TODO: configure & make variables should be set here.
          rvm_ruby_configure=" true "
          rvm_ruby_make="rake"
          rvm_ruby_make_install="sudo rake install"
          __rvm_db "${rvm_ruby_interpreter}_repo_url" "rvm_url"
          rvm_ruby_repo_url=$rvm_url
          __rvm_install_source $*
          result=$? ; if [[ "$result" -gt 0 ]] ; then
            $rvm_scripts_path/log "error" "There has been an error while trying to install from source. Aborting the installation." ; return $result
          fi
        elif [[ "nightly" = "$rvm_ruby_version" ]] ; then
          macruby_path="/Library/Frameworks/MacRuby.framework/Versions/0.6/usr/bin"
          # TODO: Separated nightly from head.
          $rvm_scripts_path/log "info" "Retrieving the latest nightly macruby build..."
          $rvm_scripts_path/fetch "$rvm_url"
          result=$? ; if [[ "$result" -gt 0 ]] ; then
            $rvm_scripts_path/log "error" "There has been an error while trying to fetch the source. Aborting the installation." ; __rvm_pushpop ; return $result
          fi
          mv "$rvm_archives_path/macruby_nightly-latest.pkg" "$rvm_archives_path/macruby_nightly.pkg"
          __rvm_run "macruby/extract" "sudo /usr/sbin/installer -pkg '$rvm_archives_path/macruby_nightly.pkg' -target '/'"
          \mkdir -p "$rvm_ruby_home/bin"
        else
          macruby_path="/Library/Frameworks/MacRuby.framework/Versions/${rvm_ruby_version}/usr/bin"
          # TODO: Separated nightly from head.
          $rvm_scripts_path/log "info" "Retrieving MacRuby ${rvm_ruby_version} ..."
          $rvm_scripts_path/fetch "$rvm_url"
          result=$? ; if [[ "$result" -gt 0 ]] ; then
            $rvm_scripts_path/log "error" "There has been an error while trying to fetch the source. Aborting the installation." ; __rvm_pushpop ; return $result
          fi
          \mkdir -p $rvm_ruby_src_path
          unzip -o -j "$rvm_archives_path/$rvm_ruby_package_file" "MacRuby ${rvm_ruby_version}/MacRuby ${rvm_ruby_version}.pkg" -d "$rvm_ruby_src_path"
          mv "$rvm_ruby_src_path/MacRuby ${rvm_ruby_version}.pkg" "$rvm_ruby_src_path/$rvm_ruby_string.pkg"
          __rvm_run "macruby/extract" "sudo /usr/sbin/installer -pkg '$rvm_ruby_src_path/$rvm_ruby_string.pkg' -target '/'"
          \mkdir -p "$rvm_ruby_home/bin"
        fi

        binaries=(erb gem irb rake rdoc ri ruby testrb)
        for binary_name in ${binaries[@]}; do
          # TODO: This should be generated via an external script.
          ruby_wrapper=$(cat <<RubyWrapper
#!/usr/bin/env bash

export GEM_HOME="$rvm_ruby_gem_home"
export GEM_PATH="$rvm_ruby_gem_path"
export MY_RUBY_HOME="$rvm_ruby_home"
export PATH="$rvm_ruby_gem_home/bin:$rvm_ruby_global_gems_path/bin:$rvm_ruby_home/bin:\$PATH"

exec $macruby_path/mac$binary_name $prefix "\$@"
RubyWrapper
)

          file_name="$rvm_ruby_home/bin/$binary_name"
          \rm -f $file_name
          echo "$ruby_wrapper" > $file_name
          if [[ -f $file_name ]] ; then chmod +x $file_name ; fi
          if [[ "$binary_name" = "ruby" ]] ; then
            echo "$ruby_wrapper" > $rvm_bin_path/$rvm_ruby_string
          fi
          unset file_name ruby_wrapper binary_name files prefix
        done
        __rvm_irbrc
      else
        $rvm_scripts_path/log "fail" "MacRuby can only be installed on a Darwin OS."
      fi
    ;;

    ree)
      if [[ -n "$(echo $rvm_ruby_version | awk '/^1\.8/')" ]] && [[ -z "$rvm_head_flag" ]] ; then
        rvm_url="$(__rvm_db "ree_${rvm_ruby_version}_url")/$rvm_ruby_package_file.tar.gz"
        $rvm_scripts_path/log "info" "Installing Ruby Enterprise Edition from source to: $rvm_ruby_home"
        __rvm_pushpop "$rvm_src_path"
        if [[ -z "$rvm_force_flag" ]] && [[ -d "$rvm_ruby_src_path" ]] && [[ ! -x "$rvm_ruby_src_path/installer" ]] ; then
          $rvm_scripts_path/log "It appears that the archive has already been extracted. Skipping extract (use --force to force re-download and extract)."
        else
          $rvm_scripts_path/log "Downloading $rvm_ruby_package_file, this may take a while depending on your connection..."
          $rvm_scripts_path/fetch "$rvm_url"
          result=$? ; if [[ "$result" -gt 0 ]] ; then
            $rvm_scripts_path/log "error" "There has been an error while trying to fetch the source. Aborting the installation." ; __rvm_pushpop ; return $result
          fi

          \rm -rf "$rvm_ruby_src_path"
          __rvm_run "extract" "gunzip < \"$rvm_archives_path/$rvm_ruby_package_file.$rvm_archive_extension\" | tar xf - -C $rvm_src_path" "Extracting $rvm_ruby_package_file ..."

          result=$? ; if [[ "$result" -gt 0 ]] ; then
            $rvm_scripts_path/log "error" "There has been an error while trying to extract the source. Aborting the installation." ; __rvm_pushpop ; return $result
          fi

          mv "$rvm_src_path/$rvm_ruby_package_file" "$rvm_ruby_src_path"
        fi
        builtin cd "$rvm_ruby_src_path"

        \mkdir -p "${rvm_ruby_home}/lib/ruby/gems/1.8/gems"
        if [[ -n "$rvm_ruby_configure_flags" ]] ; then
          rvm_ruby_configure_flags="$(echo $rvm_ruby_configure_flags | sed 's#--#-c --#g')"
        fi

        if [[ "Darwin" = "$(uname)" ]] && [[ "1.8.6" = "$rvm_ruby_version" ]] && [[ -z "$rvm_ree_options" ]] ; then
          rvm_ree_options="${rvm_ree_options} --no-tcmalloc"
        fi

        __rvm_db "${rvm_ruby_interpreter}_configure_flags" "db_configure_flags"

        __rvm_apply_patches "$rvm_ruby_src_path/source"
        result=$? ; if [[ "$result" -gt 0 ]] ; then
          $rvm_scripts_path/log "error" "There has been an error while trying to apply patches to ree. Aborting the installation." ; __rvm_pushpop ; return $result
        fi

        __rvm_run "install" "./installer -a $rvm_rubies_path/$rvm_ruby_string $rvm_ree_options $db_configure_flags $rvm_ruby_configure_flags" "Installing $rvm_ruby_string, this may take a while depending on your cpu(s)..."
        result=$? ; if [[ "$result" -gt 0 ]] ; then
          $rvm_scripts_path/log "error" "There has been an error while trying to run the ree installer. Aborting the installation." ; __rvm_pushpop ; return $result
        fi

        chmod +x $rvm_ruby_home/bin/*

        __rvm_rubygems_setup
        __rvm_irbrc
        __rvm_bin_script
        __rvm_post_install
        __rvm_pushpop
      else
        __rvm_db "${rvm_ruby_interpreter}_${rvm_ruby_version}_repo_url" "rvm_url"
        if [[ -z "$rvm_url" ]] ; then
          $rvm_scripts_path/log "fail" "rvm does not know the rvm repo url for '${rvm_ruby_interpreter}_${rvm_ruby_version}'"
          result=1
        else
          rvm_ruby_repo_url=$rvm_url
          if [[ "rvm_make_flags_flag" -eq 1 ]] ; then __rvm_make_flags ; fi
          __rvm_install_source $*
        fi
      fi
    ;;

    rbx|rubinius)
      $rvm_scripts_path/log "info" "Installing pre-requisites"

      # Ensure we have a 1.8.7 compatible ruby installed.
      __rvm_ensure_has_18_compat_ruby || return 1
      # TODO: use 'rvm gems load' here:
      unset CFLAGS LDFLAGS ARCHFLAGS # Important.

      unset BUNDLE_PATH GEM_HOME GEM_PATH MY_RUBY_HOME IRBRC
      __rvm_remove_rvm_from_path
      __rvm_conditionally_add_bin_path ; export PATH
      builtin hash -r

      if [[ -n "$(echo $rvm_ruby_version | awk '/^1\.0/')" ]] && [[ -z "$rvm_head_flag" ]] ; then
        $rvm_scripts_path/log "info" "Downloading $rvm_ruby_package_file, this may take a while depending on your connection..."
        $rvm_scripts_path/fetch "$rvm_url"
        result=$? ; if [[ "$result" -gt 0 ]] ; then
          $rvm_scripts_path/log "error" "There has been an error while trying to fetch the source. Aborting the installation." ; __rvm_pushpop ; return $result
        fi
        __rvm_run "extract" "gunzip < \"$rvm_archives_path/$(basename $rvm_ruby_package_file)\" | tar xf - -C $rvm_src_path" "Extracting $rvm_ruby_package_file ..."

        result=$? ; if [[ "$result" -gt 0 ]] ; then
          $rvm_scripts_path/log "error" "There has been an error while trying to extract the source. Aborting the installation." ; __rvm_pushpop ; return $result
        fi

        # Remove the left over folder first.
        \rm -rf "$rvm_ruby_src_path"
        mv "$rvm_src_path/rubinius-${rvm_ruby_version}" "$rvm_ruby_src_path"
      else
        __rvm_db "rubinius_repo_url" "rvm_ruby_repo_url"
        #rvm_ruby_home="$rvm_rubies_path/$rvm_ruby_interpreter-$rvm_ruby_version"
        __rvm_fetch_from_github "rbx"
        result=$? ; if [[ "$result" -gt 0 ]] ; then
          $rvm_scripts_path/log "error" "There has been an error while fetching the rbx git repo. Aborting the installation." ; __rvm_pushpop ; return $result
        fi
      fi

      builtin cd "$rvm_ruby_src_path" ; chmod +x ./configure

      __rvm_apply_patches
      result=$? ; if [[ "$result" -gt 0 ]] ; then
        $rvm_scripts_path/log "error" "There has been an error while trying to apply patches to rubinius. Aborting the installation." ; __rvm_pushpop ; return $result
      fi

      __rvm_db "${rvm_ruby_interpreter}_configure_flags" "db_configure_flags"

      export ruby="$(__rvm_18_compat_ruby)"

      rvm_ruby_configure_flags="${rvm_ruby_configure_flags:-"--skip-system"}"
      rvm_ruby_configure="$rvm_bin_path/$ruby configure --prefix=$rvm_ruby_home $db_configure_flags $rvm_ruby_configure_flags" ; message="Configuring rbx"
      if [[ "$rvm_llvm_flag" = "0" ]] ; then
        rvm_ruby_configure="$rvm_ruby_configure --disable-llvm"
      else
        if [[ "$rvm_ruby_patch_level" = "rc1" ]] ; then
          rvm_ruby_configure="$rvm_ruby_configure --enable-llvm"
        fi
      fi
      __rvm_run "configure" "$rvm_ruby_configure" "$message"
      result=$? ; if [[ "$result" -gt 0 ]] ; then
        $rvm_scripts_path/log "error" "There has been an error while running '$rvm_ruby_configure'. Aborting the installation." ; __rvm_pushpop ; return $result
      fi

      if [[ "$rvm_trace_flag" -eq 1 ]] ; then
        rvm_ruby_make="$rvm_wrappers_path/$ruby/rake install --trace" ; message="Compiling rbx (with --trace)"
      else
        rvm_ruby_make="$rvm_wrappers_path/$ruby/rake install" ; message="Compiling rbx"
      fi
      __rvm_run "rake" "$rvm_ruby_make" "$message"
      result=$? ; if [[ "$result" -gt 0 ]] ; then
        $rvm_scripts_path/log "error" "There has been an error while running '$rvm_ruby_configure'. Aborting the installation." ; __rvm_pushpop ; return $result
      fi

      unset ruby

      # Symlink rubinius wrappers
      ln -fs "$rvm_ruby_home/bin/rbx" "$rvm_ruby_home/bin/ruby"

      # Install IRB Wrapper on Rubinius.
      file_name="$rvm_ruby_home/bin/irb"
      \rm -f "$file_name"
      printf '#!/usr/bin/env bash\n' > "$file_name"
      printf "exec '$rvm_ruby_home/bin/rbx' 'irb' \"\$@\"\n" >> "$file_name"
      [[ -f "$file_name" ]] && chmod +x "$file_name"

      # Install Gem Wrapper on Rubinius.
      file_name="$rvm_ruby_home/bin/gem"
      \cp -f "$rvm_ruby_home/lib/bin/gem.rb" "$file_name"
      __rvm_inject_ruby_shebang "$file_name"
      [[ -f "$file_name" ]] && chmod +x "$file_name"
      unset file_name

      binaries="erb ri rdoc"
      __rvm_post_install
      __rvm_irbrc
      __rvm_bin_script
    ;;

    jruby)
      if ! command -v java > /dev/null; then
        printf "java must be installed and in your path in order to install JRuby." ; return 1
      fi

      __rvm_pushpop $rvm_src_path
      __rvm_fetch_ruby
      result=$? ; if [[ "$result" -gt 0 ]] ; then
        $rvm_scripts_path/log "error" "There has been an error while trying to fetch the source. Aborting the installation." ; __rvm_pushpop ; return $result
      fi

      builtin cd "$rvm_ruby_src_path"
      if [[ -n "$rvm_head_flag" ]] ; then __rvm_run "ant.dist" "ant dist" "Running 'ant dist' (this could take a few minutes) ..." ; fi

      \mkdir -p "$rvm_ruby_home/bin/"
      if $rvm_scripts_path/match "$rvm_ruby_version" "1\.3" || $rvm_scripts_path/match "$rvm_ruby_version" "1\.2" ; then
        __rvm_run "nailgun" "builtin cd \"$rvm_ruby_src_path/tool/nailgun\" &&  make $rvm_make_flags" "Building Nailgun"
      else
        __rvm_run "nailgun" "builtin cd \"$rvm_ruby_src_path/tool/nailgun\" && ./configure --prefix=$rvm_ruby_home && make $rvm_make_flags" "Building Nailgun"
      fi

      __rvm_pushpop

      if [[ -z "$rvm_ruby_home" ]] || [[ "$rvm_ruby_home" = "/" ]] ; then echo "WTH?!?! rvm_ruby_home == / ??? not removing." ; return 1000000 ; fi

      \rm -rf $rvm_ruby_home
      __rvm_run "install" "/bin/cp -Rf $rvm_ruby_src_path $rvm_ruby_home" "Installing JRuby to $rvm_ruby_home"

      __rvm_pushpop $rvm_ruby_home/bin/
      for binary in jirb jruby jgem ; do
        ln -nfs $binary ${binary#j}
      done ; unset binary
      __rvm_pushpop

      # -server is "a lot slower for short-lived scripts like rake tasks, and takes longer to load"
      #sed -e 's#^JAVA_VM=-client#JAVA_VM=-server#' $rvm_ruby_home/bin/jruby > $rvm_ruby_home/bin/jruby.new &&
      #  mv $rvm_ruby_home/bin/jruby.new $rvm_ruby_home/bin/jruby
      chmod +x $rvm_ruby_home/bin/jruby

      for binary in jrubyc jirb_swing jirb jgem rdoc ri spec autospec testrb ast generate_yaml_index.rb ; do
        __rvm_inject_gem_env $rvm_ruby_home/bin/$binary
      done ; unset binary

      __rvm_inject_ruby_shebang "$rvm_ruby_home/bin/rake"

      __rvm_rubygems_setup
      __rvm_irbrc
      __rvm_bin_script
      __rvm_use

      __rvm_post_install

      # jruby ships with some built in gems, copy them in to place.
      if [[ -d "$rvm_ruby_home/lib/ruby/gems/1.8" ]]; then
        $rvm_scripts_path/log "info" "Copying across included gems"
        cp -R "$rvm_ruby_home/lib/ruby/gems/1.8/" "$GEM_HOME/"
      fi

    ;;

    maglev)
      __rvm_ensure_has_18_compat_ruby

      $rvm_scripts_path/log "info" "Running MagLev prereqs checking script."
      $rvm_scripts_path/maglev
      result=$? ; if [[ "$result" -gt 0 ]] ; then
        $rvm_scripts_path/log "error" "Prerequisite checks have failed. Aborting the installation." ; __rvm_pushpop ; return $result
      fi

      __rvm_pushpop $rvm_src_path

      if [[ ! -d "$rvm_src_path/$rvm_ruby_string" ]] || [[ -n "$rvm_force_flag" ]] ; then
        \rm -rf "$rvm_src_path/$rvm_ruby_string/" "$rvm_src_path/$rvm_ruby_string/"
        __rvm_fetch_ruby
        result=$? ; if [[ "$result" -gt 0 ]] ; then
          $rvm_scripts_path/log "error" "There has been an error while trying to fetch the source. Aborting the installation." ; __rvm_pushpop ; return $result
        fi
      fi

      if [[ -n "$rvm_head_flag" ]] ; then
        builtin cd $rvm_ruby_src_path
        rvm_gemstone_package_file="GemStone-$(\grep ^GEMSTONE version.txt | cut -f2 -d-).$(uname -sm | \tr ' ' '-')"
        rvm_gemstone_url="${rvm_gemstone_url:-"$maglev_url/${rvm_gemstone_package_file}.${rvm_archive_extension}"}"
      fi

      $rvm_scripts_path/log "info" "Downloading the GemStone package, this may take a while depending on your connection..."
      $rvm_scripts_path/fetch "$rvm_gemstone_url"
      result=$? ; if [[ "$result" -gt 0 ]] ; then
        $rvm_scripts_path/log "error" "There has been an error while trying to fetch the GemStone package. Aborting the installation." ; __rvm_pushpop ; return $result
      fi

      builtin cd "$rvm_src_path"

      if [[ -s "$rvm_ruby_package_file" ]] ; then
        mv "$rvm_ruby_package_file" "$rvm_ruby_src_path"
      fi

      builtin cd "$rvm_ruby_src_path"

      __rvm_run "gemstone.extract" "gunzip < \"$rvm_archives_path/${rvm_gemstone_package_file}.${rvm_archive_extension}\" | tar xf - -C $rvm_ruby_src_path"
      result=$? ; if [[ "$result" -gt 0 ]] ; then
        $rvm_scripts_path/log "error" "There has been an error while trying to extract the GemStone package. Aborting the installation." ; __rvm_pushpop ; return $result
      fi

      chmod -R 777 "$rvm_gemstone_package_file" # for now.
      ln -nfs "$rvm_gemstone_package_file" "gemstone"

      __rvm_pushpop

      if [[ -z "$rvm_ruby_home" ]] || [[ "$rvm_ruby_home" = "/" ]] ; then echo "WTH?!?! rvm_ruby_home == / ??? not removing." ; return 1000000 ; fi
      \rm -rf $rvm_ruby_home
      __rvm_run "install" "/bin/cp -Rf $rvm_ruby_src_path $rvm_ruby_home" "Installing maglev to $rvm_ruby_home"

      __rvm_pushpop $rvm_ruby_home/bin/
      for binary in maglev-irb maglev-ruby maglev-gem ; do
        ln -nfs $binary ${binary#maglev-}
      done ; unset binary
      __rvm_pushpop

      for binary in maglev-ruby maglev-irb maglev-gem ; do
        __rvm_inject_gem_env $rvm_ruby_home/bin/$binary
      done ; unset binary

      builtin cd "$rvm_ruby_home"
      if [[ -n "$rvm_head_flag" ]] ; then
        git submodule update --init
        $rvm_ruby_home/bin/maglev force-reload
        ln -sf maglev.demo.key-$(uname -sm | \tr ' ' '-') etc/maglev.demo.key
      fi

      #ln -fs "$rvm_ruby_home/$(echo $rvm_gemstone_package_file | awk -F'.' '{print $1}')" "$rvm_ruby_home/gemstone"

      compatible_ruby="$(__rvm_18_compat_ruby)"

      if [[ ! -e ${rvm_ruby_home}/etc/conf.d/maglev.conf ]] ; then
        $rvm_scripts_path/log "info" "Creating default 'maglev' repository."
        $rvm_wrappers_path/$compatible_ruby/rake "stone:create[maglev]" >/dev/null 2>&1
      fi

      $rvm_scripts_path/log "info" "Generating maglev HTML documentation"
      $rvm_wrappers_path/$compatible_ruby/rake rdoc >/dev/null 2>&1

      $rvm_scripts_path/log "info" "Generating smalltalk FFI."
      $rvm_wrappers_path/$compatible_ruby/rake stwrappers >/dev/null 2>&1

      unset compatible_ruby

      # TODO: Figure out if anything needs to be done with rubygems.
      #__rvm_rubygems_setup
      __rvm_irbrc
      __rvm_bin_script
      __rvm_use
    ;;

    ironruby|ir)
      if ! command -v mono > /dev/null ; then
        printf "mono must be installed and in your path in order to install IronRuby." ; return 1
      fi

      if [[ "$rvm_head_flag" = 1 ]] ; then
          mono_version="$(mono -V | head -n 1 | cut -d ' ' -f5)"
          if $rvm_scripts_path/match "$mono_version" "([0-9]+)\.([0-9]+)\.?([0-9]+)?" ; then
            mono_major_ver="$(echo $mono_version | cut -d '.' -f1)"
            mono_minor_ver="$(echo $mono_version | cut -d '.' -f2)"
            if [[ $mono_major_ver -lt 2 ]] || ( [[ $mono_major_ver -eq 2 ]] && [[ $mono_minor_ver -lt 6 ]] ) ; then
              printf "Mono 2.6 (or greater) must be installed and in your path in order to build IronRuby from the repository."
              printf "Version detected: ${mono_version}"
              return 1
            fi
          else
            printf "Cannot recognize mono version."
            return 1
          fi

          __rvm_ensure_has_18_compat_ruby

          __rvm_fetch_ruby
          if [[ $? -gt 0 ]] ; then result=$? ; return $result ; fi
          builtin cd $rvm_ruby_src_path

          compatible_ruby="$(__rvm_18_compat_ruby)"

          $rvm_wrappers_path/$compatible_ruby/gem install pathname2 --no-rdoc --no-ri

          # MONO_LIB=/Library/Frameworks/Mono.framework/Versions/current/lib/
          rvm_ruby_make="$rvm_wrappers_path/$compatible_ruby/rake MERLIN_ROOT=\"$rvm_ruby_src_path/Merlin/Main\" compile mono=1 configuration=release --trace"
          __rvm_run "rake" "$rvm_ruby_make" "Building IronRuby..."
          unset compatible_ruby
          if [[ $? -gt 0 ]] ; then result=$? ; return $result ; fi

          \rm -rf $rvm_ruby_home/*
          \mkdir -p $rvm_ruby_home/bin $rvm_ruby_home/lib $rvm_ruby_home/lib/ruby $rvm_ruby_home/lib/IronRuby

          \cp -r $rvm_ruby_src_path/Merlin/Main/Bin/mono_release/* $rvm_ruby_home/bin/
          \cp -r $rvm_ruby_src_path/Merlin/Main/Languages/Ruby/Scripts/bin/* $rvm_ruby_home/bin/
          \cp -r $rvm_ruby_src_path/Merlin/External.LCA_RESTRICTED/Languages/Ruby/redist-libs/ruby/* $rvm_ruby_home/lib/ruby
          \cp -r $rvm_ruby_src_path/Merlin/Main/Languages/Ruby/Libs/* $rvm_ruby_home/lib/IronRuby
      else
        $rvm_scripts_path/log "info" "Retrieving IronRuby"

        $rvm_scripts_path/fetch "$rvm_url" "$rvm_ruby_package_file"
        result=$? ; if [[ "$result" -gt 0 ]] ; then
          $rvm_scripts_path/log "error" "There has been an error while trying to fetch the source. Aborting the installation." ; __rvm_pushpop ; return $result
        fi

        \mkdir -p $rvm_ruby_src_path $rvm_ruby_home
        unzip -o  -d ${rvm_ruby_src_path} ${rvm_archives_path}/${rvm_ruby_package_file} >> "$rvm_ruby_log_path/extract.log" 2>> "$rvm_ruby_log_path/extract.error.log"
        result=$? ; if [[ "$result" -gt 1 ]] ; then
          $rvm_scripts_path/log "error" "There has been an error while trying to extract $rvm_ruby_package_file. Aborting the installation." ; __rvm_pushpop ; return $result
        fi

        for dir in bin lib silverlight ; do
          \cp -Rf $rvm_src_path/$rvm_ruby_string/$dir "$rvm_ruby_home/$dir"
        done
      fi

      binaries=(gem irb rdoc rake ri ruby)
      for binary_name in ${binaries[@]} ; do
        if [[ -s $rvm_ruby_home/bin/$binary_name ]] ; then
          \tr -d '\r' < "$rvm_ruby_home/bin/$binary_name" > "$rvm_ruby_home/bin/$binary_name.new"
          #sed -e '1,1s=.*=#!'"/usr/bin/env ir=" "$rvm_ruby_home/bin/$binary_name" > "$rvm_ruby_home/bin/$binary_name.new"
          mv -f "$rvm_ruby_home/bin/$binary_name.new" "$rvm_ruby_home/bin/$binary_name"
          chmod +x $rvm_ruby_home/bin/$binary_name
        fi
      done

      sed -e '1,1s=.*=#!'"/usr/bin/env bash=" "$rvm_ruby_home/bin/ir" | \tr -d '\r' > "$rvm_ruby_home/bin/ir.new"
      mv -f "$rvm_ruby_home/bin/ir.new" "$rvm_ruby_home/bin/ir"
      chmod +x $rvm_ruby_home/bin/ir
      ln -fs $rvm_ruby_home/bin/ir $rvm_ruby_home/bin/ruby
      builtin hash -r
      __rvm_run "gems.install" "PATH=$rvm_ruby_gem_home/bin:$rvm_ruby_global_gems_path/bin:$rvm_ruby_home/bin:$PATH GEM_HOME=$rvm_ruby_gem_home GEM_PATH=$rvm_ruby_gem_home $rvm_ruby_home/bin/gem install --no-rdoc --no-ri rake $rvm_gem_options" "Installing $rvm_gem_name to $dir"
    ;;

    mput|shyouhei)
      if [[ "rvm_make_flags_flag" -eq 1 ]] ; then __rvm_make_flags ; fi
      unset BUNDLE_PATH GEM_HOME GEM_PATH MY_RUBY_HOME IRBRC
      __rvm_remove_rvm_from_path
      __rvm_conditionally_add_bin_path ; export PATH
      builtin hash -r

      rvm_ruby_home="$rvm_rubies_path/$rvm_ruby_interpreter-$rvm_ruby_version"

      __rvm_fetch_from_github "mput" "trunk"

      __rvm_apply_patches
      result=$? ; if [[ "$result" -gt 0 ]] ; then
        $rvm_scripts_path/log "error" "There has been an error while trying to apply patches to mput. Aborting the installation." ; return $result
      fi

      if [[ ! -s "$rvm_ruby_src_path/configure" ]] ; then
        if command -v autoconf &> /dev/null ; then
          __rvm_run "autoconf" "autoconf" "Running autoconf"
        else
          result=$?; $rvm_scripts_path/log "fail" "rvm expects autoconf to install this ruby interpreter, autoconf was not found in PATH. Aborting installation." ; return $result
        fi
      fi

      if [[ -s ./Makefile ]] && [[ -z "$rvm_reconfigure_flag" ]] ; then
          (($rvm_debug_flag)) && $rvm_scripts_path/log "debug" "Skipping configure step, Makefile exists so configure must have already been run."
      elif [[ -n "$rvm_ruby_configure" ]] ; then
        __rvm_run "configure" "$rvm_ruby_configure"
          result=$? ; if [[ "$result" -gt 0 ]] ; then
            $rvm_scripts_path/log "error" "There has been an error while trying to configure the source. Aborting the installation." ; __rvm_pushpop ; return $result
          fi

      elif [[ -s ./configure ]] ; then
          local configure_command="./configure --prefix=$rvm_ruby_home $rvm_ruby_configure_flags"
          __rvm_run "configure" "" "Configuring $rvm_ruby_string using $rvm_ruby_configure_flags, this may take a while depending on your cpu(s)..."
          result=$? ; if [[ "$result" -gt 0 ]] ; then
            $rvm_scripts_path/log "error" "There has been an error while trying to configure the source. Aborting the installation." ; __rvm_pushpop ; return $result
          fi
      else
          $rvm_scripts_path/log "error" "Skipping configure step, 'configure' script does not exist, did autoconf not run successfully?"
      fi

      rvm_ruby_make=${rvm_ruby_make:-"make"}
      __rvm_run "make" "$rvm_ruby_make $rvm_make_flags" "Compiling $rvm_ruby_string, this may take a while depending on your cpu(s)..."
      result=$? ; if [[ "$result" -gt 0 ]] ; then
        $rvm_scripts_path/log "error" "There has been an error while trying to run make. Aborting the installation." ; __rvm_pushpop ; return $result
      fi

      rvm_ruby_make_install=${rvm_ruby_make_install:-"make install"}
      __rvm_run "install" "$rvm_ruby_make_install" "Installing $rvm_ruby_string"
      result=$? ; if [[ "$result" -gt 0 ]] ; then
        $rvm_scripts_path/log "error" "There has been an error while trying to run make install. Aborting the installation." ; __rvm_pushpop ; return $result
      fi

      $rvm_scripts_path/log "info" "Installation of $rvm_ruby_string is complete."

      export GEM_HOME="$rvm_ruby_gem_home"
      export GEM_PATH="$rvm_ruby_gem_path"
      export BUNDLE_PATH="$rvm_ruby_gem_home"

      __rvm_rubygems_setup
      __rvm_bin_script
      __rvm_run "chmod.bin" "chmod +x $rvm_ruby_home/bin/*"
      __rvm_post_install
      __rvm_pushpop
    ;;

    ruby)
      __rvm_check_for_bison # Run like hell
      result=$? ; if [[ "$result" -gt 0 ]] ; then return $result ; fi

      if [[ "rvm_make_flags_flag" -eq 1 ]] ; then __rvm_make_flags ; fi
      __rvm_install_source $*
    ;;

    default)
      $rvm_scripts_path/log "fail" "must specify a ruby interpreter to install."
    ;;

    *) $rvm_scripts_path/log "fail" "Ruby interpreter '$rvm_ruby_interpreter' is not known."

  esac

  rvm_hook="after_install" ; source $rvm_scripts_path/hook

  if [[ -n "$ruby_options" ]] ; then RUBYOPT=$ruby_options ; export RUBYOPT ; fi
}

__rvm_fetch_from_github() {
  \rm -rf "$rvm_ruby_src_path"
  if [[ ! -d "$rvm_ruby_repo_path/.git" ]] ; then
    \rm -rf "$rvm_ruby_repo_path"
    builtin cd "$rvm_home"
    __rvm_run "$1.repo" "git clone --depth 1 $rvm_ruby_repo_url $rvm_ruby_repo_path" "Cloning $rvm_ruby_repo_url"
    result=$? ; if [[ "$result" -gt 0 ]] ; then
      rvm_ruby_repo_http_url="$(echo $rvm_ruby_repo_url | sed -e 's/git:/http:/')"
      $rvm_scripts_path/log "info" "Could not fetch $rvm_ruby_repo_url - trying $rvm_ruby_repo_http_url"
      __rvm_run "$1.repo" "git clone --depth 1 $rvm_ruby_repo_http_url $rvm_ruby_repo_path" "Cloning $rvm_ruby_repo_http_url"
    fi
  else
    local branch="${2:-"master"}"
    builtin cd "$rvm_ruby_repo_path"
    __rvm_run "$1.repo" "git pull origin $branch" "Pulling from origin $branch"
  fi
  __rvm_run "$1.copy" "\\cp -R \"$rvm_ruby_repo_path\" \"$rvm_ruby_src_path\"" "Copying from repo to source..."
  builtin cd "$rvm_ruby_src_path"
}

__rvm_fetch_ruby() {
  [[ -z "$rvm_ruby_selected_flag" ]] && __rvm_select

  if [[ -z "$rvm_head_flag" && -z "$rvm_ruby_tag" && -z "$rvm_ruby_revision" ]] ; then
    rvm_ruby_package_name="${rvm_ruby_package_name:-"$rvm_ruby_string"}"
    rvm_ruby_package_file="${rvm_ruby_package_file:-"$rvm_ruby_package_name"}"
    if [[ "ruby" = "$rvm_ruby_interpreter" ]]; then
      rvm_archive_extension="${rvm_archive_extension:-tar.bz2}"
    else
      rvm_archive_extension="${rvm_archive_extension:-tar.gz}"
    fi

    if [[ ! -s "$rvm_archives_path/$rvm_ruby_package_file.$rvm_archive_extension" ]] ; then
      if [[ "ruby" = "$rvm_ruby_interpreter" ]] ; then
        rvm_url="$(__rvm_db "${rvm_ruby_interpreter}_${rvm_release_version}.${rvm_major_version}_url")/$rvm_ruby_package_file.$rvm_archive_extension"
      elif [[ "ree" = "$rvm_ruby_interpreter" ]] ; then
        rvm_url="$(__rvm_db "${rvm_ruby_interpreter}_${rvm_ruby_version}_url")/${rvm_ruby_package_file}.${rvm_archive_extension}"
      elif [[ "jruby" = "$rvm_ruby_interpreter" ]] ; then
        rvm_url="$(__rvm_db "${rvm_ruby_interpreter}_url")/${rvm_ruby_version}/${rvm_ruby_package_file}.${rvm_archive_extension}"
      elif [[ "maglev" = "$rvm_ruby_interpreter" ]] ; then
        : # Should already be set from selector
      else
        rvm_url="$(__rvm_db "${rvm_ruby_interpreter}_url")/${rvm_ruby_package_file}.${rvm_archive_extension}"
      fi
      "$rvm_scripts_path/log" "info" "Downloading ${rvm_ruby_package_file}, this may take a while depending on your connection..."
      "$rvm_scripts_path/fetch" "${rvm_url}"
      result=$? ; if [[ "$result" -gt 0 ]] ; then
        "$rvm_scripts_path/log" "error" "There has been an error while trying to fetch the source. Aborting the installation." ; __rvm_pushpop ; return $result
      fi
    fi

    if [[ ! -d "$rvm_ruby_src_path" ]] || [[ -n "$rvm_force_flag" ]] ; then
      \rm -rf "$rvm_ruby_src_path" # Especially when forced, we want to ensure the destination is missing.

      \mkdir -p "/tmp/rvm_src_$$"

      if [[ "tar.gz" = "$rvm_archive_extension" ]] || [[ "tgz" = "$rvm_archive_extension" ]] ; then
        __rvm_run "extract" "gunzip < \"$rvm_archives_path/$rvm_ruby_package_file.$rvm_archive_extension\" | tar xf - -C /tmp/rvm_src_$$" "Extracting $rvm_ruby_package_file ..."
        result=$? ; if [[ "$result" -gt 0 ]] ; then
          $rvm_scripts_path/log "error" "There has been an error while trying to extract the source. Aborting the installation." ; __rvm_pushpop ; return $result
        fi
      elif [[ "zip" = "$rvm_archive_extension" ]] ; then
        __rvm_run "extract" "unzip -q -o $rvm_archives_path/$rvm_ruby_package_file -d /tmp/rvm_src_$$"
        result=$? ; if [[ "$result" -gt 0 ]] ; then
          $rvm_scripts_path/log "error" "There has been an error while trying to extract $rvm_ruby_package_file. Aborting the installation." ; __rvm_pushpop ; return $result
        fi
      elif [[ "tar.bz2" = "$rvm_archive_extension" ]] ; then
        __rvm_run "extract" "bunzip2 < \"$rvm_archives_path/$rvm_ruby_package_file.$rvm_archive_extension\" | tar xf - -C /tmp/rvm_src_$$" "Extracting $rvm_ruby_package_file ..."
        result=$? ; if [[ "$result" -gt 0 ]] ; then
          $rvm_scripts_path/log "error" "There has been an error while trying to extract the source. Aborting the installation." ; __rvm_pushpop ; return $result
        fi
      fi

      mv "/tmp/rvm_src_$$/$(\cd /tmp/rvm_src_$$ ; \ls)" "$rvm_ruby_src_path" ; \rm -rf "/tmp/rvm_src_$$"

      if [[ -n "$rvm_ruby_name" ]] && [[ -d "$rvm_src_path/$(echo $rvm_ruby_string | sed -e 's/-n.*//')" ]] ; then
        mv "$rvm_src_path/$(echo $rvm_ruby_string | sed -e 's/-n.*//')" "$rvm_ruby_src_path"
      fi

    else
      $rvm_scripts_path/log "info" "$rvm_ruby_src_path has already been extracted." ; __rvm_pushpop ; return 0
    fi

  else

    \mkdir -p "$rvm_repo_path"
    if [[ -n "$(echo $rvm_url | awk '/^git/')" ]] ; then
      if [[ -d "$rvm_ruby_repo_path/.git" ]] ; then
        builtin cd $rvm_ruby_repo_path
        if [[ -z "$rvm_ruby_revision" ]] ; then
          $rvm_scripts_path/log "info" "Pulling from $rvm_ruby_repo_url, this may take a while depending on your connection..."
          git pull origin master --force
          result=$? ; if [[ "$result" -gt 0 ]] ; then
            $rvm_scripts_path/log "error" "There has been an error while trying to update the source from the remote repository. Aborting the installation." ; __rvm_pushpop ; return $result
          fi
        else
          if [[ -z "$rvm_ruby_sha" ]] ; then
            git checkout HEAD
          else
            git checkout $(echo $rvm_ruby_sha | sed 's#^s##')
          fi
          result=$? ; if [[ "$result" -gt 0 ]] ; then
            $rvm_scripts_path/log "error" "There has been an error while trying to checkout the source branch. Aborting the installation." ; __rvm_pushpop ; return $result
          fi
        fi
      else
        \rm -rf "$rvm_ruby_repo_path"
        rvm_ruby_repo_http_url="$(echo $rvm_ruby_repo_url | sed -e 's/git:/http:/')"
        $rvm_scripts_path/log "info" "Cloning from $rvm_ruby_repo_url, this may take a while depending on your connection..."
        git clone --depth 1 "$rvm_ruby_repo_url" "$rvm_ruby_repo_path"
        result=$? ; if [[ "$result" -gt 0 ]] ; then
          $rvm_scripts_path/log "info" "cloning from $rvm_ruby_repo_url failed, now attempting to clone from $rvm_ruby_repo_http_url, this may take a while depending on your connection..."
          git clone "$rvm_ruby_repo_http_url" "$rvm_ruby_repo_path"
          result=$? ; if [[ "$result" -gt 0 ]] ; then
            $rvm_scripts_path/log "error" "There has been an error while trying to fetch the repository. Aborting the installation." ; __rvm_pushpop ; return $result
          fi
        fi
      fi
    else
      if [[ -n "$rvm_ruby_tag" ]] ; then
        # TODO: Check if tag v is valid
        rvm_url="${rvm_url:-"$rvm_ruby_repo_url/tags/$(echo $rvm_ruby_tag | sed 's/^t//')"}"
      elif [[ -z "$rvm_ruby_version" ]] && [[ -n "$rvm_head_flag" ]] ; then
        rvm_url="${rvm_url:-"$rvm_ruby_repo_url/trunk"}"
      elif [[  "$rvm_major_version" = "9" ]] ; then
        if [[ -z "$rvm_minor_version" ]] || [[ "$rvm_minor_version" = 3 ]] ; then
          rvm_url="${rvm_url:-"$rvm_ruby_repo_url/trunk"}"
        else
          rvm_url="${rvm_url:-"$rvm_ruby_repo_url/branches/ruby_${rvm_release_version}_${rvm_major_version}_${rvm_minor_version}"}"
        fi
      elif [[ -z "$rvm_minor_version" ]] || [[ "$rvm_major_version.$rvm_minor_version" = "8.8" ]] ; then
        rvm_url="${rvm_url:-"$rvm_ruby_repo_url/branches/ruby_${rvm_release_version}_${rvm_major_version}"}"
      else
        rvm_url="${rvm_url:-"$rvm_ruby_repo_url/branches/ruby_${rvm_release_version}_${rvm_major_version}_${rvm_minor_version}"}"
      fi

      rvm_rev=""
      if [ -n "$rvm_ruby_revision" ] ; then
        rvm_rev="-$rvm_ruby_revision"
      fi

      if [[ -d "$rvm_ruby_repo_path/.svn" ]] ; then
        builtin cd $rvm_ruby_repo_path
        $rvm_scripts_path/log "info" "Updating ruby from $rvm_url"
        __rvm_run "svn.switch" "svn switch $rvm_url"
        __rvm_run "svn.update" "svn update"
        if [[ -n "$rvm_rev" ]] ; then
          $rvm_scripts_path/log "info" "Checking out revision ${rvm_rev/-r/-r } from $rvm_url"
          __rvm_run "svn.checkout" "svn update -q ${rvm_rev/-r/-r }"
        fi
      else
        \rm -rf $rvm_ruby_repo_path
        __rvm_run "svn.checkout" "svn checkout -q ${rvm_rev/-r/-r } $rvm_url $rvm_ruby_repo_path" "Downloading source from ${rvm_url}."
      fi
      result=$? ; if [[ "$result" -gt 0 ]] ; then
        $rvm_scripts_path/log "error" "There has been an error while trying to fetch / update the source. Aborting the installation." ; __rvm_pushpop ; return $result
      fi

    fi
    $rvm_scripts_path/log "info" "Copying from repo to src path..."
    \rm -rf "$rvm_ruby_src_path"
    \cp -R "$rvm_ruby_repo_path" "$rvm_ruby_src_path"
  fi
}

__rvm_check_default() {
  default_ruby_interpreter="$(rvm alias show default 2>/dev/null | awk -F"${rvm_gemset_seperator:-"@"}" '{print $1}')"
  current_ruby_interpreter="$(echo "$rvm_ruby_string" | awk -F"${rvm_gemset_seperator:-"@"}" '{print $1}')"
  if [[ -n "$current_ruby_interpreter" && "$current_ruby_interpreter" == "$default_ruby_interpreter" ]]; then
    __rvm_run_with_env 'default.restore'  'system' 'rvm use system --default' 'Removing default ruby interpreter'
  fi
  unset default_ruby_interpreter current_ruby_interpreter
}

__rvm_uninstall_ruby() {
  if [[ -z "$rvm_ruby_selected_flag" ]] ; then __rvm_select ; fi

  if [[ -n "$rvm_ruby_string" ]] ; then
    for dir in $rvm_rubies_path ; do
      if [[ -d $dir/$rvm_ruby_string ]] ; then
        $rvm_scripts_path/log "info" "Removing $dir/$rvm_ruby_string..."
        \rm -rf $dir/$rvm_ruby_string
      else
        $rvm_scripts_path/log "info" "$dir/$rvm_ruby_string has already been removed."
      fi
      if [[ -e $rvm_bin_path/$rvm_ruby_string ]] ; then
        \rm -f $rvm_bin_path/$rvm_ruby_string
      fi
    done ; unset dir

    __rvm_remove_install_record "$rvm_ruby_string"

    __rvm_remove_gemsets

    __rvm_check_default

  else
    $rvm_scripts_path/log "fail" "Cannot uninstall unknown package '$rvm_ruby_string'"
  fi ; unset rvm_uninstall_flag
}

__rvm_remove_ruby() {
  if [[ -z "$rvm_ruby_selected_flag" ]] ; then __rvm_select ; fi

  if [[ -n "$rvm_ruby_string" ]] ; then
    for dir in $rvm_src_path $rvm_rubies_path ; do
      if [[ -d $dir/$rvm_ruby_string ]] ; then
        $rvm_scripts_path/log "info" "Removing $dir/$rvm_ruby_string..."
        \rm -rf $dir/$rvm_ruby_string
      else
        $rvm_scripts_path/log "info" "it seems that $dir/$rvm_ruby_string is already non existent."
      fi

      if [[ -e $rvm_bin_path/$rvm_ruby_string ]] ; then
        \rm -f $rvm_bin_path/$rvm_ruby_string
      fi

      __rvm_check_default

    done ; unset dir
    __rvm_remove_install_record "$rvm_ruby_string"
    __rvm_remove_gemsets
    __rvm_remove_archives
    __rvm_remove_aliases
    __rvm_remove_wrappers
    __rvm_remove_environments
    __rvm_remove_binaries
  else
    $rvm_scripts_path/log "fail" "Cannot remove unknown package '$rvm_ruby_string'"
  fi ; unset rvm_remove_flag
}

__rvm_remove_gemsets() {
  if [[ -n "$rvm_gems_flag" ]] ; then
    $rvm_scripts_path/log "info" "Removing $rvm_ruby_string gemsets..."
    gemsets="$rvm_gems_path/$rvm_ruby_string $(\ls -d "${rvm_gems_path}"/* | awk '/'$rvm_ruby_string'@/')"
    for gemset in $gemsets ; do
      if [[ -d "$gemset" ]] ; then
        \rm -rf "$gemset"
      fi
    done ; unset gemset gemsets
  fi
}

__rvm_remove_wrappers() {
  $rvm_scripts_path/log "info" "Removing $rvm_ruby_string wrappers..."
  wrappers="$rvm_wrappers_path/$rvm_ruby_string $(\ls -d "$rvm_wrappers_path"/* 2>/dev/null | awk '/'$rvm_ruby_string'@/')"
  for wrapper in $wrappers ; do
    \rm -rf "$wrapper"
  done ; unset wrapper wrappers
}

__rvm_remove_environments() {
  $rvm_scripts_path/log "info" "Removing $rvm_ruby_string environments..."
  environments="$rvm_environments_path/$rvm_ruby_string $(\ls -d "$rvm_environments_path"/* | awk '/'$rvm_ruby_string'@/')"
  for environment in $environments ; do
    \rm -rf "$environment"
  done ; unset environment environments
}

__rvm_remove_aliases() {
  $rvm_scripts_path/log "info" "Removing $rvm_ruby_string aliases..."
  aliases=$(awk '/'$rvm_ruby_string'/' $rvm_config_path/alias | sed 's/=.*//')
  for alias_name in $aliases ; do
    # Remove from alias key-value store
    $rvm_scripts_path/alias delete "$alias_name" >/dev/null 2>&1
  done ; unset alias_name aliases
}

__rvm_remove_archives() {
  if [[ -n "$rvm_archive_flag" ]] ; then
    $rvm_scripts_path/log "info" "Removing $rvm_ruby_string archives..."
    \rm -f $rvm_archives_path/${rvm_ruby_package_file}.${rvm_archive_extension}
  fi
}

__rvm_remove_binaries() {
  $rvm_scripts_path/log "info" "Removing $rvm_ruby_string binaries..."
  # Iterate over all binaries and check for symlinked wrappers etc.
  for binary_name in $(\ls "$rvm_bin_path"); do
    full_binary_path="$rvm_bin_path/$binary_name"
    if [[ -L "$full_binary_path" ]] && $rvm_scripts_path/match "$(readlink "$full_binary_path")" "$rvm_ruby_string"; then
      \rm -f "$full_binary_path"
    fi
    unset full_binary_path
  done; unset binary_name
}

__rvm_post_install() {
  if [[ "$rvm_ruby_interpreter" != "jruby" ]] ; then
    binaries="${binaries:-"gem irb erb ri rdoc testrb rake"}"
    $rvm_scripts_path/log "info" "adjusting shebangs for $rvm_ruby_string ($binaries)."
    for binary in $(echo $binaries) ; do
      if [[ -e "$rvm_ruby_home/bin/$binary" ]] || [[ -e "$rvm_ruby_src_path/bin/$binary" ]] ; then
        if [[ "$rvm_ruby_src_path" != "$rvm_ruby_home" ]] && [[ -f "$rvm_ruby_src_path/bin/$binary" ]] ; then
          \cp -f "$rvm_ruby_src_path/bin/$binary" "$rvm_ruby_home/bin/$binary"
        elif [[ -f "$rvm_ruby_gem_home/bin/$binary" ]] ; then
          \cp -f "$rvm_ruby_gem_home/bin/$binary" "$rvm_ruby_home/bin/$binary"
        fi
        __rvm_inject_gem_env "$rvm_ruby_home/bin/$binary"
        __rvm_inject_ruby_shebang "$rvm_ruby_home/bin/$binary"
        chmod +x "$rvm_ruby_home/bin/$binary"
      fi
    done ; unset binary binaries
  fi

  # Import the initial gemsets.
  __rvm_run_with_env "gemsets.initial" "$rvm_ruby_string" 'rvm gemset initial' "Importing initial gems..."

  __rvm_irbrc
  __rvm_generate_default_docs

  if [[ -n "$rvm_ruby_aliases" ]]; then
    $rvm_scripts_path/log "info" "Setting up aliases for $rvm_ruby_string"
    while read -r ruby_alias; do
      $rvm_scripts_path/log info "Aliasing $rvm_ruby_string to $ruby_alias"
      $rvm_scripts_path/alias delete "$ruby_alias" > /dev/null 2>&1
      $rvm_scripts_path/alias create "$ruby_alias" "$rvm_ruby_string" > /dev/null 2>&1
    done < <(echo "$rvm_ruby_string" | \tr ' ' '\n' | sort -u)
    unset rvm_ruby_aliases ruby_alias
  fi
}

__rvm_generate_default_docs() {
  if [[ "$rvm_docs_flag" = "1" && "$rvm_ruby_interpreter" != "macruby" ]]; then
    __rvm_run_with_env "docs.generate" "$rvm_ruby_string" "rvm docs generate-ri" "Attempting to generate ri documentation..."
  fi
}

__rvm_rubygems_setup() {
  if [[ -n "$(echo $rvm_ruby_version | awk '/^1\.9/')" ]] || [[ -n "$(echo $rvm_ruby_interpreter | awk '/^mput/')" ]] ; then
    install=0
  elif [[ "$rvm_ruby_string" = "ruby-head" ]] ; then
    install=0
  else
    install=1
  fi

  __rvm_use

  if [[ "$install" -eq 0 ]] ; then
    # 1.9.X has it's own built-in gem command
    __rvm_inject_ruby_shebang "$rvm_ruby_src_path/bin/gem"
    __rvm_inject_gem_env "$rvm_ruby_home/bin/gem"

    \cp $rvm_ruby_src_path/bin/gem $rvm_ruby_home/bin/gem

    home="$GEM_HOME" ; path="$GEM_PATH" # Save
    for dir in $rvm_ruby_global_gems_path $rvm_ruby_gem_home ; do
      export GEM_HOME="$dir" ; export GEM_PATH="$dir" ; export BUNDLE_PATH="$dir"
      __rvm_run "rubygems.update" "$rvm_ruby_home/bin/gem update --system" "Updating rubygems for $dir"
    done ; unset home path dir
    GEM_HOME="$home" ; GEM_PATH="$path" ; BUNDLE_PATH="$home"
    export GEM_HOME GEM_PATH BUNDLE_PATH

    __rvm_inject_ruby_shebang "$rvm_ruby_home/bin/gem"
    __rvm_inject_gem_env "$rvm_ruby_home/bin/gem"

    directory_name="$rvm_ruby_home/lib/ruby/gems"
    version_number="${rvm_release_version}.${rvm_major_version}"
    if [[ "$version_number" == "." ]]; then
      version_number="$(\ls "$directory_name" | \grep '^[[:digit:]].[[:digit:]]\(.[[:digit:]]\)\?' | head -n1)"
      if [[ -n "$version_number" ]]; then
        ruby_lib_gem_path="${directory_name}/${version_number}"
      else
        ruby_lib_gem_path=""
      fi
    else
      ruby_lib_gem_path="${directory_name}/${version_number}"
    fi
    unset directory_name version_number
  elif [[ -n "$(echo $rvm_ruby_interpreter | awk '/^rbx|jruby/')" ]] ; then
    # Hands off rubygems for rbx & jruby
    if [[ -n "$rvm_debug_flag" ]] ; then $rvm_scripts_path/log "debug" "Skipping rubygems update for $rvm_ruby_version" ; fi
    ruby_lib_gem_path="$rvm_ruby_home/lib/ruby/gems/jruby"
  else
    $rvm_scripts_path/log "info" "Installing rubygems dedicated to $rvm_ruby_string..."
    rvm_rubygems_version="$(__rvm_db "${rvm_ruby_interpreter}_rubygems_version")"
    rvm_rubygems_version="${rvm_rubygems_version:-"$(__rvm_db "rubygems_version")"}"
    rvm_rubygems_url=$(__rvm_db "rubygems_${rvm_rubygems_version}_url")
    rvm_gem_package_name="rubygems-$rvm_rubygems_version"
    rvm_gem_url="$rvm_rubygems_url/$rvm_gem_package_name.tgz"
    # Sanity check... If setup.rb is missing from the rubygems source path,
    # something went wrong. Cleanup, aisle 3!
    if [[ ! -f "$rvm_src_path/$rvm_gem_package_name/setup.rb" ]]; then
      \rm -rf "$rvm_src_path/$rvm_gem_package_name"
    fi

    if [[ ! -d "$rvm_src_path/$rvm_gem_package_name" ]] ; then
      $rvm_scripts_path/log "info" "Retrieving $rvm_gem_package_name"
      $rvm_scripts_path/fetch "$rvm_gem_url"
      result=$? ; if [[ "$result" -gt 0 ]] ; then
        $rvm_scripts_path/log "error" "There has been an error while trying to fetch the source. Aborting the installation." ; __rvm_pushpop ; return $result
      fi
      \mkdir -p "$rvm_src_path/$rvm_gem_package_name"
      __rvm_run "rubygems.extract" "gunzip < \"$rvm_archives_path/$rvm_gem_package_name.tgz\" | tar xf - -C $rvm_src_path" "Extracting $rvm_gem_package_name ..."
    fi

    builtin cd "$rvm_src_path/$rvm_gem_package_name"

    __rvm_run "rubygems.install" "GEM_PATH=$rvm_ruby_gem_path GEM_HOME=$rvm_ruby_gem_home BUNDLE_PATH=$rvm_ruby_gem_home $rvm_ruby_home/bin/ruby $rvm_src_path/$rvm_gem_package_name/setup.rb" "Installing rubygems for $rvm_ruby_home/bin/ruby"
    result=$?
    if [[ $result -eq 0 ]] ; then
      $rvm_scripts_path/log "info" "Installation of rubygems $rvm_ruby_package_name completed successfully."
    else
      $rvm_scripts_path/log "warning" "Installation of rubygems $rvm_ruby_package_name did not complete successfully."
    fi

    __rvm_inject_ruby_shebang "$rvm_ruby_home/bin/gem"

    if [[ -n "$rvm_major_version" ]] ; then
      ruby_lib_gem_path="$rvm_ruby_home/lib/ruby/gems/${rvm_release_version}.$rvm_major_version"
    else
      ruby_lib_gem_path="$rvm_ruby_home/lib/ruby/gems/$interpreter"
    fi
  fi

  if [[ -n "$ruby_lib_gem_path" ]]; then
    # Add ruby's gem path to ruby's lib direcotry.
    \mkdir -p $(dirname $ruby_lib_gem_path)
    if [[ -d "$ruby_lib_gem_path" ]] ; then \rm -rf "$ruby_lib_gem_path" ; fi
    ln -nfs "$rvm_ruby_gem_home" "$ruby_lib_gem_path"
  fi; unset ruby_lib_gem_path

  if [[ -s "$rvm_ruby_src_path/bin/rdoc" ]] ; then
    __rvm_inject_ruby_shebang "$rvm_ruby_src_path/bin/rdoc"
  fi

  if [[ -s "$rvm_ruby_src_path/bin/rake" ]] ; then
    __rvm_inject_ruby_shebang "$rvm_ruby_src_path/bin/rake"
  fi

  return $result
}

__rvm_inject_ruby_shebang() {
  __rvm_actual_file $1

  if [[ -f "$actual_file" ]] ; then
    sed -e '1,1s=.*=#!'"/usr/bin/env ruby=" ${actual_file} > "${actual_file}.new"
    mv "${actual_file}.new" "${actual_file}" ; chmod +x "$actual_file"
  fi ; unset actual_file
}

__rvm_inject_gem_env() {
  __rvm_actual_file $1
  if [[ -f "$actual_file" ]] ; then
    if [[ -n "$(head -n 1 $actual_file | awk '/[j]*ruby/')" ]] ; then
      string="ENV['GEM_HOME']=ENV['GEM_HOME'] || '$rvm_ruby_gem_home'\nENV['GEM_PATH']=ENV['GEM_PATH'] || '$rvm_ruby_gem_path'\nENV['PATH']='$rvm_ruby_gem_home/bin:$rvm_ruby_global_gems_path/bin:$rvm_ruby_home/bin:' + ENV['PATH']\nENV['BUNDLE_PATH']=ENV['BUNDLE_PATH'] || '$rvm_ruby_gem_home'\n"
    elif [[ -n "$(head -n 1 $actual_file | awk '/bash/')" ]] ; then
      string="GEM_HOME=\${GEM_HOME:-'$rvm_ruby_gem_home'}\nGEM_PATH=\${GEM_PATH:-'$rvm_ruby_gem_path'}\nPATH=$rvm_ruby_gem_home/bin:$rvm_ruby_global_gems_path/bin:$rvm_ruby_home/bin:\$PATH\nBUNDLE_PATH=\${BUNDLE_PATH:-'$rvm_ruby_gem_home'}\n"
    fi
    if [[ -n "$string" ]] ; then
      awk "NR==2 {print \"$string\"} {print}" "$actual_file" > "$actual_file.new"
      mv $actual_file.new $actual_file ; chmod +x "$actual_file"
      unset string
    fi
  fi ; unset actual_file
}

__rvm_actual_file() {
  if [[ -L $1 ]] ; then          # If the file is a symlink,
    actual_file="$(readlink $1)" # read the link target so we can preserve it.
  else
    actual_file="$1"
  fi
}

__rvm_manage_rubies() {
  unset rvm_gemset_name rvm_ruby_selected_flag

  rvm_ruby_gem_home=$(echo $rvm_ruby_gem_home | awk -F${rvm_gemset_separator} '{print $1}')
  rvm_ruby_string=$(echo $rvm_ruby_string | awk -F${rvm_gemset_separator} '{print $1}')

  local manage_result=0

  if [[ -n "$rubies_string" ]] ;then
    for rvm_ruby_string in $(echo "$rubies_string" | \tr ',' ' ') ; do
      current_manage_ruby_string="$rvm_ruby_string"
      eval "__rvm_${rvm_action}_ruby"
      result="$?"
      if [[ "$result" -gt 0 && "$manage_result" = 0 ]]; then
        manage_result="$result"
      fi
      [[ "$result" = 0 && "$rvm_action" = "install" ]] && __rvm_record_install "$current_manage_ruby_string"
      unset current_manage_ruby_string
      __rvm_unset_ruby_variables
    done
  else # all
    if [[ "$rvm_action" != "install" && "$rvm_action" != "remove" && "$rvm_action" != "uninstall" ]] ; then
      while read -r bin_line
      do # Keep this on second line damnit!
        if [[ -x "$bin_line" ]] ; then
          current_manage_ruby_string="$(dirname "$bin_line" | xargs dirname | xargs basename)"
          rvm_ruby_string="$current_manage_ruby_string"
          eval "__rvm_${rvm_action}_ruby"
          result="$?"
          if [[ "$result" -gt 0 && "$manage_result" = 0 ]]; then
            manage_result="$result"
          fi
          # record as current_manage_string to prevent it being overridden.
          [[ "$result" = 0 && "$rvm_action" = "install" ]] && __rvm_record_install "$current_manage_ruby_string"
          unset current_manage_ruby_string
          __rvm_unset_ruby_variables
        fi
      done < <(\ls $rvm_rubies_path/*/bin/ruby 2> /dev/null)
    else
      $rvm_scripts_path/log "warn" 'Really? '"$rvm_action"' all? See "rvm list known" and limit the selection to something more sane please :)'
    fi
  fi

  # TODO: This should return the exit status of the command that got called.
  return $manage_result

}

rvm_action="$1"
rubies_string="$2"
__rvm_manage_rubies
exit $?