RubyGems - wayneeseguin-rvm - Versions diffs - 0.0.31 → 0.0.35 - Mend

wayneeseguin-rvm 0.0.31 → 0.0.35

Files changed (11) hide show

data/config/db ADDED Viewed

@@ -0,0 +1,20 @@
+niceness=0
+ruby_repo_url=http://svn.ruby-lang.org/repos/ruby
+rubinius_repo_url=git://github.com/evanphx/rubinius.git
+macruby_repo_url=http://svn.macosforge.org/repository/ruby/MacRuby
+jruby_repo_url=git://kenai.com/jruby~main
+ruby_configure=--enable-shared
+interpreter=ruby
+ruby_version=1.8.6
+ruby_patchlevel=383
+jruby_version=1.3.1
+ree_interpreter=ruby-enterprise
+ree_version=1.8.6
+ree_patch_level=20090610
+macruby_version=2009-09-04
+ruby_version=1.8.6
+ruby_1.9.1_patch_level=p243
+ruby_1.9.2_patch_level=preview1
+ruby_1.8.5_patch_level=p115
+ruby_1.8.6_patch_level=p383
+ruby_1.8.7_patch_level=p174

data/rvm.gemspec CHANGED Viewed

@@ -5,11 +5,11 @@
 Gem::Specification.new do |s|
   s.name = %q{rvm}
-  s.version = "0.0.31"
+  s.version = "0.0.35"
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Wayne E. Seguin"]
-  s.date = %q{2009-09-03}
+  s.date = %q{2009-09-05}
   s.description = %q{Manages Ruby interpreter installations and switching between them.}
   s.email = %q{wayneeseguin@gmail.com}
   s.executables = ["rvm-install", "rvm-update"]
@@ -20,13 +20,17 @@ Gem::Specification.new do |s|
     "INSTALL",
      "LICENCE",
      "README",
-     "config/cache",
+     "config/db",
      "examples/rvmrc",
      "lib/rvm.rb",
      "rvm.gemspec",
      "scripts/rvm",
+     "scripts/rvm-cli",
      "scripts/rvm-install",
