#!/bin/bash

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="`cat $rvm_path/VERSION.yml | tail -n 3 | sed 's/^.*: //g' | tr "\n" '.' | sed 's/\.$//'`"
  rvm_meta_updated="2009.09.16"
}

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] [Flags]

  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
    gemdo     - Used with -f to execute a command using selected ruby's 'gem'
    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.
    tests     - run 'rake test' across selected ruby versions
    specs     - run 'rake spec' across selected ruby versions

  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    - Emit rvm version loaded for current shell
    -h|--help       - Emit this output and exit
    -l|--level      - patch level to use with rvm use / install
       --tag        - subersion tag to use
       --rev        - repository revision # to use or 'head' for

       --prefix     - path for all rvm files (~/.rvm/), with trailing slash!
       --bin        - path for binaries to be placed (~/.rvm/bin/)
       --source     - src directory to use (~/.rvm/src/)
       --archives   - directory for downladed files (~/.rvm/archives/)
    -S|--script     - Specify a script file to attempt to load and run (rubydo)
    -G|--gems       - root gem path to use
    -C|--configure  - custom configure options, comma separated
                      default: --enable-shared=true
    --reconfigure   - Force installer to re-run configure if already run
    --make          - custom make command
    --make-install  - custom make install command
    --nice          - process niceness (for slow computers, default 0)
    -m|--gem-set    - use a named gem set, instead of the default set.
    --rm-gem-set    - Remove a named gem set

  Flags

    --self        - with update, updates rvm itself
    --rubygems    - with update, updates rubygems for selected ruby
    --default     - with ruby select, sets a default ruby for new shells.
    --debug       - Toggle debug mode on for very verbose output.
    --force       - Force install, removes old install & source before install.
    --all         - Used with 'rvm list' to display "most" available versions.
    --dump        - Used with gemset to dump the current ruby's gemset.
    --load        - Used with gemset to load a specified gemset file
    --summary     - Used with rubydo to print out a summary of the commands run.
    --jit         - Used with rubinius install to build with JIT
    --latest      - with gemset --dump skips version strings for latest gem.
    --reconfigure -
    --spec        -
    --test        -

  Resources:

    http://rvm.beginrescueend.com/
    https://www.pivotaltracker.com/projects/26822

Usage

}

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|readline|iconv)
        rvm_action=$rvm_token
      ;;

      use)
        rvm_action=$rvm_token
      ;;

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

      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|rakedo|gemdo)
        rvm_action=$rvm_token
        if [ "$rvm_action" = "do" ] ; then rvm_action="do" ; fi
        temp=$(echo $1 | awk '{print substr($1, 0, 1)}')
        if [ "$temp" = "-" ] ; then
          unset rvm_ruby_version
        else
          if [ ! -z "$(echo $temp | grep '[0-9]')" ] ; then
            rvm_ruby_version=$(echo "$1" | tr ',' ' ') ; shift
            unset rvm_ruby_interpreter
          else
            if [ "$1" = "jruby" -o "$1" = "rbx" -o "$1" = "rubinius" -o "$1" = "macruby" ] ; then
              rvm_ruby_interpreter=$1 ; shift
            else
              unset rvm_ruby_interpreter rvm_ruby_version
            fi
          fi
        fi
      ;;

      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"
          shift
        fi
      ;;

      -t|--tag)
        rvm_ruby_tag="$1";
        rvm_action="${rvm_action:-use}"
        shift
      ;;

      --head)
        rvm_ruby_rev="head"
        rvm_action="${rvm_action:-use}"
      ;;

      --rev|--revision)
        rvm_ruby_rev="$1";
        rvm_action="${rvm_action:-use}"
        shift
      ;;

      -b|--branch)
        rvm_ruby_branch="$1";
        rvm_action="${rvm_action:-use}"
        shift
      ;;

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

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


      -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."
        fi
      ;;

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

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

      -f|--file)
        rvm_action="rubydo"
        rvm_ruby_args="$1"
        shift
      ;;

      -S|--script|-e|--execute)
        rvm_action="rubydo"
        rvm_ruby_args="$@"
        rvm_parse_break=1
      ;;

      --load)
        rvm_load_flag=1
        if [ ! -z "$1" ] ; then
          rvm_load_file="$1"
          shift
        else
           rvm_action="error"
           rvm_error_message="--load must be followed by the .gemset file to load."
           break;
        fi
      ;;

      default|system)
        rvm_action="use"
        rvm_ruby_interpreter="system"
      ;;

      --prefix)          rvm_prefix_path="$1"      ; shift ;;
      -G|--gems)         rvm_gem_path="$1"         ; shift ;;
      --source)          rvm_source_path="$1"      ; shift ;;
      --archives)        rvm_archives_path="$1"    ; shift ;;
      --make)            rvm_ruby_make="$1"        ; shift ;;
      --make-install)    rvm_ruby_make_install="$1"; shift ;;
      --nice)            rvm_niceness="$1"         ; shift ;;
      -l|--level)        rvm_ruby_patch_level="$1" ; shift ;;
      -h|--help)         rvm_action=help           ; shift ;;
      -m|--gem-set)      rvm_gem_set_name="$1"     ; shift ;;
         --rm-gem-set)   rvm_gem_set_name_rm="$1"  ; shift ;;
      tests|specs)       rvm_action="tests"                ;;

      --self|--gem|--rubygems|--reconfigure|--default|--debug|debug|--force|--all|--dump|--summary|--jit|--latest|--spec|--test)
        eval "rvm_$(echo $rvm_token | sed 's/-//g')_flag=1"
      ;;

      reboot|flush|asdf|damnit|wtf|argh|work|workdamnit|BOOM|boom|wth)
        $rvm_action="reboot"
      ;;

      *)
        if [ ! -z "$rvm_token" ] ; then
          echo "$rvm_token" | grep ',' > /dev/null
          if [ $? -eq 0 ] ; then
            rvm_ruby_version="$rvm_token"
            if [ -z "$rvm_action" ] ; then
              rvm_action="rubydo" # Not sure if we really want to do this but we'll try it out.
            fi
          else
            echo $rvm_token | grep '\.rb$' > /dev/null
            if [ $? -eq 0 ] ; then # we have a specified ruby script
              rvm_ruby_args=$rvm_token
              if [ -z "$rvm_action" ] ; then
                rvm_action="rubydo" # Not sure if we really want to do this but we'll try it out.
              fi
            else
              rvm_action="error"
              rvm_error_message="Unrecognized command line argument: '$rvm_token'"
            fi
          fi
        else
          rvm_action="error"
          rvm_error_message="Unrecognized command line argument(s): '$rvm_token $@'"
        fi
        if [ "$rvm_action" = "error" ] ; then
          break;
        fi

    esac
    if [ ! -z "$rvm_parse_break" -o ! -z "$rvm_error_message" ] ; then unset rvm_parse_break; break; fi
  done

  if [ ! -z "$rvm_error_message" ] ; then popd 2> /dev/null ; return 1 ; fi
}

