rvm 0.1.41 → 0.1.42

data/lib/rvm/environment/wrapper.rb

@@ -0,0 +1,23 @@
+module RVM
+  class Environment
+
+    # Generates wrappers with the specified prefix, pointing
+    # to ruby_string.
+    def wrapper(ruby_string, wrapper_prefix, *binaries)
+      rvm(:wrapper, ruby_string, wrapper_prefix, *binaries).successful?
+    end
+
+    # Generates the default wrappers.
+    def default_wrappers(ruby_string, *binaries)
+      wrapper ruby_string, '', *binaries
+    end
+
+    # If available, return the path to the wrapper for
+    # the given executable. Will return ni if the wrapper
+    # is unavailable.
+    def wrapper_path_for(executable)
+      raise NotImplementedError
+    end
+
+  end
+end

data/lib/rvm/errors.rb

@@ -0,0 +1,28 @@
+module RVM
+
+  # Generic error in RVM
+  class Error < StandardError; end
+
+  # Generic error with the shell command output attached.
+  # The RVM::Shell::Result instance is available via +#result+.
+  class ErrorWithResult < Error
+    attr_reader :result
+
+    def initialize(result, message = nil)
+      @result = result
+      super message
+    end
+
+  end
+
+  # Something occured processing the command and rvm couldn't parse the results.
+  class IncompleteCommandError < Error; end
+
+  # The given action can't replace the env for the current process.
+  # Typically raised by RVM::Environment#gemset_use when the gemset
+  # is for another, incompatible ruby interpreter.
+  #
+  # Provides access to the output of the shell command via +#result+.
+  class IncompatibleRubyError < ErrorWithResult; end
+
+end

data/lib/rvm/shell.rb

@@ -1,14 +1,25 @@
 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
+  # Provides Generic access to a more ruby-like shell interface.
+  # For more details, see AbstractWrapper.
+  module Shell
+
+    autoload :AbstractWrapper,   'rvm/shell/abstract_wrapper'
+    autoload :SingleShotWrapper, 'rvm/shell/single_shot_wrapper'
+    # Current unimplemented
+    #autoload :PersistingWrapper, 'rvm/shell/persisting_wrapper'
+    autoload :TestWrapper,       'rvm/shell/test_wrapper'
+    autoload :Utility,           'rvm/shell/utility'
+    autoload :Result,            'rvm/shell/result'
+
+    # Returns the default shell wrapper class to use
+    def self.default_wrapper
+      @@default_wrapper ||= SingleShotWrapper
     end
+
+    # Sets the default shell wrapper class to use.
+    def self.default_wrapper=(wrapper)
+      @@default_wrapper = wrapper
+    end
+
   end
 end

data/lib/rvm/shell/abstract_wrapper.rb

