rvm 0.0.69 → 0.0.70

data/config/db

@@ -2,6 +2,7 @@ niceness=0
 ruby_repo_url=http://svn.ruby-lang.org/repos/ruby
 rubinius_repo_url=git://github.com/evanphx/rubinius.git
 shyouhei_repo_url=git://github.com/shyouhei/ruby.git
+macruby_version=nightly
 macruby_repo_url=git://git.macruby.org/macruby/MacRuby.git
 macruby_nightly_url=http://macruby.icoretech.org/latest
 jruby_repo_url=git://kenai.com/jruby~main

data/lib/VERSION.yml

@@ -1,4 +1,4 @@
 ---
 :major: 0
 :minor: 0
-:patch: 69
+:patch: 70

data/lib/rvm/open4.rb

@@ -0,0 +1,395 @@
+# vim: ts=2:sw=2:sts=2:et:fdm=marker
+# Author: Ara T. Howard
+# Gem: open4
+require 'fcntl'
+require 'timeout'
+require 'thread'
+
+module Open4
+#--{{{
+  VERSION = '0.9.6'
+  def self.version() VERSION end
+
+  class Error < ::StandardError; end
+
+  def popen4(*cmd, &b)
+#--{{{
+    pw, pr, pe, ps = IO.pipe, IO.pipe, IO.pipe, IO.pipe
+
+    verbose = $VERBOSE
+    begin
+      $VERBOSE = nil
+      ps.last.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+
+      cid = fork {
+        pw.last.close
+        STDIN.reopen pw.first
+        pw.first.close
+
+        pr.first.close
+        STDOUT.reopen pr.last
+        pr.last.close
+
+        pe.first.close
+        STDERR.reopen pe.last
+        pe.last.close
+
+        STDOUT.sync = STDERR.sync = true
+
+        begin
+          exec(*cmd)
+          raise 'forty-two'
+        rescue Exception => e
+          Marshal.dump(e, ps.last)
+          ps.last.flush
+        end
+        ps.last.close unless (ps.last.closed?)
+        exit!
+      }
+    ensure
+      $VERBOSE = verbose
+    end
+
+    [pw.first, pr.last, pe.last, ps.last].each{|fd| fd.close}
+
+    begin
+      e = Marshal.load ps.first
+      raise(Exception === e ? e : "unknown failure!")
+    rescue EOFError # If we get an EOF error, then the exec was successful
+      42
+    ensure
+      ps.first.close
+    end
+
+    pw.last.sync = true
+
+    pi = [pw.last, pr.first, pe.first]
+
+    if b
+      begin
+        b[cid, *pi]
+        Process.waitpid2(cid).last
+      ensure
+        pi.each{|fd| fd.close unless fd.closed?}
+      end
+    else
+      [cid, pw.last, pr.first, pe.first]
+    end
+#--}}}
+  end
+  alias open4 popen4
+  module_function :popen4
+  module_function :open4
+
+  class SpawnError < Error
+#--{{{
+    attr 'cmd'
+    attr 'status'
+    attr 'signals'
+    def exitstatus
+      @status.exitstatus
+    end
+    def initialize cmd, status
+      @cmd, @status = cmd, status
+      @signals = {}
+      if status.signaled?
+        @signals['termsig'] = status.termsig
+        @signals['stopsig'] = status.stopsig
+      end
+      sigs = @signals.map{|k,v| "#{ k }:#{ v.inspect }"}.join(' ')
+      super "cmd <#{ cmd }> failed with status <#{ exitstatus.inspect }> signals <#{ sigs }>"
+    end
+#--}}}
+  end
+
+  class ThreadEnsemble
+#--{{{
+    attr 'threads'
+
+    def initialize cid
+      @cid, @threads, @argv, @done, @running = cid, [], [], Queue.new, false
+      @killed = false
+    end
+
+    def add_thread *a, &b
+      @running ? raise : (@argv << [a, b])
+    end
+
+#
+# take down process more nicely
+#
+    def killall
+      c = Thread.critical
+      return nil if @killed
+      Thread.critical = true
+      (@threads - [Thread.current]).each{|t| t.kill rescue nil}
+      @killed = true
+    ensure
+      Thread.critical = c
+    end
+
+    def run
+      @running = true
+
+      begin
+        @argv.each do |a, b|
+          @threads << Thread.new(*a) do |*a|
+            begin
+              b[*a]
+            ensure
+              killall rescue nil if $!
+              @done.push Thread.current
+            end
+          end
+        end
+      rescue
+        killall
+        raise
+      ensure
+        all_done
+      end
+
+      @threads.map{|t| t.value}
+    end
+
+    def all_done
+      @threads.size.times{ @done.pop }
+    end
+#--}}}
+  end
+
+  def to timeout = nil
+#--{{{
+    Timeout.timeout(timeout){ yield }
+#--}}}
+  end
+  module_function :to
+
+  def new_thread *a, &b
+#--{{{
+    cur = Thread.current
+    Thread.new(*a) do |*a|
+      begin
+        b[*a]
+      rescue Exception => e
+        cur.raise e
+      end
+    end
+#--}}}
+  end
+  module_function :new_thread
+
+  def getopts opts = {}
+#--{{{
+    lambda do |*args|
+      keys, default, ignored = args
+      catch('opt') do
+        [keys].flatten.each do |key|
+          [key, key.to_s, key.to_s.intern].each do |key|
+            throw 'opt', opts[key] if opts.has_key?(key)
+          end
+        end
+        default
+      end
+    end
+#--}}}
+  end
+  module_function :getopts
+
+  def relay src, dst = nil, t = nil
+#--{{{
+    unless src.nil?
+      if src.respond_to? :gets
+        while buf = to(t){ src.gets }
+          dst << buf if dst
+        end
+
+      elsif src.respond_to? :each
+        q = Queue.new
+        th = nil
+
+        timer_set = lambda do |t|
+          th = new_thread{ to(t){ q.pop } }
+        end
+
+        timer_cancel = lambda do |t|
+          th.kill if th rescue nil
+        end
+
+        timer_set[t]
+        begin
+          src.each do |buf|
+            timer_cancel[t]
+            dst << buf if dst
+            timer_set[t]
+          end
+        ensure
+          timer_cancel[t]
+        end
+
+      elsif src.respond_to? :read
+        buf = to(t){ src.read }
+        dst << buf if dst
+
+      else
+        buf = to(t){ src.to_s }
+        dst << buf if dst
+      end
+    end
+#--}}}
+  end
+  module_function :relay
+
+  def spawn arg, *argv
+#--{{{
+    argv.unshift(arg)
+    opts = ((argv.size > 1 and Hash === argv.last) ? argv.pop : {})
+    argv.flatten!
+    cmd = argv.join(' ')
+
+
+    getopt = getopts opts
+
+    ignore_exit_failure = getopt[ 'ignore_exit_failure', getopt['quiet', false] ]
+    ignore_exec_failure = getopt[ 'ignore_exec_failure', !getopt['raise', true] ]
+    exitstatus = getopt[ %w( exitstatus exit_status status ) ]
+    stdin = getopt[ %w( stdin in i 0 ) << 0 ]
+    stdout = getopt[ %w( stdout out o 1 ) << 1 ]
+    stderr = getopt[ %w( stderr err e 2 ) << 2 ]
+    pid = getopt[ 'pid' ]
+    timeout = getopt[ %w( timeout spawn_timeout ) ]
+    stdin_timeout = getopt[ %w( stdin_timeout ) ]
+    stdout_timeout = getopt[ %w( stdout_timeout io_timeout ) ]
+    stderr_timeout = getopt[ %w( stderr_timeout ) ]
+    status = getopt[ %w( status ) ]
+    cwd = getopt[ %w( cwd dir ) ]
+
+    exitstatus =
+      case exitstatus
+        when TrueClass, FalseClass
+          ignore_exit_failure = true if exitstatus
+          [0]
+        else
+          [*(exitstatus || 0)].map{|i| Integer i}
+      end
+
+    stdin ||= '' if stdin_timeout
+    stdout ||= '' if stdout_timeout
+    stderr ||= '' if stderr_timeout
+
+    started = false
+
+    status =
+      begin
+        chdir(cwd) do
+          Timeout::timeout(timeout) do
+            popen4(*argv) do |c, i, o, e|
+              started = true
+
+              %w( replace pid= << push update ).each do |msg|
+                break(pid.send(msg, c)) if pid.respond_to? msg
+              end
+
+              te = ThreadEnsemble.new c
+
+              te.add_thread(i, stdin) do |i, stdin|
+                relay stdin, i, stdin_timeout
+                i.close rescue nil
+              end
+
+              te.add_thread(o, stdout) do |o, stdout|
+                relay o, stdout, stdout_timeout
+              end
+
+              te.add_thread(e, stderr) do |o, stderr|
+                relay e, stderr, stderr_timeout
+              end
+
+              te.run
+            end
+          end
+        end
+      rescue
+        raise unless(not started and ignore_exec_failure)
+      end
+
+    raise SpawnError.new(cmd, status) unless
+      (ignore_exit_failure or (status.nil? and ignore_exec_failure) or exitstatus.include?(status.exitstatus))
+
+    status
+#--}}}
+  end
+  module_function :spawn
+
+  def chdir cwd, &block
+    return(block.call Dir.pwd) unless cwd
+    Dir.chdir cwd, &block
+  end
+  module_function :chdir
+
+  def background arg, *argv
+#--{{{
+    require 'thread'
+    q = Queue.new
+    opts = { 'pid' => q, :pid => q }
+    case argv.last
+      when Hash
+        argv.last.update opts
+      else
+        argv.push opts
+    end
+    thread = Thread.new(arg, argv){|arg, argv| spawn arg, *argv}
+    sc = class << thread; self; end
+    sc.module_eval {
+      define_method(:pid){ @pid ||= q.pop }
+      define_method(:spawn_status){ @spawn_status ||= value }
+      define_method(:exitstatus){ @exitstatus ||= spawn_status.exitstatus }
+    }
+    thread
+#--}}}
+  end
+  alias bg background
+  module_function :background
+  module_function :bg
+
+  def maim pid, opts = {}
+#--{{{
+    getopt = getopts opts
+    sigs = getopt[ 'signals', %w(SIGTERM SIGQUIT SIGKILL) ]
+    suspend = getopt[ 'suspend', 4 ]
+    pid = Integer pid
+    existed = false
+    sigs.each do |sig|
+      begin
+        Process.kill sig, pid
+        existed = true
+      rescue Errno::ESRCH
+        return(existed ? nil : true)
+      end
+      return true unless alive? pid
+      sleep suspend
+      return true unless alive? pid
+    end
+    return(not alive?(pid))
+#--}}}
+  end
+  module_function :maim
+
+  def alive pid
+#--{{{
+    pid = Integer pid
+    begin
+      Process.kill 0, pid
+      true
+    rescue Errno::ESRCH
+      false
+    end
+#--}}}
+  end
+  alias alive? alive
+  module_function :alive
+  module_function :'alive?'
+#--}}}
+end
+
+def open4(*cmd, &b) cmd.size == 0 ? Open4 : Open4::popen4(*cmd, &b) end

