#!/usr/bin/env bash

__rvm_info() {
  full_version=$(ruby -v)
  cat <<Info

system:
  uname: "$(uname -a)"

ruby:
  interpreter:  "$(echo $full_version | awk '{print $1}')"
  version:      "$(echo $full_version | awk '{print $2}')"
  date:         "$(echo $full_version | sed 's/^.*(\([0-9]\{4\}\(-[0-9][0-9]\)\{2\}\).*$/\1/')"
  platform:     "$(echo $full_version | sed 's/^.*\[//' | sed 's/\].*$//')"
  patchlevel:   "$(echo $full_version | sed 's/^.*(//' | sed 's/).*$//')"
  full_version: "$full_version"

homes:
  gem:          "${GEM_HOME:-'not set'}"
  ruby:         "${MY_RUBY_HOME:-'not set'}"

binaries:
  ruby:         "$(which ruby)"
  irb:          "$(which irb)"
  gem:          "$(which gem)"
  rake:         "$(which rake)"

environment:
  GEM_HOME:     "$GEM_HOME"
  MY_RUBY_HOME: "$MY_RUBY_HOME"
  IRBRC:        "$IRBRC"
Info
  unset full_version
}

__rvm_debug() {
  $rvm_scripts_path/log "debug" "PATH:\n$(echo $PATH | awk -F":" '{print $1":"$2":"$3":"$4":"$5}')"
  $rvm_scripts_path/log "debug" "uname -a: $(uname -a)"

  if [[ "Darwin" = "$(uname)" ]] ; then
    $rvm_scripts_path/log "debug" "uname -r: $(uname -r)"
    $rvm_scripts_path/log "debug" "uname -m: $(uname -m)"
    $rvm_scripts_path/log "debug" "sw_vers: $(sw_vers | tr "\n" ',')"
    $rvm_scripts_path/log "debug" "ARCHFLAGS: $ARCHFLAGS"
    $rvm_scripts_path/log "debug" "LDFLAGS: $LDFLAGS"
    $rvm_scripts_path/log "debug" "CFLAGS: $CFLAGS"
    $rvm_scripts_path/log "debug" "/Developer/SDKs/*:$(basename -a /Developer/SDKs/* | tr "\n" ',')"
  fi

  for file_name in $(echo $rc_files) ; do
    if [[ -s "$file_name" ]] ; then
      $rvm_scripts_path/log "debug" "$file_name:\n$(grep 'rvm' $file_name)"
    fi
  done

  if [[ "root" = "$(whoami)" ]] ; then
    debug_files="$rvm_path/default $rvm_path/system $rvm_path/config/db /etc/rvmrc /etc/gemrc"
  else
    debug_files="$rvm_path/default $rvm_path/system $rvm_path/config/db $HOME/.rvmrc $HOME/.gemrc"
  fi

  for file_name in $(echo $debug_files); do
    if [[ -f "$file_name" ]] && [[ -s "$file_name" ]] ; then
      $rvm_scripts_path/log "debug" "$file_name (filtered):\n$(cat $file_name | awk '!/assword|_key/')\n"
    fi
  done

  $rvm_scripts_path/log "debug" "gem sources:\n$(gem sources | awk '/gems/')"
}

if [[ ! -z "$ZSH_VERSION" ]] ; then __shell_array_start=1 ; else __shell_array_start=0 ; fi
__rvm_push() {
  array=$1 ; shift ; item=$2
  # TODO: allow loop over more arguments.
  eval "index=\$((\${#${array}[*]} + $__shell_array_start))"
  eval "${array}[${index}]=${item}"
  unset array item
}

__rvm_clean_path() {
  PATH=$(echo $PATH | tr -s ':' '\n' | awk '!($0 in a){a[$0];print}' | tr -s '\n' ':' | sed 's#:$##')
  export PATH
}

__rvm_remove_rvm_from_path() {
  PATH=$(echo $PATH | tr -s ':' '\n' | grep -v "\.rvm" | tr -s '\n' ':' | sed 's#:$##')
  export PATH
}

__rvm_gi() { gem install -q --no-rdoc --no-ri $* ; }

__rvm_run() {
  log_file_name="$1" ; command="$2" ; message="$3"
  rvm_ruby_log_path="${rvm_ruby_log_path:-$rvm_path/log}"
  mkdir -p $(dirname "$rvm_ruby_log_path/$log_file_name.log")

  if [[ ! -z "$message" ]] ; then $rvm_scripts_path/log "info" "$message" ; fi
  (( $rvm_debug_flag )) && $rvm_scripts_path/log "debug" "Executing: $command"
  touch "$rvm_ruby_log_path/$log_file_name.log" "$rvm_ruby_log_path/$log_file_name.error.log" # for zsh :(
  echo "[$(date +'%Y-%m-%d %H:%M:%S')] $command" | tee "$rvm_ruby_log_path/$log_file_name.log" > "$rvm_ruby_log_path/$log_file_name.error.log"
  if [[ -z "$rvm_niceness" ]] || [[ "0" = "$rvm_niceness" ]] ; then
    eval "$command" >> "$rvm_ruby_log_path/$log_file_name.log" 2>> "$rvm_ruby_log_path/$log_file_name.error.log"
  else
    eval "nice -n $rvm_niceness $command" >> $rvm_ruby_log_path/$log_file_name.log 2>> $rvm_ruby_log_path/$log_file_name.error.log
  fi
  if [[ $? -gt 0 ]] ; then $rvm_scripts_path/log "error" "Error running '$command', please check $rvm_ruby_log_path/$log_file_name.error.log" ; __rvm_pushpop ; return 1 ; fi
  unset log_file command
}