@@ -0,0 +1,145 @@
+require 'yaml'
+
+module RVM
+  module Shell
+    # Provides the most common functionality expected of a shell wrapper.
+    # Namely, implements general utility methods and tools to extract output
+    # from a given command but doesn't actually run any commands itself,
+    # leaving that up to concrete implementations.
+    #
+    # == Usage
+    #
+    # Commands are run inside of a shell (usually bash) and can either be exectuted in
+    # two situations (each with wrapper methods available) - silently or verbosely.
+    #
+    # Silent commands (via run_silently and run_command) do exactly as
+    # they say - that can modify the environment etc but anything they print (to stdout
+    # or stderr) will be discarded.
+    #
+    # Verbose commands will run the command and then print the command epilog (which
+    # contains the output stastus and the current env in yaml format). This allows us
+    # to not only capture all output but to also return the exit status and environment
+    # variables in a way that makes persisted shell sessions possible.
+    #
+    # Under the hood, #run and run_silently are the preferred ways of invoking commands - if
+    # passed a single command, they'll run it as is (much like system in ruby) but when
+    # given multiple arguments anything after the first will be escaped (e.g. you can
+    # hence pass code etc). #run will also parse the results of this epilog into a usable
+    # RVM::Shell::Result object.
+    #
+    # run_command and run_command_silently do the actual hard work for these behind the scenes,
+    # running a string as the shell command. Hence, these two commands are what must be
+    # implemented in non-abstract wrappers.
+    #
+    # For an example of the shell wrapper functionality in action, see RVM::Environment
+    # which delegates most of the work to a shell wrapper.
+    class AbstractWrapper
+
+      # Used the mark the end of a commands output and the start of the rvm env.
+      COMMAND_EPILOG_START = "---------------RVM-RESULTS-START---------------"
+      # Used to mark the end of the commands epilog.
+      COMMAND_EPILOG_END   = "----------------RVM-RESULTS-END----------------"
+      # The location of the shell file with the epilog function definition.
+      WRAPPER_LOCATION     = File.expand_path('./shell_wrapper.sh', File.dirname(__FILE__))
+
+      # Defines the shell exectuable.
+      attr_reader :shell_executable
+
+      # Initializes a new shell wrapper, including setting the
+      # default setup block. Implementations must override this method
+      # but must ensure that they call super to perform the expected
+      # standard setup.
+      def initialize(sh = 'bash', &setup_block)
+        setup &setup_block
+        @shell_executable = sh
+      end
+
+      # Defines a setup block to be run when initiating a wrapper session.
+      # Usually used for doing things such as sourcing the rvm file. Please note
+      # that the wrapper file is automatically source.
+      #
+      # The setup block should be automatically run by wrapper implementations.
+      def setup(&blk)
+        @setup_block = blk
+      end
+
+      # Runs the gives command (with optional arguments), returning an
+      # RVM::Shell::Result object, including stdout / stderr streams.
+      # Under the hood, uses run_command to actually process it all.
+      def run(command, *arguments)
+        expanded_command = build_cli_call(command, arguments)
+        status, out, err = run_command(expanded_command)
+        Result.new(expanded_command, status, out, err)
+      end
+
+      # Wrapper around run_command_silently that correctly escapes arguments.
+      # Essentially, #run but using run_command_silently.
+      def run_silently(command, *arguments)
+        run_command_silently build_cli_call(command, arguments)
+      end
+
+      # Given a command, it will execute it in the current wrapper
+      # and once done, will return:
+      # - the hash from the epilog output.
+      # - a string representing stdout.
+      # - a string representing stderr.
+      def run_command(full_command)
+        raise NotImplementedError.new("run_command is only available in concrete implementations")
+      end
+
+      # Like run_command, but doesn't care about output.
+      def run_command_silently(full_command)
+        raise NotImplementedError.new("run_command_silently is only available in concrete implementations")
+      end
+
+      # Returns a given environment variables' value.
+      def [](var_name)
+        run(:true)[var_name]
+      end
+
+      protected
+
+      # When called, will use the current environment to source the wrapper scripts
+      # as well as invoking the current setup block. as defined on initialization / via #setup.
+      def invoke_setup!
+        source_command_wrapper
+        @setup_block.call(self) if @setup_block
+      end
+
+      # Uses run_silently to source the wrapper file.
+      def source_command_wrapper
+        run_silently :source, WRAPPER_LOCATION
+      end
+
+      # Returns a command followed by the call to show the epilog.
+      def wrapped_command(command)
+        "#{command}; __rvm_show_command_epilog"
+      end
+
+      # Wraps a command in a way that it prints no output.
+      def silent_command(command)
+        "{ #{command}; } >/dev/null 2>&1"
+      end
+
+      # Checks whether the given command includes a epilog, marked by
+      # epilog start and end lines.
+      def command_complete?(c)
+        start_index, end_index = c.index(COMMAND_EPILOG_START), c.index(COMMAND_EPILOG_END)
+        start_index && end_index && start_index < end_index
+      end
+
+      # Takes a raw string from a processes STDIO and returns three things:
+      # 1. The actual stdout, minus epilogue.
+      # 2. YAML output of the process results.
+      # 3. Any left over from the STDIO text.
+      def raw_stdout_to_parts(c)
+        raise IncompleteCommandError if !command_complete?(c)
+        before, after = c.split(COMMAND_EPILOG_START, 2)
+        epilog, after = after.split(COMMAND_EPILOG_END, 2)
+        return before, YAML.load(epilog.strip), after
+      end
+
+      include RVM::Shell::Utility
+    end
+  end
+end

data/lib/rvm/shell/result.rb

