gemrage 0.1.1 → 0.1.2

data/vendor/ruby/1.8/gems/rvm-1.0.14/lib/rvm/environment/sets.rb

@@ -0,0 +1,123 @@
+module RVM
+  class Environment
+
+    # Passed either something containing ruby code or
+    # a path to a ruby file, will attempt to exectute
+    # it in the current environment.
+    def ruby(runnable, options = {})
+      if runnable.respond_to?(:path)
+        # Call the path
+        ruby_run runnable.path, options
+      elsif runnable.respond_to?(:to_str)
+        runnable = runnable.to_str
+        File.exist?(runnable) ? ruby_run(runnable, options) : ruby_eval(runnable, options)
+      elsif runnable.respond_to?(:read)
+        ruby_run runnable.read
+      end
+    end
+
+    # Eval the given code within ruby.
+    def ruby_eval(code, options = {})
+      perform_set_operation :ruby, "-e", code.to_s, options
+    end
+
+    # Run the given path as a ruby script.
+    def ruby_run(path, options = {})
+      perform_set_operation :ruby, path.to_s, options
+    end
+
+    # Execute rake (optionally taking the path to a rake file),
+    # then change back.
+    def rake(file = nil, options = {})
+      if file.nil?
+        perform_set_operation :rake, options
+      else
+        file = File.expand_path(file)
+        chdir(File.dirname(file)) do
+          perform_set_operation(:rake, options.merge(:rakefile => file))
+        end
+      end
+    end
+
+    # Use the rvm test runner for unit tests.
+    def tests(options = {})
+      perform_set_operation :tests, options
+    end
+
+    # Use the rvm spec runner for specs.
+    def specs(options = {})
+      perform_set_operation :specs, options
+    end
+
+    # Like Kernel.system, but evaluates it within the environment.
+    # Also note that it doesn't support redirection etc.
+    def system(command, *args)
+      identifier = extract_identifier!(args)
+      args = [identifier, :exec, command, *args].compact
+      rvm(*args).successful?
+    end
+
+    # Executes a command, replacing the current shell.
+    # exec is a bit of an odd ball compared to the others, since
+    # it has to use the Kernel.exec builtin.
+    def exec(command, *args)
+      command = @shell_wrapper.build_cli_call(:exec, [command] + args)
+      Kernel.exec "bash", "-c", "source '#{env_path}'; #{command}"
+    end
+
+    protected
+
+    # Converts the given identifier to a rvm-friendly form.
+    # Unlike using sets directly, a nil identifier is set
+    # to mean the current ruby (not all). :all or "all" will
+    # instead return the a blank identifier / run it against
+    # all rubies.
+    def normalize_set_identifier(identifier)
+      case identifier
+      when nil, ""
+        @environment_name
+      when :all, "all"
+        nil
+      when Array
+        identifier.map { |i| normalize_set_identifier(i) }.uniq.join(",")
+      else
+        identifier.to_s
+      end
+    end
+
+    # From an options hash, extract the environment identifier.
+    def extract_environment!(options)
+      values = []
+      [:environment, :env, :rubies, :ruby].each do |k|
+        values << options.delete(k)
+      end
+      values.compact.first
+    end
+
+    # Shorthand to extra an identifier from args.
+    # Since we
+    def extract_identifier!(args)
+      options = extract_options!(args)
+      identifier = normalize_set_identifier(extract_environment!(options))
+      args << options
+      identifier
+    end
+
+    # Performs a set operation. If the :env or :environment option is given,
+    # it will return a yaml summary (instead of the stdout / stderr etc via
+    # a Result object.
+    def perform_set_operation(*args)
+      options     = extract_options!(args)
+      environment = extract_environment!(options)
+      identifier  = normalize_set_identifier(environment)
+      # Uses yaml when we have multiple identifiers.
+      uses_yaml   = !environment.nil?
+      options.merge!(:yaml => true) if uses_yaml
+      args.unshift(identifier) unless identifier.nil?
+      args << options
+      result = rvm(*args)
+      uses_yaml ? YAML.load(result.stdout) : result
+    end
+
+  end
+end

data/vendor/ruby/1.8/gems/rvm-1.0.14/lib/rvm/environment/tools.rb