function rvm {

  __rvm_cleanup-variables
  __rvm_load-rvmrc
  __rvm_initialize
  __rvm_load-defaults
  __rvm_parse-args $@

  if [ -z "$rvm_debug_flag" ] ; then set +x ; else set -x ; fi
  result=0
  case "$rvm_action" in
    install)    __rvm_install-ruby     ; result=$? ;;
    uninstall)  __rvm_uninstall        ; result=$? ;;
    use)        __rvm_use              ; result=$? ;;
    gemdir)     __rvm_gem-dir          ; result=$? ;;
    srcdir)     __rvm_src-dir          ; result=$? ;;
    gemdup)     __rvm_gem-dup          ; result=$? ;;
    list)       __rvm_list             ; result=$? ;;
    symlinks)   __rvm_symlinks         ; result=$? ;;
    version)    __rvm_version          ; result=$? ;;
    reset)      __rvm_reset            ; result=$? ;;
                # TODO: how can we use bin_path here for reload, default file?
    reload)     __rvm_reload           ; result=$? ;;
    implode)    __rvm_implode          ; result=$? ;;
    update)     __rvm_update           ; result=$? ;;
    readline)   __rvm_readline_install ; result=$? ;;
    iconv)      __rvm_iconv_install    ; result=$? ;;
    reboot)     __rvm_reboot           ; result=$? ;;
    usage|help) __rvm_usage            ; result=$? ;;
    rubydo|rakedo|gemdo) __rvm_do      ; result=$? ;;

    tests|specs)
      rvm_summary_flag=1
      rvm_action="rake"
      __rvm_do
    ;;

    info|debug)
      __rvm_version
      __rvm_info
      if [ "$rvm_action" = "debug" ] ; then __rvm_debug ; fi
      result=0
    ;;

    error)      __rvm_log "fail" "$rvm_error_message ( see: 'rvm usage' )" ; popd 2> /dev/null ; return 1; ;;
    *)
      if [ ! -z "$rvm_action" ] ; then
        __rvm_log "fail"  "unknown action '$rvm_action'"
      else
        __rvm_usage
      fi
      result=1
  esac
  if [ "$rvm_debug_flag" = "1" ] ; then set +x ; unset rvm_debug_flag ; fi
  return $result
}