__rvm_cleanup_variables() {
  __rvm_unset_ruby_variables
  unset rvm_ruby_selected_flag rvm_action rvm_irbrc_file rvm_command rvm_error_message rvm_gem_set_name rvm_url rvm_force_flag rvm_all_flag rvm_reconfigure_flag rvm_make_flags rvm_bin_flag rvm_load_flag rvm_dump_flag rvm_self_flag rvm_gem_flag rvm_rubygems_flag rvm_debug_flag rvm_delete_flag rvm_summary_flag rvm_test_flag _rvm_spec_flag rvm_json_flag rvm_yaml_flag rvm_shebang_flag rvm_env_flag rvm_tail_flag rvm_use_flag rvm_dir_flag rvm_list_flag rvm_empty_flag rvm_file_name rvm_benchmark_flag rvm_clear_flag rvm_name_flag rvm_verbose_flag rvm_user_flag rvm_system_flag rvm_ruby_configure_flags CFLAGS LDFLAGS ARCHFLAGS
}

__rvm_unset_ruby_variables() {
  unset rvm_ruby_interpreter rvm_ruby_version rvm_ruby_repo_url rvm_ruby_package_name rvm_ruby_patch_level rvm_ruby_make rvm_ruby_make_install rvm_ruby_revision rvm_ruby_tag rvm_major_version rvm_minor_version rvm_ruby_gem_home rvm_ruby_binary rvm_ruby_home rvm_ruby_log_path rvm_ruby_src_path rvm_ruby_irbrc rvm_ruby_selected_flag rvm_ruby_string rvm_ruby_string rvm_ruby_src_path rvm_ruby_repo_url rvm_major_version rvm_minor_version rvm_ruby_gem_home rvm_head_flag rvm_ruby_configure rvm_ruby_mode
}

__rvm_load_rvmrc() {
  if [[ -f /etc/rvmrc ]] ; then source /etc/rvmrc ; fi
  if [[ -f $HOME/.rvmrc ]] ; then source $HOME/.rvmrc ; fi
}