data/lib/rvm/rvm.rb

@@ -0,0 +1,14 @@
+module RVM
+  module InstanceMethods
+    def rvm(command, options = {})
+      result = RVM::Shell.new(command)
+      [result.output, result.errors]
+    end
+  end
+
+  def self.included(receiver)
+    receiver.send(:include, InstanceMethods)
+  end
+end
+
+include RVM

data/lib/rvm/shell.rb

@@ -0,0 +1,14 @@
+module RVM
+  class Shell
+    attr_reader :errors, :output
+
+    def initialize(command)
+      @command = (command =~ /^rvm /) ? command : "rvm #{command}"
+      Open4::popen4("/bin/bash -l -c '#{@command.tr("'","\\'")}'") do |pid, stdin, stdout, stderr|
+        stdin.close
+        @output = stdout.readlines.join
+        @errors = stderr.readlines.join
+      end
+    end
+  end
+end

data/rvm.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rvm}
-  s.version = "0.0.69"
+  s.version = "0.0.70"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Wayne E. Seguin"]
-  s.date = %q{2009-10-30}
+  s.date = %q{2009-10-31}
   s.default_executable = %q{rvm-install}
   s.description = %q{Manages Ruby interpreter installations and switching between them.}
   s.email = %q{wayneeseguin@gmail.com}