@@ -0,0 +1,68 @@
+module RVM
+  class Environment
+
+    # Gets the full name for the current env.
+    def tools_identifier
+      normalize rvm(:tools, :identifier).stdout
+    end
+
+    # Gets the identifier after cd'ing to a path, no destructive.
+    def tools_path_identifier(path)
+      path_identifier = rvm(:tools, "path-identifier", path.to_s)
+      if path_identifier.exit_status == 2
+        error_message = "The rvmrc located in '#{path}' could not be loaded, likely due to trust mechanisms."
+        error_message << " Please run 'rvm rvmrc {trust,untrust} \"#{path}\"' to continue, or set rvm_trust_rvmrcs to 1."
+        raise ErrorLoadingRVMRC, error_message
+      end
+      return normalize(path_identifier.stdout)
+    end
+
+    def tools_strings(*rubies)
+      rubies = rubies.flatten.join(",").split(",").uniq
+      names = {}
+      value = rvm(:tools, :strings, *rubies)
+      if value.successful?
+        parts = value.stdout.split
+        rubies.each_with_index do |key, index|
+          names[key] = normalize(parts[index])
+        end
+      end
+      names
+    end
+
+    # Return the tools wrapper.
+    def tools
+      @tools_wrapper ||= ToolsWrapper.new(self)
+    end
+
+    # Ruby like wrapper for tools
+    class ToolsWrapper
+
+      def initialize(parent)
+        @parent = parent
+      end
+
+      # Returns the current envs expanded identifier
+      def identifier
+        @parent.tools_identifier
+      end
+
+      # Returns the identifier for a path, taking into account
+      # things like an rvmrc
+      def path_identifier(path)
+        @parent.tools_path_identifier(File.expand_path(path))
+      end
+      alias identifier_for_path path_identifier
+
+      def strings(*rubies)
+        @parent.tools_strings(*rubies)
+      end
+
+      def expand_string(ruby)
+        strings(ruby)[ruby]
+      end
+
+    end
+
+  end
+end

data/vendor/ruby/1.8/gems/rvm-1.0.14/lib/rvm/environment/utility.rb