__rvm_bin_scripts() {
  for rvm_ruby_binary in $(\ls $rvm_path/*/bin/ruby 2> /dev/null) ; do
    if [[ -x "$rvm_ruby_binary" ]] ; then
      rvm_ruby_string=$(dirname "$rvm_ruby_binary" | xargs dirname | xargs basename)
      __rvm_select
      __rvm_bin_script
    fi
  done
}

__rvm_bin_script() {
  if [[ -z "$rvm_ruby_selected_flag" ]] ; then __rvm_select $* ; fi
ruby_wrapper=$(cat <<RubyWrapper
#!/bin/bash

GEM_HOME=$rvm_ruby_gem_home ; export GEM_HOME
GEM_PATH=$rvm_ruby_gem_home ; export GEM_PATH
MY_RUBY_HOME=$rvm_ruby_home ; export MY_RUBY_HOME
PATH=$rvm_ruby_home/bin:$rvm_ruby_gem_home/bin:\$PATH ; export PATH

exec "$rvm_ruby_binary" "\$@"
RubyWrapper
)
  rm -f $rvm_path/bin/$rvm_ruby_package_name
  echo "$ruby_wrapper" > $rvm_path/bin/$rvm_ruby_package_name
  unset ruby_wrapper
  chmod +x $rvm_path/bin/$rvm_ruby_package_name
}

__rvm_load_defaults() {
  if [[ ! -s "$rvm_path/system" ]] ; then
    for variable in RUBY_VERSION GEM_HOME GEM_PATH MY_RUBY_HOME ; do
      eval value=\$${variable}
      if [[ -z "$value" ]] ; then
        echo "unset ${variable}" >> $rvm_path/system
      else
        eval "export $variable"
        eval value=\$${variable}
        echo "${variable}='$value' ; export ${variable}" >> $rvm_path/system
      fi
    done
  fi

  rvm_system_ruby=$($rvm_scripts_path/db "$rvm_config_path/db" "system_ruby")
  if [[ ! -z "$rvm_system_ruby" ]] ; then
    rvm_system_ruby=$(which ruby)
    if [[ $? -ne 0 ]] ; then
      $rvm_scripts_path/log "info" "System ruby not found, no db will be stored."
    else
      $rvm_scripts_path/db "$rvm_config_path/db" "system_ruby" "$rvm_system_ruby"

      # Now store system system & user gem paths
      rvm_system_user_gem_path=$($rvm_scripts_path/db "$rvm_config_path/db" "system_user_gem_path")
      if [[ -z "$rvm_system_user_gem_path" ]] ; then
        rvm_system_user_gem_path=$( rvm system ; gem env gemdir user; )
        $rvm_scripts_path/db "$rvm_config_path/db" "system_user_gem_path" "$rvm_system_user_gem_path"
      fi
      rvm_system_gem_path=$($rvm_scripts_path/db "$rvm_config_path/db" "system_gem_path")
      if [[ -z "$rvm_system_gem_path" ]] ; then
        rvm_system_gem_path=$( rvm system ; gem env gemdir; )
        $rvm_scripts_path/db "$rvm_config_path/db" "system_gem_path" "$rvm_system_gem_path"
      fi
    fi
  fi
}

__rvm_reset() {
  PATH=$(echo $PATH | tr ':' '\n' | awk '$0 !~ /rvm/' | paste -sd : -)
  PATH=$rvm_bin_path:$PATH ; export PATH

  for variable in RUBY_VERSION GEM_HOME MY_RUBY_HOME ; do unset $variable ; done

  for file in system default ; do
    if [[ -f "$rvm_path/$file" ]] ; then rm -f $rvm_path/$file ; fi
  done
  rvm_ruby_interpreter="system"
  __rvm_select

  for system_config in system_ruby system_gem_path system_user_gem_path ; do
    $rvm_scripts_path/db "$rvm_config_path/db" "$system_config" "delete"
  done ; unset system_config variable

  rm -f $rvm_path/bin/ruby $rvm_path/bin/gem $rvm_path/bin/rake $rvm_path/bin/irb $rvm_path/bin/default*
}

__rvm_implode() {
  while : ; do
    $rvm_scripts_path/log "warn" "Are you SURE you wish for rvm to implode? This will remove $rvm_path ? (type 'yes' or 'no')"
    read response
    if [[ "yes" = "$response" ]] ; then
      if [[ "/" = "$rvm_path" ]] ; then
        $rvm_scripts_path/log "error" "remove '/' ?!... NO!"
      else
        if [[ -d "$rvm_path" ]] ; then
          $rvm_scripts_path/log "info" "Hai! Removing $rvm_path"
          rm -rf $rvm_path/
          $rvm_scripts_path/log "info" "$rvm_path has been removed."
        else
          $rvm_scripts_path/log "info" "It appears that $rvm_path is already non existant."
        fi
      fi
      break
    elif [[ "no" = "$response" ]] ; then
      $rvm_scripts_path/log "info" "Cancelling implosion, no harm done :)"
      break
    fi
  done
}

__rvm_source_dir() {
  if [[ -z "$rvm_ruby_selected_flag" ]] ; then __rvm_select $* ; fi
  if [[ -z "$rvm_ruby_src_path" ]] ; then
    $rvm_scripts_path/log "fail" "No source directory exists for the default implementation."
  else
    echo "$rvm_ruby_src_path"
  fi
}

__rvm_list() {
  if [[ ! -z "$rvm_all_flag" ]] ; then
    while read -r tag
    do
      prefix="$(echo ${tag/\//} | sed 's#^v1_##' | awk -F'_' '{print "(ruby-)1."$1"."$2}' | sed 's#p$##')"
      echo "${prefix}-t${tag/\//}"
      unset prefix tag
    done < <(svn list http://svn.ruby-lang.org/repos/ruby/tags/ | awk '/^v1_[8|9]/')
    echo -e "(ruby-)1.8.6(-p383)\n(ruby-)1.8.6-head\n(ruby-)1.8.7(-p174)\n(ruby-)1.8.7-head\n(ruby-)1.9.1(-p243)\n(ruby-)1.9.1-head\n(ruby-)1.9.2-preview1"
    echo -e "jruby-1.2.0\njruby-1.3.0\njruby-1.3.1\njruby(-1.4.0) # the default\njruby-head"
    echo -e "rbx(-head) # rubinius head, the default rbx \nrbx(-head) --jit (rubinius head with LLVM enabled)"
    echo -e "ree-1.8.6\nree(-1.8.7) # the default\nree-1.8.6-head\nree-1.8.7-head"
    echo -e "mput(-head) # shyouhei head, the default mput"
    if [[ "Darwin" = "$(uname)" ]] ; then
      echo -e "macruby(-nightly) # the default macruby\nmacruby-head # Build from the macruby git repository"
    fi
  else
    current_ruby="$(which ruby | xargs dirname | xargs dirname | xargs basename 2> /dev/null)"
    for version in $(\ls -l $rvm_path/ 2> /dev/null | awk '/ ruby-[1-2].*/ { print $NF  }') ; do
      string=$($rvm_path/$version/bin/ruby -v)
      if [[ "$version" = "$current_ruby" ]] ; then
        echo -e "=> $(tput setaf 2)$version$(tput sgr0)  ( ruby -v # => $string) )"
        selected="1"
      else
        echo -e "   $(tput setaf 2)$version$(tput sgr0)  ( ruby -v # => $string) )"
      fi
    done ; unset version

    for version in $(\ls $rvm_path/ 2> /dev/null | awk '/ree-.*/ { print $NF }') ; do
      string="$($rvm_path/$version/bin/ruby -v | tr "\n" ' ' )"
      if [[ "$version" = "$current_ruby" ]] ; then
        echo -e "=> $(tput setaf 2)$version$(tput sgr0)  ( ruby -v # => $string) )"
        selected="1"
      else
        echo -e "   $(tput setaf 2)$version$(tput sgr0)  ( ruby -v # => $string) )"
      fi
    done ; unset version

    for version in $(\ls $rvm_path/ 2> /dev/null | awk '/mput-.*/ { print $NF }') ; do
      string="$($rvm_path/$version/bin/ruby -v | tr "\n" ' ' )"
      if [[ "$version" = "$current_ruby" ]] ; then
        echo -e "=> $(tput setaf 2)$version$(tput sgr0)  ( ruby -v # => $string) )"
        selected="1"
      else
        echo -e "   $(tput setaf 2)$version$(tput sgr0)  ( ruby -v # => $string) )"
      fi
    done ; unset version

    for version in $(\ls $rvm_path/ 2> /dev/null | awk '/jruby-.*/ { print $NF }') ; do
      string=$($rvm_path/$version/bin/ruby -v)
      if [[ "$version" = "$current_ruby" ]] ; then
        echo -e "=> $(tput setaf 2)$version$(tput sgr0)  ( ruby -v # => $string) )"
        selected="1"
      else
        echo -e "   $(tput setaf 2)$version$(tput sgr0)  ( ruby -v # => $string) )"
      fi
    done ; unset version

    # for version in $(\ls $rvm_path/ 2> /dev/null | awk '/rbx-.*/ { print $NF }') ; do
    for version in "rbx-head" ; do
      if [[ -f "$rvm_path/$version/bin/ruby" ]] ; then
        string="$($rvm_path/$version/bin/ruby -v | tr "\n" ' ' )"
        if [[ "$version" = "$current_ruby" ]] ; then
          echo -e "=> $(tput setaf 2)$version$(tput sgr0)  ( ruby -v # => $string) )"
          selected="1"
        else
          echo -e "   $(tput setaf 2)$version$(tput sgr0)  ( ruby -v # => $string) )"
        fi
      fi
    done ; unset version


    if [[ "Darwin" = "$(uname)" ]] ; then
      for version in $(\ls $rvm_path/ 2> /dev/null | awk '/macruby-.*/ { print $NF }') ; do
        string="$($rvm_path/$version/bin/ruby -v | tr "\n" ' ' )"
        if [[ "$version" = "$current_ruby" ]] ; then
          echo -e "=> $(tput setaf 2)$version$(tput sgr0)  ( ruby -v # => $string) )"
          selected="1"
        else
          echo -e "   $(tput setaf 2)$version$(tput sgr0)  ( ruby -v # => $string) )"
        fi
      done ; unset version
    fi

    if [[ -f "$rvm_path/default" ]] && [[ -s $rvm_path/default ]] ; then
      version=$(grep '^MY_RUBY_HOME' $rvm_path/default | awk -F"'" '{print $2}' | xargs basename)
      if [[ ! -z "$version" ]] ; then
        string=$($rvm_path/$version/bin/ruby -v)
        if [[ "$version" = "$current_ruby" ]] ; then
          echo -e "=> $(tput setaf 3)(default)$(tput sgr0) $(tput setaf 2)$version$(tput sgr0)  ( ruby -v # => $string) )"
          selected="1"
        else
          echo -e "   $(tput setaf 3)(default)$(tput sgr0) $(tput setaf 2)$version$(tput sgr0)  ( ruby -v # => $string) )"
        fi
      fi ; unset version
    fi

    system_version=$(rvm system ; ruby -v 2> /dev/null)
    if [[ ! -z "$system_version" ]] ; then
      if [[ "$($(which ruby) -v)" = "$system_version" ]] ; then
        echo -e "=> $(tput setaf 2)system$(tput sgr0) ( ruby -v # => $system_version )\n"
      else
        echo -e "   $(tput setaf 2)system$(tput sgr0) ( ruby -v # => $system_version )\n"
      fi
    fi ; unset current_ruby version selected
  fi
}

__rvm_initialize() {
  rvm_ruby_load_path="."
  rvm_ruby_require=""

  __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_src_path $rvm_bin_path $rvm_archives_path $rvm_gem_path $rvm_temp_path
}

__rvm_update() {
  if [[ "head" = "$rvm_ruby_revision" ]] || [[ ! -z "$rvm_self_flag" ]] || [[ "update" = "$rvm_action" ]] || [[ ! -z "$rvm_update_flag" ]] ; then
    __rvm_version
    __rvm_update_rvm
  fi
  if [[ ! -z "$rvm_bin_flag" ]] ; then __rvm_bin_scripts ; fi
  if [[ ! -z "$rvm_rubygems_flag" ]] ; then __rvm_rubygems_setup ; fi
  __rvm_hook "after_update"
}

__rvm_update_rvm() {
  mkdir -p "$rvm_src_path"
  __rvm_pushpop "$rvm_src_path"
  if [[ "head" = "$rvm_ruby_revision" ]] ; then
    if [[ -d "$rvm_src_path/rvm/.git" ]] ; then
      builtin cd $rvm_src_path/rvm/ && git pull origin master && ./scripts/install
    else
      builtin cd $rvm_src_path && git clone git://github.com/wayneeseguin/rvm.git && builtin cd rvm/ && ./install
    fi
  else
    # TODO: rvm_install_path:
    gem install rvm --no-rdoc --no-ri -q rvm && $(gem env gemdir user)/bin/rvm-install && source $rvm_path/scripts/rvm
  fi
  __rvm_pushpop
}

__rvm_reboot() {
  $rvm_scripts_path/log "warn" "Do you wish to reset rvm? ('yes', or 'no')"
  read response
  if [[ "yes" = "$response" ]] ; then
    builtin cd $rvm_path
    __rvm_reset
    mv $rvm_path/archives ~/.archives
    if [[ "/" = "$rvm_path" ]] ; then
      $rvm_scripts_path/log "error" "remove '/' ?!... NO!"
    else
      if [[ -d "$rvm_path" ]] ; then rm -rf "$rvm_path/" ; fi
    fi
    gem install rvm --no-rdoc --no-ri -q
    __rvm_update_rvm
    source $rvm_path/scripts/rvm
  else
    $rvm_scripts_path/log "info" "Carry on then..."
  fi ; unset response
}

__rvm_ruby_do() {
  __rvm_select
  __rvm_use
  binary="$(echo $rvm_action | sed 's#do$##')"
  if [[ -x "$rvm_ruby_home/bin/$binary" ]] ; then
    binary="$rvm_ruby_home/bin/$binary"
  elif [[ "system" = "$rvm_ruby_string" ]] && [[ -x "$(which $binary)" ]] ; then
    binary="$(which $binary)"
  else
    $rvm_scripts_path/log "warn" "'$binary not found for $rvm_ruby_string' either does not exist or is not executable? :("
    __rvm_unset_ruby_variables
    return 1
  fi

  if [[ ! -z "$rvm_ruby_mode" ]] ; then
    rvm_ruby_string="$rvm_ruby_string-$rvm_ruby_mode"
    rvm_ruby_mode="--$(echo $rvm_ruby_mode | sed 's/^m//')"
  fi

  load_path="$rvm_ruby_home/bin:$rvm_ruby_load_path"
  # TODO: the else case below should be run if $rvm_ruby_args =~ /\.rb$/
  if [[ "ruby" = "$binary" ]] && [[ "$rvm_benchmark_flag" -ne 1 ]] ; then
    if $rvm_scripts_path/match "$rvm_ruby_args" "\.rb$" ; then
      if [[ -z "$prefix" ]] ; then prefix="-S" ; fi
      if ! $rvm_scripts_path/match "$rvm_ruby_args" "$prefix" ; then
        rvm_ruby_args="$prefix $rvm_ruby_args"
      fi
    fi
    rvm_command="$binary $rvm_ruby_mode $rvm_ruby_require -I$load_path $rvm_ruby_args"
  elif [[ "gem" = "$binary" ]] && match "$rvm_ruby_args" '^install' ; then
    rvm_command="$binary $rvm_ruby_mode $rvm_ruby_args --no-rdoc --no-ri"
  else
    rvm_command="$binary $rvm_ruby_mode $rvm_ruby_args"
  fi

  if [[ ! -z "$rvm_json_flag" ]] || [[ ! -z "$rvm_yaml_flag" ]] || [[ ! -z "$rvm_summary_flag" ]] ; then
    mkdir -p ./log/$rvm_ruby_string/
    touch ./log/$rvm_ruby_string/$rvm_action.log ./log/$rvm_ruby_string/$rvm_action.error.log
    eval "$rvm_command" >> ./log/$rvm_ruby_string/$rvm_action.log 2>> ./log/$rvm_ruby_string/$rvm_action.error.log
  else
    echo -e "\n\n\033[0;32m$rvm_ruby_string: $($rvm_ruby_home/bin/ruby -v $rvm_ruby_mode | tr "\n" ' ')\033[0m\n"
    eval "$rvm_command"
  fi
  result=$?
  if [[ $result -eq 0 ]]; then
    eval "successes=(${successes[*]} $rvm_ruby_string)"
  else
    eval "errors=(${errors[*]} $rvm_ruby_string)"
  fi
  eval "rubies=(${rubies[*]} $rvm_ruby_string)"
  eval "statuses=(${statuses[*]} $result)"
  __rvm_unset_ruby_variables
}

__rvm_do() {
  __rvm_state

  rubies=() ; successes=() ; errors=() ; statuses=()
  # TODO: Extract the common functionality out of the if below
  if [[ ! -z "$rvm_ruby_string" ]] ; then
    unset rvm_ruby_interpreter rvm_ruby_version
    __rvm_ruby_do
  elif [[ ! -z "$rvm_ruby_version" ]] ;then
    for rvm_ruby_string in $(echo $rvm_ruby_version | tr ',' ' ') ; do
      __rvm_ruby_do
    done
  elif [[ ! -z "$rvm_ruby_interpreter" ]] ; then
      unset rvm_ruby_string rvm_ruby_version
      __rvm_ruby_do
  else # all
    rubies=($(\ls $rvm_path/*/bin/ruby))
    for full_binary in ${rubies[@]} ; do
      if [[ -x "$full_binary" ]] ; then
        rvm_ruby_string="$(dirname $full_binary | xargs dirname | xargs basename)"
        __rvm_ruby_do
      fi
    done ; unset full_binary rubies
  fi

  if [[ ! -z "$rvm_summary_flag" ]] ; then __rvm_summary ; fi
  if [[ ! -z "$rvm_yaml_flag" ]]    ; then __rvm_yaml    ; fi
  if [[ ! -z "$rvm_json_flag" ]]    ; then __rvm_json    ; fi

  __rvm_state

  __rvm_hook "after_do"

  return ${#errors[*]}
}

__rvm_summary() {
  export successes errors statuses
  summary="\nSummary:\n\n"
  if [[ ${#successes[*]} -gt 0 ]] ; then
    summary="$summary \033[0;32m${#successes[*]} successful: $(echo "${successes[*]}" | sed 's# #, #g')\033[0m\n"
  fi
  if [[ ${#errors[*]} -gt 0 ]] ; then
    summary="$summary \033[0;31m${#errors[*]} errors: $(echo "${errors[*]}" | sed 's# #, #g')\033[0m\n"
  fi
  total=${#rubies[*]}
  if [[ ! -z "$ZSH_VERSION" ]] ; then array_start=1 ; else array_start=0 ; fi
  echo -e "$summary" | tee -a log/summary.log
  return ${#errors[*]}
}

__rvm_yaml() {
  export successes errors statuses
  yaml="totals:\n  rubies: ${#rubies[*]}\n  successes: ${#successes[*]}\n  errors: ${#errors[*]}\nsuccesses:"
  for var in ${successes[*]} ; do yaml="$yaml\n  - $var" ; done
  yaml="$yaml\nerrors:"
  for var in ${errors[*]} ; do yaml="$yaml\n  - $var" ; done
  yaml="$yaml\nrubies:"
  total=${#rubies[*]}
  if [[ ! -z "$ZSH_VERSION" ]] ; then array_start=1 ; else array_start=0 ; fi
  for (( index = $array_start ; index < $total + $array_start ; index++ )) ; do
    (( $rvm_debug_flag )) && $rvm_scripts_path/log "debug" "${rubies[$index]}: ${statuses[$index]}"
    yaml="$yaml\n  \"${rubies[$index]}\": ${statuses[$index]}"
  done ; unset index array_start
  mkdir -p log
  echo -e "$yaml" | tee -a log/summary.yaml

  return ${#errors[*]}
}

__rvm_json() {
  json="{"
  json="$json\n  \"totals\": { \"rubies\": ${#rubies[*]}, \"successes\": ${#successes[*]}, \"errors\": ${#errors[*]}},"
  json="$json\n  \"successful\": [ "$(echo ${successes[*]} | sed 's# #", "#g')" ],"
  json="$json\n  \"errors\": [ "$(echo ${errors[*]} | sed 's# #", "#g')" ],"
  json="$json\n  \"rubies\": {"

  total=${#rubies[*]}
  if [[ ! -z "$ZSH_VERSION" ]] ; then array_start=1 ; else array_start=0 ; fi
  for (( index = $array_start ; index < $total + $array_start ; index++ )) ; do
    (( $rvm_debug_flag )) && $rvm_scripts_path/log "debug" "${rubies[$index]}: ${statuses[$index]}"
    json="$json\n    {\"${rubies[$index]}\": ${statuses[$index]}}"
    if (( $index + 1 < $total + $array_start )) ; then json="$json,  " ; fi
  done ; unset index array_start
  json="$json\n  }\n}"

  mkdir -p log
  echo -e "$json" | tee -a log/summary.json

  return ${#errors[*]}
}

__rvm_benchmark() {
  code="require \"benchmark\" \n Benchmark.bmbm do |benchmark| \n benchmark.report(\"${rvm_ruby_file}\") do \n"
  echo -e "$code" > "$rvm_temp_path/$$.rb"
  unset code
  cat $rvm_ruby_file >> "$rvm_temp_path/$$.rb"
  echo -e "\n end \nend\n" >> "$rvm_temp_path/$$.rb"
  rvm_ruby_args="$rvm_temp_path/$$.rb"
  rvm_benchmark_flag=1
  rvm_action="ruby"
  if [[ ! -z "$rvm_debug_flag" ]] ; then echo -e "$rvm_temp_path/$$.rb:\n$(cat $rvm_temp_path/$$.rb)" ; fi
  __rvm_do
}

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

__rvm_pushpop() {
  if [[ -z "$1" ]] ; then
    popd > /dev/null 2>&1
  else
    pushd "$1" > /dev/null 2>&1
  fi
}

__rvm_state() {
  if [[ -z "$rvm_state" ]] ; then
    if [[ -z "$(which ruby | awk /$(basename $rvm_path)/)" ]] ; then
      rvm_state=system
    else
      rvm_state="$(dirname $(which ruby) | xargs dirname | xargs basename)"
    fi
  else
    rvm_ruby_string="$rvm_state"
    __rvm_select
    __rvm_use
    unset rvm_state
  fi
}

__rvm_inspect() {
  for binary in $rvm_ruby_args ; do
    actual_file=$(which $binary)
    $rvm_scripts_path/log "info" "$actual_file:"
    if [[ ! -z "$rvm_shebang_flag" ]] ; then cat $actual_file | head -n 1    ; fi
    if [[ ! -z "$rvm_env_flag" ]]     ; then cat $actual_file | awk '/ENV/'  ; fi
    if [[ ! -z "$rvm_path_flag" ]]    ; then cat $actual_file | awk '/PATH/' ; fi
    if [[ ! -z "$rvm_head_flag" ]]    ; then cat $actual_file | head -n 5    ; fi
    if [[ ! -z "$rvm_tail_flag" ]]    ; then cat $actual_file | tail -n 5    ; fi
    if [[ ! -z "$rvm_all_flag" ]]     ; then cat $actual_file                ; fi
  done
}

#
# ruby supporting libraries:
#
__rvm_readline_install() {
  __rvm_make_flags
  __rvm_pushpop $rvm_src_path
  package="readline" ; version="5.2" ; archive_format="tar.gz"
  # TODO: Figure out how to list, grab and apply the patches
  $rvm_scripts_path/log "info" "Retrieving $package-$version.$archive_format"
  $rvm_scripts_path/fetch "ftp://ftp.gnu.org/gnu/readline/$package-$version.$archive_format"
  result=$? ; if [[ "$result" -gt 0 ]] ; then return $result ; fi
  __rvm_run "$package/extract" "tar zxf $rvm_archives_path/$package-$version.$archive_format -C $rvm_src_path" "Extracting $package-$version.$archive_format"
  builtin cd "$rvm_src_path/$package-$version"
  if [[ "Darwin" = "$(uname)" ]] ; then
    #sdk=$(\ls -t /Developer/SDKs/ | head -n 1)
    #CFLAGS="-isysroot /Developer/SDKs/$sdk -arch i386 -arch x86_64"
    #LDFLAGS="-Wl,-syslibroot,/Developer/SDKs/$sdk -arch i386 -arch x86_64"
    #export CFLAGS LDFLAGS
    __rvm_run "$package/configure" "./configure --prefix=$rvm_path/usr --disable-dependency-tracking --disable-static --enable-shared" "Configuring $package"
  else
    __rvm_run "$package/configure" "./configure --prefix=$rvm_path/usr --disable-dependency-tracking --disable-static --enable-shared" "Configuring $package"
  fi
  __rvm_run "$package/make" "/usr/bin/make $rvm_make_flags" "Compiling $package"
  __rvm_run "$package/make.install" "/usr/bin/make install" "Installing $package to $rvm_path/usr"
  __rvm_pushpop
}

__rvm_iconv_install() {
  __rvm_make_flags
  __rvm_pushpop $rvm_src_path
  package="libiconv" ; version=1.13.1 ; archive_format="tar.gz"
  $rvm_scripts_path/log "info" "Retrieving $package-$version.$archive_format"
  $rvm_scripts_path/fetch "http://ftp.gnu.org/pub/gnu/libiconv/$package-$version.$archive_format"
  result=$? ; if [[ "$result" -gt 0 ]] ; then return $result ; fi
  __rvm_run "$package/extract" "tar zxf $rvm_archives_path/$package-$version.$archive_format -C $rvm_src_path" "Extracting $package-$version.$archive_format"
  builtin cd "$rvm_src_path/$package-$version"
  __rvm_run "$package/configure" "./configure --prefix=$rvm_path/usr" "Configuring $package."
  __rvm_run "$package/make" "/usr/bin/make $rvm_make_flags" "Compiling $package"
  __rvm_run "$package/make.install" "/usr/bin/make install" "Installing $package to $rvm_path/usr"
  __rvm_pushpop
}

__rvm_curl_install() {
  __rvm_make_flags
  __rvm_pushpop $rvm_src_path
  package="curl" ; version=7.19.7 ; archive_format="tar.gz"
  $rvm_scripts_path/log "info" "Retrieving $package-$version.$archive_format"
  $rvm_scripts_path/fetch "http://curl.haxx.se/download/$package-$version.$archive_format"
  result=$? ; if [[ "$result" -gt 0 ]] ; then return $result ; fi
  __rvm_run "$package/extract" "tar zxf $rvm_archives_path/$package-$version.$archive_format -C $rvm_src_path" "Extracting $package-$version.$archive_format"
  builtin cd "$rvm_src_path/$package-$version"
  __rvm_run "$package/configure" "./configure --prefix=$rvm_path/usr" "Configuring $package."
  __rvm_run "$package/make" "/usr/bin/make $rvm_make_flags" "Compiling $package"
  __rvm_run "$package/make.install" "/usr/bin/make install" "Installing $package to $rvm_path/usr"
  __rvm_pushpop
}

__rvm_openssl_install() {
  __rvm_make_flags
    if $rvm_scripts_path/match "$rvm_archflags" "x86_64" ; then
      openssl_os="os/compiler darwin64-x86_64-cc"
    else
      openssl_os="os/compiler darwin-i386-cc"
    fi
  __rvm_pushpop $rvm_src_path
  package="openssl" ; version="0.9.8k" ; archive_format="tar.gz"
  $rvm_scripts_path/log "info" "Retrieving $package-$version.$archive_format"
  $rvm_scripts_path/fetch "http://www.openssl.org/source/$package-$version.tar.gz"
  result=$? ; if [[ "$result" -gt 0 ]] ; then return $result ; fi
  __rvm_run "$package/extract" "tar zxf $rvm_archives_path/$package-$version.$archive_format -C $rvm_src_path" "Extracting $package-$version.$archive_format"
  builtin cd "$rvm_src_path/$package-$version"
  __rvm_run "$package/config" "./config --prefix=$rvm_path/usr zlib no-asm no-krb5 shared" "Configuring $package."
  __rvm_run "$package/make" "/usr/bin/make $rvm_make_flags" "Compiling $package"
  __rvm_run "$package/make.install" "/usr/bin/make install" "Installing $package to $rvm_path/usr"
  __rvm_pushpop
}

__rvm_zlib_install() {
  __rvm_make_flags
  __rvm_pushpop $rvm_src_path
  package="zlib" ; version="1.2.3" ; archive_format="tar.gz"
  $rvm_scripts_path/log "info" "Retrieving $package-$version.$archive_format"
  $rvm_scripts_path/fetch "http://www.zlib.net/$package-$version.tar.gz"
  result=$? ; if [[ "$result" -gt 0 ]] ; then return $result ; fi
  __rvm_run "$package/extract" "tar zxf $rvm_archives_path/$package-$version.$archive_format -C $rvm_src_path" "Extracting $package-$version.$archive_format"
  builtin cd "$rvm_src_path/$package-$version"
  __rvm_run "$package/configure" "./configure --prefix=$rvm_path/usr" "Configuring $package."
  __rvm_run "$package/make" "/usr/bin/make $rvm_make_flags" "Compiling $package"
  __rvm_run "$package/make.install" "/usr/bin/make install" "Installing $package to $rvm_path/usr"
  __rvm_pushpop
}

__rvm_ncurses_install() {
  __rvm_make_flags
  __rvm_pushpop $rvm_src_path
  package="ncurses" ; version="5.7" ; archive_format="tar.gz"
  $rvm_scripts_path/log "info" "Retrieving $package"
  $rvm_scripts_path/fetch "ftp://invisible-island.net/ncurses/ncurses.tar.gz"
  result=$? ; if [[ "$result" -gt 0 ]] ; then return $result ; fi
  __rvm_run "$package/extract" "tar zxf $rvm_archives_path/$package.$archive_format -C $rvm_src_path" "Extracting $package.$archive_format"
  builtin cd "$rvm_src_path/$package-$version"
  __rvm_run "$package/configure" "./configure --prefix=$rvm_path/usr --with-shared --disable-rpath --without-debug --without-ada --enable-safe-sprintf --enable-sigwinch --without-progs" "Configuring $package."
  __rvm_run "$package/make" "/usr/bin/make $rvm_make_flags" "Compiling $package"
  __rvm_run "$package/make.install" "/usr/bin/make install" "Installing $package to $rvm_path/usr"
  __rvm_pushpop
}

__rvm_make_flags() {
  PATH=${rvm_path}/usr/bin:$PATH ; export PATH
  # This is only an issue with Darwin :/
  if [[ "Darwin" = "$(uname)" ]] ; then
    # ls /usr/lib/gcc/i686-apple-darwin10

    # Set the build & host type
    if [[ "Power Macintosh" = "$(sysctl hw.machine | awk -F: '{print $2}' | sed 's/^ //')" ]] ; then
      : # Do nothing ?
    elif [[ $(sysctl hw.cpu64bit_capable | awk '{print $2}') = 1 ]] ; then # we could also use: sysctl hw.optional.x86_64
      #   64 bit capable
      if [[ "-arch x86_64" = "$rvm_archflags" ]] ; then
        rvm_ruby_configure_flags="${rvm_ruby_configure_flags} --build=i686-apple-darwin$(uname -r) --host=i686-apple-darwin$(uname -r)"
      elif [[ "-arch i386" = "$rvm_archflags" ]] ; then
        rvm_ruby_configure_flags="${rvm_ruby_configure_flags} --build=i386-apple-darwin$(uname -r) --host=i386-apple-darwin$(uname -r)"
      else
        rvm_archflags="-arch x86_64"
        rvm_ruby_configure_flags="${rvm_ruby_configure_flags} --build=i686-apple-darwin$(uname -r) --host=i686-apple-darwin$(uname -r)"
      fi
    else
      #   32 bit capable only
      if [[ -z "$rvm_archflags" ]] ; then rvm_archflags="-arch i386" ; fi
      rvm_ruby_configure_flags="${rvm_ruby_configure_flags} --build=i386-apple-darwin$(uname -r) --host=i386-apple-darwin$(uname -r)"
    fi

    if [[ ! -z "$rvm_archflags" ]] ; then
      ARCHFLAGS="$rvm_archflags" ; export ARCHFLAGS
      # Use the latest sdk available.
      if [[ -z "$rvm_sdk" ]] ; then rvm_sdk="$(basename -a /Developer/SDKs/* | awk '/^M/' | sort | tail -n 1)" ; fi
      CFLAGS="-isysroot /Developer/SDKs/$rvm_sdk $rvm_archflags" ; export CFLAGS
      LDFLAGS="-Wl,-syslibroot /Developer/SDKs/$rvm_sdk $rvm_archflags" ; export LDFLAGS
      # CXXFLAGS="-mmacosx-version-min="$(sw_vers -productVersion | awk -F'.' '{print $1"."$2}')" -isysroot /Developer/SDKs/$rvm_sdk " ; export CXXFLAGS
    fi
  fi
}

__rvm_hook() {
  if [[ ! -z "$1" ]] ; then
    if [[ -s "$rvm_hooks_path/$1" ]] ; then
      if [[ "$rvm_verbose_flag" -eq 1 ]] || [[ "$rvm_debug_flag" -eq 1 ]] ; then $rvm_scripts_path/log "info" "running hook $1" ; fi
      source "$rvm_hooks_path/$1"
    fi
  fi
}