@@ -0,0 +1,42 @@
+module RVM
+  module Shell
+    # Represents the output of a shell command.
+    # This includes the exit status (and the helpful #successful? method)
+    # as well accessors for the command and stdout / stderr.
+    class Result
+
+      attr_reader :command, :stdout, :stderr, :raw_status
+
+      # Creates a new result object with the given details.
+      def initialize(command, status, stdout, stderr)
+        @command     = command.dup.freeze
+        @raw_status  = status
+        @environment = @raw_status["environment"] || {}
+        @successful  = (exit_status == 0)
+        @stdout      = stdout.freeze
+        @stderr      = stderr.freeze
+      end
+
+      # Returns the hash of the environment.
+      def env
+        @environment
+      end
+
+      # Whether or not the command had a successful exit status.
+      def successful?
+        @successful
+      end
+
+      # Returns a value from the outputs environment.
+      def [](key)
+        env[key.to_s]
+      end
+
+      # Returns the exit status for the program
+      def exit_status
+        @exit_status ||= (Integer(@raw_status["exit_status"]) rescue 1)
+      end
+
+    end
+  end
+end

data/lib/rvm/shell/shell_wrapper.sh

@@ -0,0 +1,10 @@
+# Prints an epilog to a shell command.
+__rvm_show_command_epilog() {
+  local last_command_result="$?"
+  echo "---------------RVM-RESULTS-START---------------"
+  echo "---"
+  echo " exit_status: \"$last_command_result\""
+  echo " environment:"
+  env | sed "s#'#\\'#" | sed -e 's#"#\\"#' -e "s#\\([^=]*\\)=\\(.*\\)#   '\1': \"\2\"#"
+  echo "----------------RVM-RESULTS-END----------------"
+}

data/lib/rvm/shell/single_shot_wrapper.rb

@@ -0,0 +1,56 @@
+require 'open3'
+
+module RVM
+  module Shell
+    # Implementation of the abstract wrapper class that opens a new
+    # instance of bash when a command is run, only keeping it around
+    # for the lifetime of the command. Possibly inefficient but for
+    # the moment simplest and hence default implementation.
+    class SingleShotWrapper < AbstractWrapper
+
+      attr_accessor :current
+
+      # Runs a given command in the current shell.
+      # Defaults the command to true if empty.
+      def run_command(command)
+        command = "true" if command.to_s.strip.empty?
+        with_shell_instance do
+          stdin.puts wrapped_command(command)
+          stdin.close
+          out, err = stdout.read, stderr.read
+          out, status, _ = raw_stdout_to_parts(out)
+          return status, out, err
+        end
+      end
+
+      # Runs a command, ensuring no output is collected.
+      def run_command_silently(command)
+        with_shell_instance do
+          stdin.puts silent_command(command)
+        end
+      end
+
+      protected
+
+      # yields stdio, stderr and stdin for a shell instance.
+      # If there isn't a current shell instance, it will create a new one.
+      # In said scenario, it will also cleanup once it is done.
+      def with_shell_instance(&blk)
+        no_current = @current.nil?
+        if no_current
+          @current = Open3.popen3(self.shell_executable)
+          invoke_setup!
+        end
+        yield
+      ensure
+        @current = nil if no_current
+      end
+
+      # Direct access to each of the named descriptors
+      def stdin;  @current[0]; end
+      def stdout; @current[1]; end
+      def stderr; @current[2]; end
+
+    end
+  end
+end

data/lib/rvm/shell/utility.rb

@@ -0,0 +1,37 @@
+module RVM
+  module Shell
+    module Utility
+
+      public
+
+      # Takes an array / number of arguments and converts
+      # them to a string useable for passing into a shell call.
+      def escape_arguments(*args)
+        return '' if args.nil?
+        args.flatten.map { |a| escape_argument(a.to_s) }.join(" ")
+      end
+
+      # Given a string, converts to the escaped format. This ensures
+      # that things such as variables aren't evaluated into strings
+      # and everything else is setup as expected.
+      def escape_argument(s)
+        return "''" if s.empty?
+        s.scan(/('+|[^']+)/).map do |section|
+          section = section.first
+          if section[0] == ?'
+            "\\'" * section.length
+          else
+            "'#{section}'"
+          end
+        end.join
+      end
+
+      # From a command, will build up a runnable command. If args isn't provided,
+      # it will escape arguments.
+      def build_cli_call(command, args = nil)
+        "#{command} #{escape_arguments(args)}".strip
+      end
+
+    end
+  end
+end