@@ -0,0 +1,173 @@
+module RVM
+  class Environment
+
+    PREFIX_OPTIONS = [:trace, :json, :yaml]
+
+    def self.default_rvm_path
+      value = `bash '#{File.expand_path('../shell/calculate_rvm_path.sh', File.dirname(__FILE__))}'`.strip
+      $?.success? && !value.empty? ? File.expand_path(value) : nil
+    end
+
+    # Returns the environment identifier for the current environment,
+    # as determined from the GEM_HOME.
+    def self.current_environment_id
+      @current_environment_id ||= begin
+        gem_home = ENV['GEM_HOME'].to_s.strip
+        if !gem_home.empty? && gem_home =~ /rvm\/gems\//
+          File.basename(gem_home)
+        else
+          matching_path = $:.select { |item| item =~ /rvm\/rubies/ }.first
+          matching_path.to_s.gsub(/^.*rvm\/rubies\//, '').split('/')[0] || "system"
+        end
+      end
+    end
+
+    # Returns the ruby string that represents the current environment.
+    def self.current_ruby_string
+      identifier_to_ruby_string(current_environment_id)
+    end
+
+    # Converts a ruby identifier (string + gemset) to just the ruby string.
+    def self.identifier_to_ruby_string(identifier)
+      identifier.gsub(/@.*$/, '')
+    end
+
+    # Returns the currentl environment.
+    # Note that when the ruby is changed, this is reset - Also,
+    # if the gemset is changed it will also be reset.
+    def self.current
+      @current_environment ||= Environment.new(current_environment_id)
+    end
+
+    # Sets the current environment back to the currently running ruby
+    # or the system env (if it can't be determined from GEM_HOME).
+    def self.reset_current!
+      @current_environment = nil
+    end
+
+    # Lets you build a command up, without needing to see the output.
+    # As an example,
+    #
+    #  rvm :use, "ree@rails3", :install => true
+    #
+    # Will call the following:
+    #
+    #  rvm use ree@rails3 --install
+    #
+    def rvm(*args)
+      options = extract_options!(args)
+      silent = options.delete(:silent)
+      rearrange_options!(args, options)
+      args += hash_to_options(options)
+      args.map! { |a| a.to_s }
+
+      if silent
+        run_silently('rvm', *args)
+      else
+        run('rvm', *args)
+      end
+    end
+
+    # Run commands inside the given directory.
+    def chdir(dir)
+      run_silently :pushd, dir.to_s
+      result = Dir.chdir(dir) { yield }
+      run_silently :popd
+      result
+    end
+
+    protected
+
+    # Moves certain options (e.g. yaml, json etc) to the front
+    # of the arguments list, making stuff like sets work.
+    def rearrange_options!(args, options)
+      prefix_options = {}
+      (PREFIX_OPTIONS + PREFIX_OPTIONS.map { |o| o.to_s }).each do |k|
+        if options.has_key?(k)
+          value = options.delete(k)
+          prefix_options[k.to_sym] = value
+        end
+      end
+      hash_to_options(prefix_options).reverse.each { |o| args.unshift(o) }
+    end
+
+    def ruby_string(result)
+      if result && result[:rvm_ruby_string]
+        result[:rvm_ruby_string]
+      else
+        self.class.identifier_to_ruby_string(expanded_name)
+      end
+    end
+
+    # Checks whether the given environment is compatible with the current
+    # ruby interpeter.
+    def compatible_with_current?(result)
+      ruby_string(result) == self.class.current_ruby_string
+    end
+
+    # Given an environment identifier, it will add the the given
+    # gemset to the end to form a qualified identifier name.
+    def self.environment_with_gemset(environment, gemset)
+      environment_name, gemset_name = environment.split("@", 2)
+      environment_name = "default"     if environment_name.to_s.empty?
+      environment_name << "@#{gemset}" unless gemset.to_s.empty?
+      environment_name
+    end
+
+    # Returns a value, or nil if it is blank.
+    def normalize(value)
+      value = value.to_s.strip
+      value.empty? ? nil : value
+    end
+
+    # Normalizes an array, removing blank lines.
+    def normalize_array(value)
+      value.split("\n").map { |line| line.strip }.reject { |line| line.empty? }
+    end
+
+    # Extract options from a hash.
+    def extract_options!(args)
+      args.last.is_a?(Hash) ? args.pop : {}
+    end
+
+    # Converts a hash of options to an array of command line argumets.
+    # If the value is false, it wont be added but if it is true only the
+    # key will be added. Lastly, when the value is neither true or false,
+    # to_s will becalled on it and it shall be added to the array.
+    def hash_to_options(options)
+      result = []
+      options.each_pair do |key, value|
+        real_key = "--#{key.to_s.gsub("_", "-")}"
+        if value == true
+          result << real_key
+        elsif value != false
+          result << real_key
+          result << value.to_s
+        end
+      end
+      result
+    end
+
+    # Recursively normalize options.
+    def normalize_option_value(value)
+      case value
+      when Array
+        value.map { |option| normalize_option_value(option) }.join(",")
+      else
+        value.to_s
+      end
+    end
+
+    def use_env_from_result!(result)
+      if compatible_with_current?(result)
+        ENV['GEM_HOME']    = result[:GEM_HOME]
+        ENV['GEM_PATH']    = result[:GEM_PATH]
+        ENV['BUNDLE_PATH'] = result[:BUNDLE_PATH]
+        Gem.clear_paths if defined?(Gem)
+      else
+        raise IncompatibleRubyError.new(result, "The given ruby environment requires #{ruby_string(result)} (versus #{self.class.current_ruby_string})")
+      end
+    end
+
+  end
+end

data/vendor/ruby/1.8/gems/rvm-1.0.14/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/vendor/ruby/1.8/gems/rvm-1.0.14/lib/rvm/environment.rb

@@ -0,0 +1,64 @@
+require 'forwardable'
+
+module RVM
+  # Implements the actual wrapper around the api. For more information
+  # about this design, see the RVM module.
+  class Environment
+    extend Forwardable
+
+    %w(configuration utility alias list gemset rubies cleanup sets env tools info).each do |key|
+      require File.join("rvm", "environment", key)
+    end
+
+    # The default config has rvm_silence_logging so that log doesn't print anything to stdout.
+    merge_config! :rvm_silence_logging => 1,
+                  :rvm_promptless      => 1,
+                  :rvm_ruby_api        => 1
+
+    attr_reader :environment_name, :shell_wrapper
+
+    # Creates a new environment with the given name and optionally
+    # a set of extra environment variables to be set on load.
+    def initialize(environment_name = "default", options = {})
+      merge_config! options
+      @environment_name = environment_name
+      @shell_wrapper = Shell.default_wrapper.new
+      @shell_wrapper.setup do |s|
+        source_rvm_environment
+        use_rvm_environment
+      end
+    end
+
+    def inspect
+      "#<#{self.class.name} environment_name=#{@environment_name.inspect}>"
+    end
+
+    # Returns the expanded name, using the same method as used by the rvm command line.
+    def expanded_name
+      @expanded_name ||= tools_identifier.to_s
+    end
+
+    # Actually define methods to interact with the shell wrapper.
+    def_delegators :@shell_wrapper, :run, :run_silently, :run_command_without_output,
+                   :run_command, :[], :escape_argument
+
+    protected
+
+    # Automatically load rvm config from the multiple sources.
+    def source_rvm_environment
+      rvm_path = config_value_for(:rvm_path, self.class.default_rvm_path, false)
+      actual_config = defined_config.merge('rvm_path' => rvm_path)
+      config = []
+      actual_config.each_pair do |k, v|
+        config << "#{k}=#{escape_argument(v.to_s)}"
+      end
+      run_silently :export, config.join(" ")
+      run_silently :source, File.join(rvm_path, "scripts", "rvm")
+    end
+
+    def use_rvm_environment
+      rvm :use, @environment_name, :silent => true
+    end
+
+  end
+end

data/vendor/ruby/1.8/gems/rvm-1.0.14/lib/rvm/errors.rb

@@ -0,0 +1,31 @@
+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
+  
+  # Called when tools.path_identifier is called on a dir with an untrusted rvmrc.
+  class ErrorLoadingRVMRC < Error; end
+
+end

data/vendor/ruby/1.8/gems/rvm-1.0.14/lib/rvm/install_command_dumper.rb

@@ -0,0 +1,51 @@
+# Prints out the rvm command (minus rvm install) to install this ruby.
+
+RUBY_NAME = File.basename(ENV['MY_RUBY_HOME'])
+RVM_HOME  = ENV['rvm_path']
+
+def ruby?(*names)
+  names.map { |n| n.to_s }.include?(RUBY_NAME.split("-").first)
+end
+
+def quote(value)
+  value = value.to_s.strip
+  value.empty? ? "" : "'#{value.gsub("'", "'\'\'")}'"
+end
+
+def normalize_argument(arg)
+  real_value, arg_value = arg.split("=", 2)
+  if !arg_value.nil?
+    real_value << "=#{quote(arg_value)}"
+  end
+  real_value.gsub("'#{RVM_HOME}", "'\"$rvm_path\"'")
+end
+
+def arguments_for_install
+  if ruby?(:ruby, :mput, :ree)
+    begin
+      require 'rbconfig'
+      require 'shellwords'
+      # Get the full arguments
+      config_args = Shellwords.shellwords(Config::CONFIG['configure_args'].to_s.strip)
+      real_arguments = []
+      config_args.each do |arg|
+        if ruby?(:ree) && arg == "--enable-mbari-api"
+          next
+        elsif arg =~ /^--prefix/
+          next
+        elsif arg =~ /^[^\-]/
+          next
+        else
+          real_arguments << normalize_argument(arg)
+        end
+      end
+      config_args = real_arguments.join(",")
+      return "-C #{quote(config_args)}" unless config_args.strip.empty?
+    rescue LoadError
+    end
+  end
+  return ""
+end
+
+# Finally, print the string to install it.
+puts "rvm install #{RUBY_NAME} #{arguments_for_install.gsub(/''+/, "'")}".strip

data/vendor/ruby/1.8/gems/rvm-1.0.14/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