@@ -25,6 +25,9 @@ Gem::Specification.new do |s|
      "install",
      "lib/VERSION.yml",
      "lib/rvm.rb",
+     "lib/rvm/open4.rb",
+     "lib/rvm/rvm.rb",
+     "lib/rvm/shell.rb",
      "lib/rvm/version.rb",
      "rvm.gemspec",
      "scripts/aliases",

data/scripts/ruby-installer

@@ -25,7 +25,6 @@ function __rvm_install_source {
     if [[ $? -gt 0 ]] ; then result=$? ; return $result ; fi
   else
     if [[ ! -z "$(echo $rvm_url | awk '/^git/')" ]] ; then
-
       if [[ -d "$rvm_ruby_src_path/.git" ]] ; then
         cd $rvm_ruby_src_path
         if [[ -z "$rvm_ruby_revision" ]] ; then
@@ -126,16 +125,63 @@ function __rvm_install_ruby {
 
   case "$rvm_ruby_interpreter" in
     macruby)
-      if [[ "$(uname)" = "Darwin" ]] ; then
-        rvm_url="$(__rvm_db "macruby_nightly_url")"
-        __rvm_log "info" "Retrieving latest macruby" # $rvm_archives_path/macruby_nightly.pkg
-        __rvm_fetch $rvm_url
-        mv $rvm_archives_path/latest $rvm_archives_path/macruby_nightly.pkg
-        __rvm_run "macruby/extract" "xar -x -f $rvm_archives_path/macruby_nightly.pkg -C $rvm_ruby_home" "Extracting macruby nightly package."
+      if [[ "Darwin" = "$(uname)" ]] ; then
+        if [[ "nightly" = "$rvm_ruby_version" ]] ; then
+          macruby_path="/usr/local/bin"
+          # TODO: Separated nightly from head.
+          rvm_url="$(__rvm_db "macruby_nightly_url")"
+          __rvm_log "info" "Retrieving the latest nightly macruby build..."
+          __rvm_fetch $rvm_url
+          mv "$rvm_archives_path/latest" "$rvm_archives_path/macruby_nightly.pkg"
+          __rvm_run "macruby/extract" "sudo installer -pkg '$rvm_path/archives/macruby_nightly.pkg' -target '/'"
+          mkdir -p "$rvm_ruby_home/bin"
+        elif [[ "head" = "$rvm_ruby_version" ]] ; then
+          # TODO: configure & make variables should be set here.
+          rvm_url="$(__rvm_db "${rvm_ruby_interpreter}_repo_url")"
+          if [[ -z "$rvm_url" ]] ; then
+            __rvm_log "fail" "rvm does not know the rvm repo url for 'ree_${rvm_ruby_version}'"
+            result=1
+          else
+            rvm_ruby_repo_url=$rvm_url
+            __rvm_install_source $*
+          fi
+        else
+          macruby_path="/usr/local/bin"
+          # TODO: Separated nightly from head.
+          rvm_url="$(__rvm_db "macruby_nightly_url")"
+          __rvm_log "info" "Retrieving latest macruby" # $rvm_archives_path/macruby_nightly.pkg
+          __rvm_fetch $rvm_url
+          mv $rvm_archives_path/latest $rvm_archives_path/macruby_nightly.pkg
+          __rvm_run "macruby/extract" "sudo installer -pkg '$rvm_path/archives/$rvm_ruby_package_file.zip' -target '/'"
+          mkdir -p "$rvm_ruby_home/bin"
+        fi
+
+        binaries="erb gem irb rake rdoc ri ruby testrb" # Trick to work in more shells :)
+        for binary_name in $(echo $binaries); do
+          # if [[ $binary_name != "gem" ]] ; then prefix="-S" ; 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 $macruby_path/mac$binary_name $prefix "\$@"
+RubyWrapper
+)
+          files="$rvm_ruby_home/bin/$binary_name $rvm_path/bin/$binary_name-$rvm_ruby_package_name"
+          for file_name in $(echo $files)  ; do
+            rm -f $file_name
+            echo "$ruby_wrapper" > $file_name
+            if [[ -f $file_name ]] ; then chmod +x $file_name ; fi
+          done
+          unset file_name ruby_wrapper binary_name files prefix
+        done
+        __rvm_irbrc
       else
         __rvm_log "fail" "MacRuby can only be installed on a Darwin OS."
       fi