-     "scripts/rvm-update"
+     "scripts/rvm-ruby-installer",
+     "scripts/rvm-selector",
+     "scripts/rvm-update",
+     "scripts/rvm-utility"
   ]
   s.homepage = %q{http://github.com/wayneeseguin/rvm}
   s.rdoc_options = ["--inline-source", "--charset=UTF-8"]

data/scripts/rvm CHANGED Viewed

@@ -1,1214 +1,17 @@
 #!/bin/bash
 #
-# License: See LICENSE
+# rvm : Ruby Version Manager
+# http://rvm.beginrescueend.com
+# http://gitub.com/wayneeseguin/rvm
 #
-#
-# Functions
-#
-function __rvm_meta {
-  rvm_meta_author="Wayne E. Seguin"
-  rvm_meta_author_email="wayneeseguin@gmail.com"
-  rvm_meta_website="http://rvm.beginrescueend.com/"
-  rvm_meta_version="0.0.31"
-  rvm_meta_updated="2009.09.03"
-}
-function __rvm_version { __rvm_meta ; echo "rvm $rvm_meta_version ($rvm_meta_updated) [$rvm_meta_website]" ; }
-function __rvm_usage {
-  __rvm_meta
-  cat <<-Usage
-  rvm ${rvm_meta_version} ${rvm_meta_website} by ${rvm_meta_author} (${rvm_meta_author_email})
-  Usage:
-    rvm Action [Implementation] [Options]
-  Action:
-    * usage   - Show this usage information
-    use       - Switch to using a specific ruby version (new login shell)
-    info      - Show information for current ruby
-    list      - Show currently installed versions
-    gemdir    - Switch to gem directory for installation (new login shell)
-    srcdir    - Switch to src directory for the current ruby installation
-    gemdup    - Clone source version gems to current version
-                (highly expiramental) Example: rvm gemdup ~/.gem/ruby/1.8/
-    install   - Install a ruby version, default is from source
-    uninstall - Uninstall a ruby version
-    reset     - Remove default and current settings, exit the shell.
-                (If you experience odd behavior try this first)
-    rubydo    - Used with -f to run a ruby file against specified or all rubies
-    debug     - Emit environment & configuration information for *current* ruby
-    reload    - Reload rvm source itself (useful after changing rvm source)
-    implode   - Removes all ruby installations it manages, everything in ~/.rvm
-    update    - Upgrades rvm to the latest version.
-  Implementation:
-    * ruby    - MRI/YARV Ruby (The Standard), defaults to 1.8.6
-    jruby     - jRuby
-    rubinius  - Rubinius
-    ree       - Ruby Enterprise Edition
-    system    - Use the system ruby (eg. pre-rvm state)
-    default   - Use rvm set default ruby and system if it hasn't been set.
-  Options:
-    -v|--version    - Ruby Package Version, defaults to 'latest'
-    -l|--level      - Patch level for the specified Ruby version
-    -p|--prefix     - Package and source directory prefix, with trailing slash!
-                      Default is a users home directory and /usr/local/ for root
-    -c|--configure  - Options for source compile (default: --enable-shared=true)
-    -a|--archives   - Directory to place downladed files into (~/.rvm/archives/)
-    -n|--nice       - Niceness level (default: 0)
-    -m|--gem-set    - Named gem set for switching between different gem sets
-    --rm-gem-set    - Removes a named gemset.
-    -l|--level      - Specify a patch level to use
-    -t|--tag        -
-    -r|--rev        - Specify the repository revision # to use or 'head' for
-    -P|--prefix     - Sets the prefix path for installs to be installed to
-    -B|--bin        - Specify path for binaries to be placed
-    -S|--source     - Specify src directory to use
-    -A|--archive    - Specify archive directory to use (tabralls / zips)
-    -G|--gems       - Specify root gem path to use
-    -C|--configure  - Specify custom configure options, comma separated
-    -M|--make       - Specify a custom make command
-    -I|--make-install - "     a custom make install command
-    -n|--nice       - Specify a process niceness (for slow computers)
-    -f|--file       - Specify a ruby file to run with 'rubydo' command
-    -h|--help       - Emit this output and exit
-    -d|--default    - Set the default Ruby to a specified version
-    -m|--gem-set    - Use a named gem set instead of the default set.
-    --all           - Used with 'rvm list' to list "most" installable versions.
-    --rm-gem-set    - Remove a named gem set
-    --jit           - Enable JIT for the Rubinius build
-    --force         - Force install, removes old install & source directories.
-    --set-prompt    - Set prompt to have the selected ruby prepended.
-    --debug|--trace - Toggle debug mode on for very verbose output.
-  Resources:
-    http://rvm.beginrescueend.com/
-    https://www.pivotaltracker.com/projects/26822
-Usage
-}
-# Logging functions based on level
-function __rvm_log   {
-  case "$1" in
-    debug) shift ; echo -e "\n\033[0;35m <d> $* \033[0m" ;;
-    info)  shift ; echo -e "\n\033[0;32m <i> $* \033[0m" ;;
-    warn)  shift ; echo -e "\n\033[0;33m <w> $* \033[0m" ;;
-    fail)  shift ; echo -e "\n\033[0;31m <e> $* \033[0m" ; popd 2> /dev/null ; return 1 ;;
-    *) echo -e "$*"
-  esac
-}
-function __rvm_clean-path {
-  PATH=`echo $PATH | tr -s ':' '\n' | awk '!($0 in a){a[$0];print}' | tr -s '\n' ':' | sed 's/:$//'`
-  export PATH
-}
-function __rvm_remove-from-path {
-  PATH=`echo $PATH | tr -s ':' '\n' | grep -v "\.rvm" | tr -s '\n' ':' | sed 's/:$//'`
-  export PATH
-}
-function __rvm_gi { gem install -q --no-rdoc --no-ri $* ; }
-function __rvm_gems-install { for gem in $* ; do __rvm_gi $gem ; done }
-function __rvm_set-defaults {
-  # TODO: Store defaults in "defaults/" dir.
-  if [ ! -s $rvm_install_path/default ] ; then
-    for variable in rvm_prompt RUBY_VERSION GEM_HOME MY_RUBY_HOME PATH ; do
-      eval value=\$${variable}
-      if [ -z "$value" ] ; then
-        echo "unset ${variable}" >> $rvm_install_path/default
-      else
-        eval "export $variable"
-        eval value=\$${variable}
-        echo "${variable}='$value' ; export ${variable}" >> $rvm_install_path/default
-      fi
-    done
-  fi
-  if [ -s $rvm_install_path/default_path ] ; then
-    rvm_default_path=`cat $rvm_install_path/default_path`
-  else
-    __rvm_clean-path # Clean the path the first time we compute default path.
-    __rvm_remove-from-path
-    echo $PATH > $rvm_install_path/default_path
-    rvm_default_path=$PATH
-  fi
-  rvm_default_ps1=`__rvm_cache rvm_default_ps1`
-  if [ -z "$rvm_default_ps1" ] ; then
-    rvm_default_ps1=$PS1
-    __rvm_cache "rvm_default_ps1" "$rvm_default_ps1"
-  fi
-  if [ -s $rvm_install_path/default_user_gem_path ] ; then
-    rvm_default_user_gem_path=`cat $rvm_install_path/default_user_gem_path`
-  else
-    ruby -r rubygems -e "puts Gem::default_path.compact.first" > $rvm_install_path/default_user_gem_path
-  fi
-  if [ -s $rvm_install_path/default_system_gem_path ] ; then
-    rvm_default_system_gem_path=`cat $rvm_install_path/default_system_gem_path`
-  else
-    ruby -r rubygems -e "puts Gem::default_path.compact[1] || Gem::default_path.compact.first" > $rvm_install_path/default_system_gem_path
-  fi
-  if [ -s $rvm_install_path/default_system_ruby ] ; then
-    default_system_ruby=`cat $rvm_install_path/default_system_ruby`
-  else
-   default_system_ruby=`which ruby`
-   echo $default_system_ruby > $rvm_install_path/default_system_ruby
-  fi
-}
-function __rvm_initialize {
-  rvm_fetch=`which curl`
-  if [ $? -ne 0 ] ; then
-    rvm_fetch=`which wget`
-    if [ $? -ne 0 ] ; then
-      rvm_fetch="wget -q -c "
-    else
-    __rvm_log "fail" "rvm expects either curl or wget, neither seem to be in your path :("
-    fi
-  else
-    rvm_fetch="$rvm_fetch -O -L -s -C - "
-  fi
-  rvm_niceness=${rvm_niceness:-0}
-  # TODO: Sanitize user input, ensure that there is a / a the end...
-  if [ "`whoami`" = "root" ] ; then
-    __rvm_log "fail" "root user support is not yet implemented."
-    #rvm_prefix_path=${rvm_prefix_path:-/usr/local/}
-  else
-    rvm_prefix_path=${rvm_prefix_path:-"$HOME/."}
-  fi
-  if [ "${rvm_prefix_path#${rvm_prefix_path%?}}" = '.' -o "${rvm_prefix_path#${rvm_prefix_path%?}}" = '/' ] ; then
-    rvm_install_path="${rvm_prefix_path}rvm"
-  else
-    rvm_install_path="${rvm_prefix_path}/rvm"
-  fi
-  rvm_archives_path="${rvm_archives_path:-"${rvm_install_path}/archives"}"
-  rvm_source_path="${rvm_source_path:-"${rvm_install_path}/src"}"
-  rvm_log_path=${rvm_log_path:-"${rvm_install_path}/log"}
-  rvm_bin_path=${rvm_bin_path:-"${rvm_install_path}/bin"}
-  rvm_gem_path=${rvm_gem_path:-"${rvm_install_path}/gems"}
-  rvm_config_path=${rvm_config_path:-"${rvm_install_path}/config"}
-  rvm_ruby_repo_url="${rvm_ruby_repo_url:-"http://svn.ruby-lang.org/repos/ruby"}"
-  # Rubinius sha1's will be available after RC1.
-  rvm_rubinius_repo_url="${rvm_rubinius_repo_url:-"git://github.com/evanphx/rubinius.git"}"
-  #rvm_macruby_repo_url="${rvm_macruby_repo_url:-"http://svn.macosforge.org/repository/ruby/MacRuby"}"
-  rvm_macruby_repo_url="${rvm_macruby_repo_url:-"git://github.com/masterkain/macruby.git"}"
-  rvm_jruby_repo_url="${rvm_jruby_repo_url:-"git://kenai.com/jruby~main"}"
-  __rvm_clean-path
-  rvm_result=$(echo $PATH | grep 'rvm\/bin:')
-  if [ -z $rvm_result ] ; then
-    PATH=$rvm_bin_path:$PATH ; export PATH
-  fi
-  mkdir -p $rvm_source_path $rvm_bin_path $rvm_archives_path
-}
-function __rvm_fetch {
-  pushd $rvm_archives_path > /dev/null
-  eval $rvm_fetch "$1"
-  popd 2> /dev/null
-}
-function __rvm_install-source {
-  if [ -z "$rvm_selected" ] ; then __rvm_select $* ; fi
-  __rvm_log "info" "Installing Ruby from source to: $rvm_ruby_home"
-  mkdir -p $rvm_ruby_log_path
-  pushd $rvm_source_path > /dev/null
-  if [ ! -z "$rvm_force" ] ; then
-    rm -rf $rvm_ruby_home
-    rm -rf $rvm_ruby_src_path
-  fi
-  if [ -z "$rvm_ruby_tag" -a -z "$rvm_ruby_rev" ] ; then
-    if [ ! -d $rvm_ruby_src_path ]  ; then
-      rvm_url="${rvm_url:-"ftp://ftp.ruby-lang.org/pub/ruby/1.$rvm_major_version/$rvm_ruby_package_name.tar.gz"}"
-      __rvm_log "info" "\tDownloading $rvm_ruby_package_name, this may take a while depending on your connection..."
-      __rvm_fetch $rvm_url
-      if [ $? -gt 0 ] ; then __rvm_log "error" "There was an error, please check $rvm_ruby_log_path/*.error.log" ; popd 2> /dev/null ; return 1 ; fi
-      __rvm_log "info" "\tExtracting $rvm_ruby_package_name ..."
-      mkdir -p $rvm_ruby_src_path
-      nice -n $rvm_niceness tar xzf $rvm_archives_path/$rvm_ruby_package_name.tar.gz -C $rvm_source_path
-    fi
-  else
-    __rvm_log "info" "\tRetrieving Ruby from $rvm_url"
-    if [ ! -z "`echo $rvm_url | grep '^git'`" ] ; then
-      if [ -d "$rvm_ruby_src_path/.git" ] ; then
-        cd $rvm_ruby_src_path
-        if [ -z "$rvm_ruby_rev" ] ; then
-          git pull origin master
-        else
-          git checkout ${rvm_ruby_rev:-HEAD}
-        fi
-      else
-        git clone --depth 1 $rvm_ruby_repo_url $rvm_ruby_src_path
-      fi
-    else
-      if [ -z "$rvm_ruby_rev" ] ; then
-        # TODO: Check if tag v is valid
-        rvm_url=$rvm_ruby_repo_url/tags/$rvm_ruby_tag
-        rvm_rev=""
-      else
-        if [ "$rvm_ruby_rev" = "head" -o "$rvm_ruby_rev" = "trunk" ] ; then
-          rvm_url=$rvm_ruby_repo_url/branches/ruby_1_${rvm_major_version}_${rvm_minor_version}
-          rvm_rev=""
-        else
-          rvm_url=$rvm_ruby_repo_url/branches/ruby_1_${rvm_major_version}_${rvm_minor_version}
-          rvm_rev="-r $rvm_ruby_rev"
-        fi
-      fi
-      if [ -d "$rvm_ruby_src_path/.svn" ] ; then
-        cd $rvm_ruby_src_path
-        svn checkout -q $rvm_rev
-      else
-        svn checkout -q $rvm_rev --force $rvm_url $rvm_ruby_src_path
-      fi
-    fi
-  fi
-  cd $rvm_ruby_src_path
-  if [ $? -gt 0 ] ; then __rvm_log "error" "There was an error, please check $rvm_ruby_log_path/*.error.log" ; popd 2> /dev/null ; return 1 ; fi
-  if [ ! -s $rvm_ruby_src_path/Makefile -a "$rvm_ruby_interpreter" = "ruby" ] ; then autoconf ; fi
-  if [ $? -gt 0 ] ; then __rvm_log "error" "There was an error, please check $rvm_ruby_log_path/*.error.log" ; popd 2> /dev/null ; return 1 ; fi
-  if [ -s ./configure ] ; then
-    __rvm_log "info" "\tConfiguring $rvm_ruby_package_name using $rvm_ruby_configure, this may take a while depending on your cpu(s)..."
-    # command="nice -n $rvm_niceness ./configure --prefix=$rvm_ruby_home $rvm_ruby_configure"
-    # eval $command > $rvm_ruby_log_path/configure.log 2> $rvm_ruby_log_path/configure.error.log
-    __rvm_run "configure" ./configure --prefix=$rvm_ruby_home $rvm_ruby_configure
-    if [ $? -gt 0 ] ; then __rvm_log "error" "There was an error, please check $rvm_ruby_log_path/*.error.log" ; popd 2> /dev/null ; return 1 ; fi
-  else
-    __rvm_log "warn" "\tSkipping configure step, ./configure file does not exist."
-  fi
-  __rvm_log "info" "\tCompiling $rvm_ruby_package_name, this may take a while, depending on your cpu(s)..."
-  if [ -z "$rvm_ruby_make" ] ; then
-    nice -n $rvm_niceness make > $rvm_ruby_log_path/make.log 2> $rvm_ruby_log_path/make.error.log
-  else
-    nice -n $rvm_niceness $rvm_ruby_make > $rvm_ruby_log_path/install.log 2> $rvm_ruby_log_path/install.error.log
-  fi
-  if [ $? -gt 0 ] ; then __rvm_log "error" "There was an error, please check $rvm_ruby_log_path/*.error.log" ; popd 2> /dev/null ; return 1 ; fi
-  if [ -z "$rvm_ruby_make" ] ; then
-    __rvm_log "info" "\tInstalling $rvm_ruby_package_name"
-    nice -n $rvm_niceness make install > $rvm_ruby_log_path/install.log 2> $rvm_ruby_log_path/install.error.log
-  else
-    nice -n $rvm_niceness $rvm_ruby_make_install > $rvm_ruby_log_path/install.log 2> $rvm_ruby_log_path/install.error.log
-  fi
-  if [ $? -gt 0 ] ; then __rvm_log "error" "There was an error, please check $rvm_ruby_log_path/*.error.log" ; popd 2> /dev/null ; return 1 ; fi
-  chmod +x $rvm_ruby_home/bin/*
-ruby_wrapper=$(cat <<-RubyWrapper
-#!/bin/bash
-GEM_HOME=$rvm_gem_home ; export GEM_HOME
-MY_RUBY_HOME=$rvm_ruby_home ; export MY_RUBY_HOME
-PATH=$rvm_ruby_home/bin:$rvm_gem_home/bin:$rvm_default_path ; export PATH
-exec "$rvm_ruby_binary" "\$@"
-RubyWrapper
-)
-  echo "$ruby_wrapper" > $rvm_bin_path/$rvm_ruby_package_name
-  unset ruby_wrapper
-  chmod +x $rvm_bin_path/$rvm_ruby_package_name
-  __rvm_log "info" "Installation of $rvm_ruby_package_name is complete."
-  __rvm_log "info" "\tInstalling rubygems dedicated to $rvm_ruby_package_name..."
-  rvm_gem_package_name="rubygems-1.3.5"
-  rvm_gem_url="http://rubyforge.org/frs/download.php/60718/$rvm_gem_package_name.tgz"
-  if [ -d $rvm_source_path/$rvm_gem_package_name ]  ; then
-    cd $rvm_source_path/$rvm_gem_package_name
-  else
-    __rvm_fetch $rvm_gem_url
-    if [ $? -gt 0 ] ; then __rvm_log "error" "There was an error, please check $rvm_ruby_log_path/*.error.log" ; popd 2> /dev/null ; return 1 ; fi
-    mkdir -p $rvm_source_path/$rvm_gem_package_name
-    nice -n $rvm_niceness tar zxf $rvm_archives_path/$rvm_gem_package_name.tgz -C $rvm_source_path
-  fi
-  # Well this is fun... fix nil error on require_paths:
-  sed -i.orig "s/require_paths\.join/require_paths.to_a.join/" $rvm_source_path/$rvm_gem_package_name/lib/rubygems/gem_path_searcher.rb
-  nice -n $rvm_niceness $rvm_ruby_home/bin/ruby $rvm_source_path/$rvm_gem_package_name/setup.rb > $rvm_ruby_log_path/rubygems.install.log 2> $rvm_ruby_log_path/rubygems.install.error.log
-  popd 2> /dev/null
-  for rvm_gem_name in rake ; do
-    __rvm_log "info" "Installing $rvm_gem_name"
-    nice -n $rvm_niceness $rvm_ruby_home/bin/gem install $rvm_gem_name --no-rdoc --no-ri -q >> $rvm_ruby_log_path/gems.install.log 2> $rvm_ruby_log_path/gems.error.log
-  done
-  for binary in gem irb erb ri rdoc testrb rake ; do
-    if [ -x $rvm_ruby_home/bin/$binary ] ; then
-      string="ENV['GEM_HOME']='$rvm_gem_home'\nENV['PATH']='$rvm_ruby_home/bin:$rvm_gem_home/bin'"
-      awk "NR==2 {print \"$string\"} {print}" $rvm_ruby_home/bin/$binary > $rvm_ruby_home/bin/$binary.new
-      mv $rvm_ruby_home/bin/$binary.new $rvm_ruby_home/bin/$binary
-      chmod +x $rvm_ruby_home/bin/$binary
-    else
-      __rvm_log "warn" "$rvm_ruby_home/bin/$binary is missing"
-    fi
-  done
-  __rvm_log "info" "Installation of rubygems for $rvm_ruby_package_name is complete."
-  if [ -x $rvm_gem_home/bin/$binary ] ; then
-    string="ENV['GEM_HOME']='$rvm_gem_home'\nENV['PATH']='$rvm_ruby_home/bin:$rvm_gem_home/bin'"
-    mv $rvm_gem_home/bin/$binary $rvm_gem_home/bin/$binary.orig
-    awk "NR==2 {print \"$string\"} {print}" $rvm_gem_home/bin/$binary.orig > $rvm_gem_home/bin/$binary
-      chmod +x $rvm_gem_home/bin/$binary
-  else
-    __rvm_log "warn" "$rvm_gem_home/bin/$binary is missing"
-  fi
-  binary=rake
-  mv $rvm_gem_home/bin/$binary $rvm_gem_home/bin/$binary.orig
-  awk "NR==2 {print \"$string\"} {print}" $rvm_gem_home/bin/$binary.orig > $rvm_gem_home/bin/$binary
-  unset binary
-}
-function __rvm_install-ruby {
-  if [ -z "$rvm_selected" ] ; then __rvm_select $* ; fi
-  if [ -z "$RUBYOPT" ] ; then ruby_options=$RUBYOPT ; unset RUBYOPT ; fi
-  case "$rvm_ruby_interpreter" in
-    macruby)
-      if [ "`uname`" = "Darwin" ] ; then
-        rvm_ruby_repo_url=$rvm_macruby_repo_url
-        rvm_ruby_configure=""
-        rvm_ruby_make="rake macruby:build framework_instdir=$rvm_install_path/macruby-head framework_name=/macruby-head --trace"
-        rvm_ruby_make_install="rake framework:install framework_instdir=$rvm_install_path/macruby-head framework_name=/macruby-head --trace"
-        rvm_ruby_rev="${rvm_ruby_rev:-head}" # Hard coding this for now
-        DESTDIR="$rvm_ruby_home" ; export DESTDIR
-        if [ -z "$rvm_ruby_rev" ] ; then
-          # TODO: Check if tag v is valid
-          #rvm_ruby_repo_url=$rvm_ruby_repo_url/tags/$rvm_ruby_tag
-          rvm_ruby_rev="head" # For now, until nightly release are available.
-        else
-          if [ "$rvm_ruby_rev" = "head" -o "$rvm_ruby_rev" = "trunk" ] ; then
-            #rvm_ruby_repo_url=$rvm_ruby_repo_url/trunk
-            rvm_ruby_rev="head"
-          else
-            #rvm_ruby_repo_url=$rvm_ruby_repo_url/trunk
-            rvm_ruby_rev="-r $rvm_ruby_rev"
-          fi
-        fi
-        __rvm_install-source
-        unset DESTDIR
-      else
-          __rvm_log "fail" "MacRuby can only be installed on a Darwin OS."
-      fi
-    ;;
-    ruby-enterprise|ree)
-      rvm_url="http://rubyforge.org/frs/download.php/58677/$rvm_ruby_package_name.tar.gz"
-      __rvm_log "info" "Installing Ruby Enterprise Edition from source to: $rvm_ruby_home"
-      pushd $rvm_source_path > /dev/null
-      if [ -d $rvm_ruby_src_path ]  ; then
-        cd $rvm_ruby_src_path
-      else
-        __rvm_log "info" "\tDownloading $rvm_ruby_package_name, this may take a while depending on your connection..."
-        __rvm_fetch $rvm_url
-        if [ $? -gt 0 ] ; then __rvm_log "error" "There was an error, please check $rvm_ruby_log_path/*.error.log" ; popd 2> /dev/null ; return 1 ; fi
-        __rvm_log "info" "\tExtracting $rvm_ruby_package_name..."
-        mkdir -p $rvm_ruby_src_path
-        nice -n $rvm_niceness tar xzf $rvm_archives_path/$rvm_ruby_package_name.tar.gz -C $rvm_source_path
-      fi
-      if [ $? -gt 0 ] ; then __rvm_log "error" "There was an error, please check $rvm_ruby_log_path/*.error.log" ; popd 2> /dev/null ; return 1 ; fi
-      __rvm_log "info" "\tInstalling $rvm_ruby_package_name, this may take a while, depending on your cpu(s)..."
-      mkdir -p $rvm_ruby_log_path
-      cd $rvm_ruby_src_path
-      nice -n $rvm_niceness ./installer -a $rvm_install_path/ruby-enterprise-$rvm_ruby_version-$rvm_ruby_patch_level --dont-install-useful-gems --no-tcmalloc > $rvm_ruby_log_path/install.log 2> $rvm_ruby_log_path/install.error.log
-      if [ $? -gt 0 ] ; then __rvm_log "error" "There was an error, please check $rvm_ruby_log_path/*.error.log" ; popd 2> /dev/null ; return 1 ; fi
-      chmod +x $rvm_ruby_home/bin/*
-      ln -fs $rvm_ruby_home/bin/ruby $rvm_install_path/bin/$rvm_ruby_package_name
-      __rvm_log "info" "\tInstalling rubygems dedicated to $rvm_ruby_package_name..."
-      rvm_gem_package_name="rubygems-1.3.5"
-      rvm_gem_url="http://rubyforge.org/frs/download.php/60718/$rvm_gem_package_name.tgz"
-      if [ -d $rvm_source_path/$rvm_gem_package_name ]  ; then
-        cd $rvm_source_path/$rvm_gem_package_name
-      else
-        __rvm_fetch $rvm_gem_url
-        if [ $? -gt 0 ] ; then __rvm_log "error" "There was an error, please check $rvm_ruby_log_path/*.error.log" ; popd 2> /dev/null ; return 1 ; fi
-        mkdir -p $rvm_source_path/$rvm_gem_package_name
-        nice -n $rvm_niceness tar zxf $rvm_archives_path/$rvm_gem_package_name.tgz -C $rvm_source_path
-      fi
-      if [ $? -gt 0 ] ; then __rvm_log "error" "There was an error, please check $rvm_ruby_log_path/*.error.log" ; popd 2> /dev/null ; return 1 ; fi
-      # Well this is fun... fix nil error on require_paths:
-      sed -i.orig "s/require_paths\.join/require_paths.to_a.join/" $rvm_source_path/$rvm_gem_package_name/lib/rubygems/gem_path_searcher.rb > $rvm_ruby_log_path/rubygems.install.log 2> $rvm_ruby_log_path/rubygems.install.error.log
-      nice -n $rvm_niceness $rvm_ruby_home/bin/ruby $rvm_source_path/$rvm_gem_package_name/setup.rb > $rvm_ruby_log_path/rubygems.install.log 2> $rvm_ruby_log_path/rubygems.install.error.log
-      __rvm_log "info" "Installation of $rvm_ruby_package_name complete."
-      popd 2> /dev/null
-      for rvm_gem_name in rake ; do
-        __rvm_log "info" "Installing $rvm_gem_name"
-        nice -n $rvm_niceness $rvm_ruby_home/bin/gem install $rvm_gem_name --no-rdoc --no-ri -q >> $rvm_ruby_log_path/gems.install.log 2> $rvm_ruby_log_path/gems.error.log
-      done
-      ;;
-    rbx|rubinius)
-      __rvm_reset # Requires 1.8 to install due to parsetree. TOOD: Check for 1.8 + parse-tree
-      rvm_ruby_repo_url=$rvm_rubinius_repo_url
-      rvm_ruby_configure=""
-      rvm_ruby_make="rake"
-      rvm_ruby_make_install="rake install"
-      #rvm_ruby_rev="head"
-      # TODO: Check if already git repo, then git pull origin master && build
-      if [ ! -d $rvm_install_path/$rvm_ruby_interpreter-$rvm_ruby_version -o ! -d $rvm_install_path/$rvm_ruby_interpreter-$rvm_ruby_version/.git ] ; then
-        rm -rf $rvm_install_path/$rvm_ruby_interpreter-$rvm_ruby_version
-        git clone --depth 1 $rvm_ruby_repo_url $rvm_install_path/$rvm_ruby_interpreter-$rvm_ruby_version
-      fi
-      cd $rvm_install_path/$rvm_ruby_interpreter-$rvm_ruby_version && $rvm_rubinius_jit rake build
-      if [ $? -gt 0 ] ; then __rvm_log "error" "There was an error, please check $rvm_ruby_log_path/*.error.log" ; popd 2> /dev/null ; return 1 ; fi
-      for binary in ruby irb ; do
-        ln -fs $rvm_install_path/$rvm_ruby_interpreter-$rvm_ruby_version/bin/rbx $rvm_install_path/$rvm_ruby_interpreter-$rvm_ruby_version/bin/$binary
-      done
-    ;;
-    jruby)
-      rvm_package_file="$rvm_ruby_interpreter-bin-$rvm_ruby_version"
-      rvm_url="http://dist.codehaus.org/$rvm_ruby_interpreter/$rvm_ruby_version/$rvm_package_file.zip"
-      rvm_jruby_repo_url="${rvm_jruby_repo_url:-"git://kenai.com/jruby~main"}"
-      __rvm_log "info" "Installing jRuby to: $rvm_ruby_home"
-      mkdir -p $rvm_ruby_log_path
-      pushd $rvm_source_path > /dev/null
-      if [ ! -z "$rvm_ruby_rev" ] ; then
-        if [ ! -d $rvm_install_path/$rvm_ruby_interpreter-$rvm_ruby_version -o ! -d $rvm_install_path/$rvm_ruby_interpreter-$rvm_ruby_version/.git ] ; then
-          git clone --depth 1 $rvm_jruby_repo_url $rvm_ruby_src_path
-          cd $rvm_ruby_src_path && ant
-        fi
-      else
-        if [ -d $rvm_ruby_src_path ]  ; then
-          cd $rvm_ruby_src_path
-        else
-          __rvm_log "info" "\tDownloading $rvm_package_file, this may take a while depending on your connection..."
-          __rvm_fetch $rvm_url
-          __rvm_log "info" "\tExtracting $rvm_package_file..."
-          nice -n $rvm_niceness unzip -q $rvm_archives_path/$rvm_package_file.zip -d $rvm_source_path
-          cd $rvm_ruby_src_path
-        fi
-      fi
-      if [ $? -gt 0 ] ; then __rvm_log "error" "There was an error, please check $rvm_ruby_log_path/*.error.log" ; popd 2> /dev/null ; return 1 ; fi
-      __rvm_log "info" "\tInstalling $rvm_ruby_package_name..."
-      mkdir -p $rvm_ruby_home/bin/
-      rsync -ag $rvm_ruby_src_path/ $rvm_ruby_home/
-      if [ $? -gt 0 ] ; then __rvm_log "error" "There was an error, please check $rvm_ruby_log_path/*.error.log" ; popd 2> /dev/null ; return 1 ; fi
-      cd $rvm_ruby_src_path/tool/nailgun && make > $rvm_ruby_log_path/install.nailgun.log 2> $rvm_ruby_log_path/install.error.nailgun.log
-      popd 2> /dev/null
-      chmod +x $rvm_ruby_home/bin/*
-      for binary in jruby jgem jirb ; do
-        ln -fs $rvm_ruby_home/bin/$binary $rvm_ruby_home/bin/${binary#j}
-      done
-      ln -fs $rvm_ruby_home/bin/ruby $rvm_install_path/bin/$rvm_ruby_package_name
-      for rvm_gem_name in rake jruby-openssl ; do
-        __rvm_log "info" "Installing $rvm_gem_name"
-        nice -n $rvm_niceness $rvm_ruby_home/bin/jgem install $rvm_gem_name --no-rdoc --no-ri -q >> $rvm_ruby_log_path/gems.install.log 2> $rvm_ruby_log_path/gems.error.log
-      done
-    ;;
-    ruby)
-      if [ -z "rvm_ruby_configure" ] ; then rvm_ruby_configure="--enable-shared=true" ; fi
-      __rvm_install-source $*
-    ;;
-    default)
-      __rvm_log "fail" "please specify a ruby implementation to install."
-    ;;
-    *) __rvm_log "fail" "Ruby implementation '$rvm_ruby_interpreter' is not known."
-  esac
-  if [ ! -z "$ruby_options" ] ; then
-    RUBYOPT=$ruby_options ; export RUBYOPT
-  fi
-}
-function __rvm_uninstall {
-  if [ -z "$rvm_selected" ] ; then __rvm_select $* ; fi
-  if [ ! -z "$rvm_ruby_package_name" ] ; then
-    for dir in $rvm_source_path $rvm_install_path ; do
-      if [ -d $dir/$rvm_ruby_package_name ] ; then
-        __rvm_log "info" "Removing $dir/$rvm_ruby_package_name..."
-        rm -rf $dir/$rvm_ruby_package_name
-      else
-        __rvm_log "info" "it seems that $dir/$rvm_ruby_package_name is already non existent."
-      fi
-      if [ -e $rvm_bin_path/$rvm_ruby_package_name ] ; then
-        rm -f $rvm_bin_path/$rvm_ruby_package_name
-      fi
-    done ; unset dir
-    rm -rf $rvm_gem_path/$rvm_ruby_interpreter/$rvm_ruby_version*/
-  else
-    __rvm_log "fail" "Cannot uninstall unknown package '$rvm_ruby_package_name'"
-  fi
-}
-# __rvm_select implementation version patch_level
-function __rvm_select {
-  rvm_ruby_interpreter="${1:-$rvm_ruby_interpreter}"
-  rvm_ruby_interpreter="${rvm_ruby_interpreter:-ruby}" # Default is standard ruby
-  if [ "$rvm_ruby_version" = "1.8" ] ; then rvm_ruby_version="1.8.6" ; fi
-  if [ "$rvm_ruby_version" = "1.9" ] ; then rvm_ruby_version="1.9.1" ; fi
-  case "$rvm_ruby_interpreter" in
-    macruby)
-      if [ "`uname`" = "Darwin" ] ; then
-        rvm_ruby_repo_url=$rvm_macruby_repo_url
-        rvm_ruby_version="head" # For now we are only supporting latest
-        unset rvm_ruby_patch_level
-      else
-        __rvm_log "fail" "MacRuby can only be installed on a Darwin OS."
-      fi
-    ;;
-    rbx|rubinius)
-      rvm_ruby_version="head"
-      rvm_ruby_version="head"
-      unset rvm_ruby_patch_level
-      rvm_ruby_repo_url=$rvm_rubinius_repo_url
-      rvm_ruby_configure=""
-      rvm_ruby_make="build"
-      rvm_ruby_make_install=""
-      #rvm_ruby_rev="head"
-    ;;
-    jruby)
-      rvm_ruby_version="${rvm_ruby_version:-1.3.1}"
-      unset rvm_ruby_patch_level
-      if [ "$rvm_ruby_version" != "1.2.0" -a "$rvm_ruby_version" != "1.3.1" ] ; then
-        __rvm_log "fail" "Unknown jRuby version: $rvm_ruby_version"
-      fi
-      alias jruby_ng="jruby --ng"
-      alias jruby_ng_server="jruby --ng-server"
-    ;;
-    ruby-enterprise|ree)
-      rvm_ruby_interpreter="ruby-enterprise"
-      rvm_ruby_version=${rvm_ruby_version:-1.8.6}
-      rvm_ruby_patch_level="${3:-20090610}"
-      if [ "$rvm_ruby_version" != "1.8.6" ] ; then
-        __rvm_log "fail" "Unknown Ruby Enterprise Edition version: $rvm_ruby_version"
-      fi
-    ;;
-    ruby)
-      if [ ! -z "$rvm_ruby_tag" ] ; then
-        rvm_ruby_version=$(echo $rvm_ruby_tag | sed 's/^v//' | sed 's/\///' | awk -F'_' '{print 1 "." $2 "." $3 }')
-        rvm_ruby_patch_level=$rvm_ruby_tag # $(echo $rvm_ruby_tag | sed 's/^v//' | sed 's/\///' | awk -F'_' '{print $4 }')
-      fi
-      rvm_ruby_version=${rvm_ruby_version:-1.8.6} # Default verison is 1.8.6
-      if [ "$rvm_ruby_version" = "1.9.1" ] ; then
-        rvm_ruby_patch_level="${rvm_ruby_patch_level:-p243}"
-      elif [ "$rvm_ruby_version" = "1.9.2" ] ; then
-        rvm_ruby_patch_level="${rvm_ruby_patch_level:-preview1}"
-      elif [ "$rvm_ruby_version" = "1.8.6" ] ; then
-        rvm_ruby_patch_level="${rvm_ruby_patch_level:-p383}"
-      elif [ "$rvm_ruby_version" = "1.8.7" ] ; then
-        rvm_ruby_patch_level="${rvm_ruby_patch_level:-p174}"
-      elif [ "$rvm_ruby_version" = "1.8.5" ] ; then
-        rvm_ruby_patch_level="${rvm_ruby_patch_level:-p115}"
-      elif [ "$rvm_ruby_version" = "1.8.0" -o "$rvm_ruby_version" = "1.8.1" -o "$rvm_ruby_version" = "1.8.2" -o "$rvm_ruby_version" = "1.8.3" -o "$rvm_ruby_version" = "1.8.4" ] ; then
-        unset rvm_ruby_patch_level
-      else
-        __rvm_log "fail" "Unknown ruby version: $rvm_ruby_version"
-      fi
-    ;;
-    default|system)
-      #noop?
-    ;;
-    *)
-      __rvm_log "fail" "Ruby implementation '$rvm_ruby_interpreter' is not known."
-  esac
-  if [ ! -z "$rvm_ruby_rev" ] ; then
-    if [ "$rvm_ruby_rev" = "head" -o "$rvm_ruby_rev" = "trunk" ] ; then
-      rvm_ruby_patch_level="head"
-    else
-      rvm_ruby_patch_level="$rvm_ruby_rev"
-    fi
-  fi
-  if [ ! -z "$rvm_ruby_interpreter" -a ! -z "$rvm_ruby_version" ] ; then
-    rvm_major_version=$(echo $rvm_ruby_version | awk -F'.' '{ print $2 }')
-    rvm_minor_version=$(echo $rvm_ruby_version | awk -F'.' '{ print $3 }')
-    if [ -z "$rvm_gem_set_name" ] ; then
-      rvm_gem_home="$rvm_gem_path/$rvm_ruby_interpreter/$rvm_ruby_version"
-    else
-      if [ ! -z "$rvm_gem_set_name_rm" -a -d $rvm_gem_path/$rvm_ruby_interpreter/$rvm_ruby_version-$rvm_gem_set_name ] ; then
-        rm -rf $rvm_gem_path/$rvm_ruby_interpreter/$rvm_ruby_version-$rvm_gem_set_name/
-        if [ "$rvm_gem_set_name_rm" = "$rvm_gem_set_name" ] ; then unset rvm_gem_set_name ; fi
-      else
-        rvm_gem_home="$rvm_gem_path/$rvm_ruby_interpreter/$rvm_ruby_version-$rvm_gem_set_name"
-      fi
-    fi
-    mkdir -p $rvm_gem_home
-    if [ -z "$rvm_ruby_patch_level" ] ; then
-      rvm_ruby_package_name="${rvm_ruby_package_name:-"$rvm_ruby_interpreter-$rvm_ruby_version"}"
-      rvm_ruby_home="${rvm_ruby_home:-"$rvm_install_path/$rvm_ruby_interpreter-$rvm_ruby_version"}"
-    else
-      rvm_ruby_package_name="${rvm_ruby_package_name:-"$rvm_ruby_interpreter-$rvm_ruby_version-$rvm_ruby_patch_level"}"
-      rvm_ruby_home="${rvm_ruby_home:-"$rvm_install_path/$rvm_ruby_interpreter-$rvm_ruby_version-$rvm_ruby_patch_level"}"
-    fi
-    rvm_ruby_log_path="$rvm_log_path/$rvm_ruby_package_name"
-    rvm_ruby_src_path="$rvm_source_path/$rvm_ruby_package_name"
-    rvm_ruby_binary="$rvm_ruby_home/bin/ruby"
-    rvm_ruby_irbrc="$rvm_ruby_home/.irbrc"
-    rvm_selected=1
-  else
-    unset rvm_selected
-  fi
-}
-function __rvm_use {
-  if [ -z "$rvm_selected" ] ; then __rvm_select $* ; fi
-  if [ -z "$rvm_ruby_interpreter" ] ; then rvm_ruby_interpreter="default" ; fi
-  if [ "$rvm_ruby_interpreter" = "default" -o "$rvm_ruby_interpreter" = "system" ] ; then
-    unset GEM_HOME MY_RUBY_HOME IRBRC
-    PATH="$rvm_default_path" ; export PATH
-    if [ "$rvm_ruby_interpreter" = "default" -a -s $rvm_install_path/current ] ; then
-      source $rvm_install_path/current
-    fi
-  else
-    GEM_HOME=$rvm_gem_home ; export GEM_HOME
-    MY_RUBY_HOME=$rvm_ruby_home ; export MY_RUBY_HOME
-    IRBRC="$rvm_ruby_irbrc" ; export IRBRC
-    # Install if not installed
-    if [ ! -d $MY_RUBY_HOME ] ; then
-      __rvm_log "warn" "$rvm_ruby_interpreter $rvm_ruby_version is not installed."
-      __rvm_install-ruby $rvm_ruby_interpreter $rvm_ruby_version $rvm_ruby_patch_level
-    fi
-    if [ ! -s "$rvm_ruby_irbrc" ] ; then
-      rvm_irbrc_file=$(cat <<Config
-      require "irb/completion" rescue nil
-  @prompt = {
-    :PROMPT_I => "${rvm_ruby_package_name} > ", # default prompt
-    :PROMPT_S => "${rvm_ruby_package_name}%l> ", # known continuation
-    :PROMPT_C => "${rvm_ruby_package_name} > ",
-    :PROMPT_N => "${rvm_ruby_package_name} ?> ", # unknown continuation
-    :RETURN => " => %s \n",
-    :AUTO_INDENT => true
-  }
-  @prompt_mode = :DEFAULT
-  IRB.conf[:PROMPT][@prompt_mode] = @prompt
-  IRB.conf[:PROMPT_MODE] = @prompt_mode
-Config
-)
-      if [ -s ~/.irbrc ] ; then
-        cat ~/.irbrc >  $rvm_ruby_home/.irbrc
-      fi
-      echo "$rvm_irbrc_file" >> $rvm_ruby_home/.irbrc
-    fi
-    PATH=$MY_RUBY_HOME/bin:$GEM_HOME/bin:$rvm_install_path/bin:$rvm_default_path ; export PATH
-    rvm_prompt="$rvm_ruby_package_name" ; export rvm_prompt
-    if [ ! -z "$rvm_set_prompt" -a ! -z "$PS1" ] ; then
-      PS1="\033[0;32m${rvm_prompt}\033[0m:: ${rvm_default_ps1}" ; export PS1
-    fi
-    if [ ! -z "$rvm_set_default" ] ; then
-      RUBY_VERSION="$($MY_RUBY_HOME/bin/ruby -v | sed 's/^\(.*\) (.*$/\1/')"
-      export GEM_HOME MY_RUBY_HOME RUBY_VERSION
-      echo "PATH=$MY_RUBY_HOME/bin:$GEM_HOME/bin:$rvm_install_path/bin:$rvm_default_path ; export PATH" > $rvm_install_path/current
-      for variable in rvm_prompt RUBY_VERSION GEM_HOME MY_RUBY_HOME ; do
-        eval "export $variable"
-        eval value=\$${variable}
-        echo "${variable}='$value' ; export ${variable}" >> $rvm_install_path/current
-      done
-    fi
-  fi
-}
-function __rvm_symlinks {
-  mkdir -p ${rvm_install_path}/bin
-  for release in `/bin/ls $rvm_install_path | grep 'ruby-'` ; do
-    for binary in irb gem rdoc ri erb ; do
-      if [ -x $rvm_install_path/$release/bin/$binary ] ; then
-        ln -fs $rvm_install_path/$release/bin/$binary $rvm_install_path/bin/$binary-${release#ruby-}
-      fi
-    done
-  done
-}
-function __rvm_list {
-  if [ "$rvm_all" ] ; then
-    svn list http://svn.ruby-lang.org/repos/ruby/tags/ | grep 'v1_[8|9]' | sed 's/^v1_//' | sed 's/\/$//' | awk -F'_' '{print "1."$1"."$2 " -l "$3}' | sed 's/p$//'
-    echo "jruby 1.2.0"
-    echo "jruby 1.3.0"
-    echo "jruby 1.3.1"
-    echo "jruby head"
-    echo "rubinius head"
-    echo "rbx head"
-    echo "ree 20090610"
-  else
-    echo -e "\nruby:\n$(/bin/ls -l $rvm_install_path/ | awk '/ ruby-[1-2].*/ { print " - " $NF  }')\n"
-    echo -e "jruby:\n$(/bin/ls -l $rvm_install_path/ | awk '/jruby-.*/ { print " - " $NF }')\n"
-    echo -e "ree:\n$(/bin/ls $rvm_install_path/ | awk '/ruby-enterprise-.*/ { print " - " $NF }')\n"
-    echo -e "system:\n - ($($default_system_ruby -v))\n"
-  fi
-}
-function __rvm_reset {
-  PATH="$rvm_install_path/bin:$rvm_default_path" ; export PATH
-  for variable in RUBY_VERSION GEM_HOME MY_RUBY_HOME rvm_prompt ; do unset $variable ; done
-  rm -f $rvm_install_path/default*
-  rm -f $rvm_install_path/current
-  __rvm_select "system"
-}
-function __rvm_implode {
-  while : ; do
-    __rvm_log "warn" "Are you SURE you wish for rvm to implode? This will remove $rvm_install_path ? (type 'yes' or 'no')"
-    read response
-    if [ "$response" = "yes" ] ; then
-      if [ -d $rvm_install_path ] ; then
-        __rvm_log "info" "Hai! Removing $rvm_install_path"
-        rm -rf $rvm_install_path/
-      else
-        __rvm_log "info" "It appears that $rvm_install_path is already non existant."
-      fi
-      break
-    elif [ "$response" = "no" ] ; then
-      __rvm_log "info" "Cancelling implosion, no harm done :)"
-      break
-    fi
-  done
-}
-function __rvm_gem-dir {
-  if [ -z "$rvm_selected" ] ; then __rvm_select $* ; fi
-  mkdir -p $rvm_gem_home
-  echo $rvm_gem_home
-}
-function __rvm_src-dir {
-  if [ -z "$rvm_selected" ] ; then __rvm_select $* ; fi
-  if [ -z "$rvm_ruby_src_path" ] ; then
-    __rvm_log "fail" "No source directory exists for the default implementation."
-  else
-    echo "$rvm_ruby_src_path"
-  fi
-}
-# clones from source implementation/version to current
-function __rvm_gem-dup {
-  if [ "$1" = "default" ] ; then
-    rvm_source_gem_dir="$rvm_default_user_gem_path"
-  elif [ "$1" = "system" ] ; then
-    rvm_source_gem_dir="$rvm_default_system_gem_path"
-  else
-    rvm_source_gem_dir=${1:-$rvm_default_user_gem_path} # TODO: check for and remove trailing /gems
-  fi
-  if [ ! -z "$rvm_source_gem_dir" ] ; then
-    for rvm_gem_name_version in `/bin/ls $rvm_source_gem_dir/gems` ; do
-      rvm_gem_name=${rvm_gem_name_version%-*}
-      rvm_gem_version=${rvm_gem_name_version##*-}
-      if [ -d $GEM_HOME/gems/$rvm_gem_name_version ] ; then
-        echo "$rvm_gem_name_version already installed."
-      else
-        __rvm_gi $rvm_source_gem_dir/cache/$rvm_gem_name-$rvm_gem_version.gem
-      fi
-    done
-    unset rvm_gem_name_version rvm_gem_name rvm_gem_version
-  else
-    __rvm_log "fail" "Unknown $rvm_ruby_interpreter version: $rvm_ruby_version"
-  fi
-}
-function __rvm_run {
-  log_file="1" ; shift
-  command="$*"
-  if [ $rvm_debug ] ; then __rvm_log "debug" "Executing: $command" ; fi
-  eval "nice -n $rvm_niceness $command" > $rvm_ruby_log_path/log_file.log 2> $rvm_ruby_log_path/log_file.error.log
-  if [ $? -gt 0 ] ; then __rvm_log "error" "There was an error, please check $rvm_ruby_log_path/log_file.error.log" ; popd 2> /dev/null ; return 1 ; fi
-  unset log_file command
-}
-function __rvm_cache {
-  rvm_cache_file="$rvm_config_path/cache"
-  touch $rvm_cache_file
-  key="$1" ; shift
-  if [ -z "$key" ] ; then
-    __rvm_log "fail" "__rvm_cache must be called with at least one argument: __rvm_cache key [value]"
-  else
-    if [ "$key" = "unset" -o "$key" = "delete" ] ; then
-      sed -i~ "s/^$2=.*$//" $rvm_cache_file
-    else
-      value="$*"
-      if [ -z "$value" ] ; then # get
-        grep "^$key=" $rvm_cache_file | awk -F'=' '{print $2}'
-      else # set
-        if [ -z "$(grep "^$key=" $rvm_cache_file)" ] ; then # append
-          echo "$key=$value" >> $rvm_cache_file
-        else # overwrite
-          sed -i~ "s/^$key=.*$/$key=$value/" $rvm_cache_file
-        fi
-      fi
-    fi
-  fi
-}
-function __rvm_cleanup-variables {
-  unset rvm_selected rvm_action rvm_ruby_interpreter rvm_ruby_patch_level rvm_ruby_version rvm_irbrc_file rvm_ruby_irbrc rvm_source_path rvm_install_path rvm_debug rvm_prefix_path rvm_ruby_package_name rvm_gem_path rvm_command rvm_error_message IRBRC rvm_ruby_home rvm_ruby_binary rvm_gem_set_name rvm_delete_flag rvm_ruby_tag rvm_ruby_rev rvm_url rvm_ruby_make rvm_ruby_make_install rvm_config_path rvm_bin_path rvm_force rvm_set_prompt rvm_all
-}
-function __rvm_get-user-defaults {
-  # NOW load defaults settings. TODO: root user loads /etc/rvmrc
-  if [ -s ~/.rvmrc ] ; then source ~/.rvmrc ; fi
-}
-function __rvm_parse-args {
-  while [ $# -gt 0 ] ; do
-    rvm_token="$1" ; shift
-    case "$rvm_token" in
-      install|uninstall|path|info|setup|version|srcdir|list|symlinks|reset|debug|reload|usage|help|implode|update)
-        rvm_action=$rvm_token
-      ;;
-      use)
-        rvm_action=$rvm_token
-        if [ "$1" = "default" ] ; then
-          rvm_ruby_interpreter="system" ; shift
-        elif [ -z "$1" ] ; then
-          rvm_ruby_interpreter="system"
-        fi
-      ;;
-      ruby|jruby|ree|macruby|rbx|rubinius|default|all)
-        rvm_ruby_interpreter="$rvm_token"
-        rvm_action="${rvm_action:-use}"
-      ;;
-      gemdir)
-        rvm_action=$rvm_token
-        if [ "$1" = "system" ] ; then
-          rvm_ruby_interpreter="system" ; shift
-        fi
-        if [ "$1" = "user" ] ; then
-          rvm_ruby_interpreter="user"  ; shift
-        fi
-        rvm_ruby_interpreter="${rvm_ruby_interpreter:-current}"
-      ;;
-      gemdup)
-        rvm_action=$rvm_token
-        if [ -z "$1" ] ; then
-          rvm_ruby_interpreter="default"
-        elif [ "$1" = "system" ] ; then
-          rvm_ruby_interpreter=$1 ; shift
-        elif [ "$1" = "default" ] ; then
-          rvm_ruby_interpreter=$1 ; shift
-        else
-          rvm_ruby_interpreter=$1 ; shift
-          rvm_ruby_version=$2 ; shift
-        fi
-      ;;
-      do|rubydo)
-        rvm_action=$rvm_token
-        temp=$(echo $1 | awk '{print substr($1, 0, 1)}')
-        if [ "$temp" != "-" ] ; then
-          if [ ! -z "$(echo $temp | grep '[0-9]')" ] ; then
-            rvm_ruby_version=$(echo "$1" | tr ',' ' ') ; shift
-          else
-            rvm_ruby_version=$1 ; shift
-          fi
-        else
-          unset rvm_ruby_version
-        fi
-        unset rvm_ruby_interpreter
-      ;;
-      1.8|1.8.0|1.8.1|1.8.2|1.8.3|1.8.4|1.8.5|1.8.6|1.8.7|1.9|1.9.1|1.9.2)
-                         rvm_ruby_interpreter="ruby"
-                         rvm_ruby_version="$rvm_token"
-                         rvm_action="${rvm_action:-use}"
-      ;;
-      1.2.0|1.3.1)
-                         rvm_ruby_interpreter="jruby"
-                         rvm_ruby_version="$rvm_token"
-                         rvm_action="${rvm_action:-use}"
-      ;;
-      -v|--version)
-                         if [ -z "$1" ] ; then
-                           rvm_action="version"
-                         else
-                           rvm_ruby_version="$1"
-                         fi
-                         shift
-      ;;
-      -t|--tag)          rvm_ruby_tag="$1";
-                         rvm_action="${rvm_action:-use}"
-                         shift                             ;;
-      -r|--rev)          rvm_ruby_rev="$1";
-                         rvm_action="${rvm_action:-use}"
-                         shift                             ;;
-      -b|--branch)       rvm_ruby_rev="$1";
-                         rvm_action="${rvm_action:-use}"
-                         shift                             ;;
-      -P|--prefix)       rvm_prefix_path="$1"      ; shift ;;
-      -B|--bin)          rvm_bin_path="$1"         ; shift ;;
-      -S|--source)       rvm_source_path="$1"      ; shift ;;
-      -A|--archive)      rvm_archives_path="$1"    ; shift ;;
-      -G|--gems)         rvm_gem_path="$1"         ; shift ;;
-      -C|--configure)
-        if [ ! -z "$1" ] ; then
-          rvm_ruby_configure="$(echo $1 | tr ',' ' ')"
-          shift
-        else
-          rvm_action="error"
-          rvm_error_message="--configure *must* be followed by configure flags."
-          break;
-        fi
-      ;;
-      -M|--make)         rvm_ruby_make="$1"        ; shift ;;
-      -I|--make-install) rvm_ruby_make_install="$1"   ; shift ;;
-      -l|--level)        rvm_ruby_patch_level="$1" ; shift ;;
-      -n|--nice)         rvm_niceness="$1"         ; shift ;;
-      -f|--file)         rvm_ruby_args="$1"        ; shift ;;
-      -h|--help)         rvm_action=help           ; shift ;;
-      -d|--default)      rvm_set_default=1                 ;;
-      --head)            rvm_ruby_rev="head"               ;;
-      --trace|--debug)   rvm_debug=1                       ;;
-      --force)           rvm_force=1                       ;;
-      --set-prompt)      rvm_set_prompt=1                  ;;
-         --all)          rvm_all=1                 ; shift ;;
-      -m|--gem-set)      rvm_gem_set_name="$1"     ; shift ;;
-         --rm-gem-set)   rvm_gem_set_name_rm="$1"  ; shift ;;
-         --jit)          rvm_rubinius_jit="RBX_LLVM=1"     ;;
-      default|system)
-        rvm_action="use"
-        rvm_ruby_interpreter="system"
-      ;;
-      *)
-      rvm_action="error"
-      rvm_error_message="Unrecognized command line argument(s): '$rvm_token $*'"
-      break;
-    esac
-    if [ ! -z "$rvm_ruby_args" -o ! -z "$rvm_error_message" ] ; then break; fi
-  done
-  if [ ! -z "$rvm_error_message" ] ; then popd 2> /dev/null ; return 1 ; fi
-  if [ -z "$rvm_debug" ] ; then set +x ; else set -x ; fi
-}
-function rvm {
-  __rvm_cleanup-variables
-  __rvm_get-user-defaults
-  __rvm_initialize
-  __rvm_set-defaults
-  __rvm_parse-args $*
-  case "$rvm_action" in
-    install)   __rvm_install-ruby $rvm_ruby_interpreter $rvm_ruby_version $rvm_ruby_patch_level ;;
-    uninstall) __rvm_uninstall    $rvm_ruby_interpreter $rvm_ruby_version $rvm_ruby_patch_level ;;
-    use)       __rvm_use          $rvm_ruby_interpreter $rvm_ruby_version $rvm_ruby_patch_level ;;
-    list)      __rvm_list                                                                       ;;
-    gemdir)    __rvm_gem-dir      $rvm_ruby_interpreter $rvm_ruby_version $rvm_ruby_patch_level ;;
-    srcdir)    __rvm_src-dir      $rvm_ruby_interpreter $rvm_ruby_version $rvm_ruby_patch_level ;;
-    gemdup)    __rvm_gem-dup      $rvm_ruby_interpreter $rvm_ruby_version $rvm_ruby_patch_level ;;
-    symlinks)  __rvm_symlinks                                                                   ;;
-    version)   __rvm_version                                                                    ;;
-    rubydo)
-               if [ ! -z "$rvm_ruby_version" ] ; then
-                 rvm_ruby_versions=$(echo $rvm_ruby_version | tr ',' ' ')
-                 for rvm_ruby_version in $rvm_ruby_versions ; do
-                   temp=$(echo $rvm_ruby_version | awk '{print substr($1, 0, 1)}')
-                   if [ ! -z "$(echo $temp | grep '[0-9]')" ] ; then
-                     rvm_ruby_interpreter="ruby"
-                   else
-                     rvm_ruby_interpreter="$rvm_ruby_version"
-                     unset rvm_ruby_version
-                   fi
-                   unset temp
-                   __rvm_select $rvm_ruby_interpreter $rvm_ruby_version
-                   rvm_command="$rvm_ruby_binary $rvm_ruby_args"
-                   echo "$(basename $rvm_ruby_binary):"
-                   eval $rvm_command
-                   unset rvm_ruby_interpreter rvm_ruby_patch_level rvm_ruby_version rvm_ruby_package_name rvm_ruby_home rvm_ruby_irbrc rvm_ruby_binary
-                 done
-               else # all
-                 rvm_ruby_versions=`/bin/ls $rvm_install_path/bin/ruby-*`
-                 for rvm_ruby_binary in $rvm_ruby_versions ; do
-                   if [ -x $rvm_ruby_binary ] ; then
-                     rvm_command="$rvm_ruby_binary $rvm_ruby_args"
-                     echo "$(basename $rvm_ruby_binary):"
-                     eval $rvm_command
-                   fi
-                 done
-               fi
-               ;;
-    reset)     __rvm_reset                                                          ;;
-               # TODO: how can we use bin_path here for reload, default file?
-    reload)    source ~/.rvm/scripts/rvm                                            ;;
-    implode)   __rvm_implode                                                        ;;
-    update)
-      if [ "$rvm_ruby_rev" = "head" ] ; then
-        if [ -d $rvm_source_path/rvm/.git ] ; then
-          cd $rvm_source_path/rvm/ && git pull origin master
-        else
-          cd $rvm_source_path && git clone git://github.com/wayneeseguin/rvm.git && cd rvm/
-        fi
-        ./scripts/rvm-update
-      else
-        # TODO: rvm_install_path:
-        gem install rvm --no-rdoc --no-ri -q && rvm-update && source ~/.rvm/scripts/rvm
-      fi
-    ;;
-    error)     __rvm_log "fail" "$rvm_error_message ( see: rvm usage )" ; popd 2> /dev/null ; return 1; ;;
-    info|debug)
-               __rvm_version
-cat <<-Info
-ruby:
-  interpreter:  "$(ruby -v | awk '{print $1}')"
-  version:      "$(ruby -v | awk '{print $2}')"
-  date:         "$(ruby -v | sed 's/^.*(\([0-9]\{4\}\(-[0-9][0-9]\)\{2\}\).*$/\1/')"
-  platform:     "$(ruby -v | sed 's/^.*\[//' | sed 's/\].*$//')"
-  patchlevel:   "$(ruby -v | sed 's/^.*(//' | sed 's/).*$//')"
-  full_version: "$(ruby -v)"
-homes:
-  gem:          "${GEM_HOME:-'not set'}"
-  ruby:         "${MY_RUBY_HOME:-'not set'}"
-binaries:
-  ruby:         "$(which ruby)"
-  irb:          "$(which irb)"
-  gem:          "$(which gem)"
-environment:
-  GEM_HOME:     "$GEM_HOME"
-  MY_RUBY_HOME: "$MY_RUBY_HOME"
-  IRBRC:        "$IRBRC"
-Info
-               if [ "$rvm_action" = "debug" ] ; then
-                 __rvm_log "info" "PATH:$(echo $PATH | awk -F":" '{print $1":"$2":"$3":"$4":"$5}')"
-                 for file in .bash_profile .bashrc .zshrc ; do
-                   if [ -s $file ] ; then
-                     __rvm_log "debug" "~/$file:\n$(cat ~/$file | grep rvm)\n"
-                   fi
-                 done
-                 if [ -s $rvm_install_path/current ] ; then
-                   __rvm_log "debug" "$rvm_install_path/current:\n$($rvm_install_path/current)\n"
-                 fi
-                 if [ -e $rvm_install_path/bin/rvm ] ; then
-                   __rvm_log "debug" "rvm script in bin:\n$(ls -laht $rvm_install_path/bin/rvm)"
-                 fi
-               fi
-               return 0
-    ;;
-    usage|help) __rvm_usage ;;
-    *)
-               if [ ! -z "$rvm_action" ] ; then
-                 __rvm_log "fail"  "unknown action '$rvm_action'"
-               else
-                 __rvm_usage
-               fi
-               return 1
-  esac
-  if [ "$rvm_debug" = "1" ] ; then set +x ; unset rvm_debug ; fi
-}
+if [ -s ~/.rvmrc ] ; then source ~/.rvmrc ; fi
+eval rvm_path="${rvm_path:-~/.rvm}"
-if [ -f ~/.rvm/current ] ; then source ~/.rvm/current ; fi # magic :)
+source $rvm_path/scripts/rvm-utility
+source $rvm_path/scripts/rvm-selector
+source $rvm_path/scripts/rvm-ruby-installer # TODO: Script not function.
+source $rvm_path/scripts/rvm-cli
+if [ -f ~/.rvm/current ] ; then source ~/.rvm/current ; fi