data/lib/rvm/version.rb

@@ -1,15 +1,19 @@
+require 'yaml'
+
 module RVM
   module Version
 
-    require "yaml"
-
-    YAML   = YAML.load_file("#{File.expand_path(File.dirname(__FILE__))}/../VERSION.yml")
-
-    MAJOR  = YAML[:major]
-    MINOR  = YAML[:minor]
-    PATCH  = YAML[:patch]
+    # YAML of raw version info
+    VERSION_YAML = YAML.load_file(File.expand_path("../VERSION.yml", File.dirname(__FILE__)))
 
-    STRING = "#{MAJOR}.#{MINOR}.#{PATCH}"
+    # Current major version of rvm
+    MAJOR  = VERSION_YAML[:major]
+    # Current minor version of rvm
+    MINOR  = VERSION_YAML[:minor]
+    # Current patch level of rvm
+    PATCH  = VERSION_YAML[:patch]
+    # A String with the current rvm version
+    STRING = [MAJOR, MINOR, PATCH].join(".").freeze
 
   end
 end

data/rvm.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rvm}
-  s.version = "0.1.41"
+  s.version = "0.1.42"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Wayne E. Seguin"]
-  s.date = %q{2010-07-08}
+  s.date = %q{2010-07-20}
   s.default_executable = %q{rvm-install}
   s.description = %q{Manages Ruby interpreter environments and switching between them.}
   s.email = %q{wayneeseguin@gmail.com}
@@ -22,6 +22,7 @@ Gem::Specification.new do |s|
      "README",
      "binscripts/rvm",
      "binscripts/rvm-prompt",
+     "binscripts/rvm-shell",
      "binscripts/rvm-update-head",
      "binscripts/rvm-update-latest",
      "binscripts/rvmsudo",
@@ -29,6 +30,7 @@ Gem::Specification.new do |s|
      "config/known",
      "config/md5",
      "contrib/gemset_snapshot",
+     "contrib/install-system-wide",
      "examples/rvmrc",
      "gemsets/default.gems",
      "gemsets/global.gems",
@@ -61,9 +63,27 @@ Gem::Specification.new do |s|
      "install",
      "lib/VERSION.yml",
      "lib/rvm.rb",
-     "lib/rvm/open4.rb",
-     "lib/rvm/rvm.rb",
+     "lib/rvm/capistrano.rb",
+     "lib/rvm/environment.rb",
+     "lib/rvm/environment/alias.rb",
+     "lib/rvm/environment/cleanup.rb",
+     "lib/rvm/environment/configuration.rb",
+     "lib/rvm/environment/env.rb",
+     "lib/rvm/environment/gemset.rb",
+     "lib/rvm/environment/info.rb",
+     "lib/rvm/environment/list.rb",
+     "lib/rvm/environment/rubies.rb",
+     "lib/rvm/environment/sets.rb",
+     "lib/rvm/environment/tools.rb",
+     "lib/rvm/environment/utility.rb",
+     "lib/rvm/environment/wrapper.rb",
+     "lib/rvm/errors.rb",
      "lib/rvm/shell.rb",
+     "lib/rvm/shell/abstract_wrapper.rb",
+     "lib/rvm/shell/result.rb",
+     "lib/rvm/shell/shell_wrapper.sh",
+     "lib/rvm/shell/single_shot_wrapper.rb",
+     "lib/rvm/shell/utility.rb",
      "lib/rvm/version.rb",
      "rvm.gemspec",
      "scripts/alias",
@@ -76,6 +96,7 @@ Gem::Specification.new do |s|
      "scripts/color",
      "scripts/completion",
      "scripts/db",
+     "scripts/disk-usage",
      "scripts/docs",
      "scripts/env",
      "scripts/fetch",
@@ -91,6 +112,7 @@ Gem::Specification.new do |s|
      "scripts/list",
      "scripts/log",
      "scripts/maglev",
+     "scripts/man",
      "scripts/manage",
      "scripts/manpages",
      "scripts/match",
@@ -105,6 +127,7 @@ Gem::Specification.new do |s|
      "scripts/rvm-install",
      "scripts/selector",
      "scripts/set",
+     "scripts/tools",
      "scripts/update",
      "scripts/utility",
      "scripts/version",