-      __rvm_irbrc
     ;;
 
     ree)

data/scripts/selector

@@ -15,11 +15,20 @@ function __rvm_select {
     macruby)
       if [[ "Darwin" = "$(uname)" ]] ; then
         rvm_ruby_repo_url="${rvm_ruby_repo_url:-"$(__rvm_db "macruby_repo_url")"}"
-        rvm_ruby_version="${rvm_ruby_version:-head}"
         rvm_ruby_package_name=${rvm_ruby_interpreter}-${rvm_ruby_version}
-        #rvm_ruby_version="${rvm_ruby_version:-"$(__rvm_db "macruby_version")"}"
-        #rvm_ruby_package_name=${rvm_ruby_interpreter}_nightly-${rvm_ruby_version}
-        #rvm_url="http://dl.getdropbox.com/u/163257/$rvm_ruby_package_name.pkg" # 'nightly' builds
+        rvm_ruby_string="${rvm_ruby_interpreter}-${rvm_ruby_version}"
+        if [[ "nightly" = "$rvm_ruby_version" ]] ; then
+          rvm_url="http://macruby.icoretech.org/latest"
+        elif [[ "head" = "$rvm_ruby_version" ]] ; then
+          rvm_ruby_repo_url=${rvm_ruby_repo_url:-"$(__rvm_db "macruby_repo_url")"}
+          rvm_url="$rvm_ruby_repo_url"
+        else
+          rvm_ruby_version="${rvm_ruby_version:-"$(__rvm_db "macruby_version")"}"
+          rvm_ruby_package_name="${rvm_ruby_interpreter}_nightly-${rvm_ruby_version}"
+          rvm_ruby_package_file="MacRuby%200.5%20beta%201.zip"
+          rvm_url="http://www.macruby.org/files/MacRuby%200.5%20beta%201.zip"
+        fi
+
         unset rvm_ruby_patch_level
       else
         __rvm_log "fail" "MacRuby can only be installed on a Darwin OS."
@@ -264,6 +273,10 @@ __rvm_ruby_string() {
     elif [[ "system" = "$string" ]] ; then
       rvm_ruby_interpreter="system"
       break
+    elif [[ "nightly" = "$string" ]] ; then
+      rvm_ruby_version="nightly"
+      rvm_nightly_flag=1
+      break
     elif match "$string" "^preview" ; then
       rvm_ruby_patch_level="$string"
     elif match "$string" "^[a-z][a-z]" ; then

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rvm
 version: !ruby/object:Gem::Version 
-  version: 0.0.69
+  version: 0.0.70
 platform: ruby
 authors: 
 - Wayne E. Seguin
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-30 00:00:00 -04:00
+date: 2009-10-31 00:00:00 -04:00
 default_executable: rvm-install
 dependencies: []
 
@@ -29,6 +29,9 @@ files:
 - install
 - lib/VERSION.yml
 - lib/rvm.rb
+- lib/rvm/open4.rb
+- lib/rvm/rvm.rb
+- lib/rvm/shell.rb
 - lib/rvm/version.rb
 - rvm.gemspec
 - scripts/aliases