geminstaller 0.2.0

data/lib/geminstaller/autogem.rb

@@ -0,0 +1,43 @@
+module GemInstaller
+  class Autogem
+    attr_writer :gem_command_manager, :gem_spec_manager, :gem_source_index_proxy
+    def autogem(gems)
+      @gem_source_index_proxy.refresh!
+      reversed_gems = gems.reverse!
+      @completed_names = []
+      @completed_gems = []
+      reversed_gems.each do |gem|
+        process_gem(gem)
+      end
+      @completed_gems
+    end
+    
+    def process_gem(gem)
+      unless @completed_names.index(gem.name) or gem.no_autogem
+        invoke_require_gem_command(gem.name, gem.version)
+        @completed_names << gem.name
+        @completed_gems << gem
+      end
+      process_gem_dependencies(gem)
+    end
+    
+    def process_gem_dependencies(gem)
+      # TODO: this method is duplicated in rogue_gem_finder.  Should abstract and take a block
+      matching_gems = @gem_spec_manager.local_matching_gems(gem)
+      matching_gems.each do |matching_gem|
+        dependency_gems = @gem_command_manager.dependency(matching_gem.name, matching_gem.version.to_s)
+        dependency_gems.each do |dependency_gem|
+          process_gem(dependency_gem)
+        end
+      end
+    end
+
+    def invoke_require_gem_command(name, version)
+      if Gem::RubyGemsVersion.index('0.8') == 0
+        require_gem(name, version)
+      else
+        gem(name, version)
+      end
+    end
+  end
+end

data/lib/geminstaller/config.rb

@@ -0,0 +1,69 @@
+module GemInstaller
+  class Config
+    def initialize(yaml)
+      @yaml = yaml
+      @default_install_options_string = nil
+    end
+
+    def gems
+      parse_defaults
+      gem_defs = @yaml["gems"]
+      gems = []
+      gem_defs.each do |gem_def|
+        name = gem_def['name']
+        version = gem_def['version'].to_s
+        platform = gem_def['platform'].to_s
+        # get install_options for specific gem, if specified
+        install_options_string = gem_def['install_options'].to_s
+        # if no install_options were specified for specific gem, and default install_options were specified...
+        if install_options_string.empty? &&
+           !@default_install_options_string.nil? && 
+           !@default_install_options_string.empty? then
+          # then use the default install_options
+          install_options_string = @default_install_options_string
+        end
+        install_options_array = []
+        # if there was an install options string specified, default or gem-specific, parse it to an array
+        install_options_array = install_options_string.split(" ") unless install_options_string.empty?
+
+        check_for_upgrade = gem_def['check_for_upgrade']
+        if check_for_upgrade.nil? && defined? @default_check_for_upgrade then
+          check_for_upgrade = @default_check_for_upgrade
+        end
+
+        fix_dependencies = gem_def['fix_dependencies']
+        if fix_dependencies.nil? && defined? @default_fix_dependencies then
+          fix_dependencies = @default_fix_dependencies
+        end
+
+        no_autogem = gem_def['no_autogem']
+        if no_autogem.nil? && defined? @default_no_autogem then
+          no_autogem = @default_no_autogem
+        end
+
+        gem = GemInstaller::RubyGem.new(
+          name, 
+          :version => version, 
+          :platform => platform, 
+          :install_options => install_options_array, 
+          :check_for_upgrade => check_for_upgrade,
+          :no_autogem => no_autogem,
+          :fix_dependencies => fix_dependencies)
+        gems << gem
+      end
+      gems.sort!
+      return gems
+    end
+
+    protected
+
+    def parse_defaults
+      defaults = @yaml["defaults"]
+      return if defaults.nil?
+      @default_install_options_string = defaults['install_options']
+      @default_check_for_upgrade = defaults['check_for_upgrade']
+      @default_fix_dependencies = defaults['fix_dependencies']
+      @default_no_autogem = defaults['no_autogem']
+    end
+  end
+end

data/lib/geminstaller/config_builder.rb

@@ -0,0 +1,40 @@
+dir = File.dirname(__FILE__)
+require File.expand_path("#{dir}/requires.rb")
+
+module GemInstaller
+  class ConfigBuilder
+    attr_reader :config_file_paths_array
+    attr_writer :file_reader
+    attr_writer :yaml_loader
+    attr_writer :config_file_paths
+    
+    def self.default_config_file_path
+      'geminstaller.yml'
+    end
+
+    def build_config
+      @config_file_paths ||= GemInstaller::ConfigBuilder.default_config_file_path
+      @config_file_paths_array = @config_file_paths.split(",")
+      merged_defaults = {}
+      merged_gems = {}
+      @config_file_paths_array.each do |path|
+        file_contents = @file_reader.read(path)
+        next unless file_contents
+        next if file_contents.empty?
+        file_contents_erb = ERB.new(%{#{file_contents}})
+        yaml = @yaml_loader.load(file_contents_erb.result)
+        merged_defaults.merge!(yaml['defaults']) unless yaml['defaults'].nil?
+        next unless yaml['gems']
+        yaml['gems'].each do |gem|
+          gem_key = [gem['name'],gem['version'],gem['platform']].join('-')
+          merged_gems[gem_key] = gem
+        end
+      end
+      merged_yaml = {}
+      merged_yaml['defaults'] = merged_defaults
+      merged_yaml['gems'] = merged_gems.values
+      config = GemInstaller::Config.new(merged_yaml)
+      config
+    end
+  end
+end

data/lib/geminstaller/dependency_injector.rb

@@ -0,0 +1,129 @@
+module GemInstaller
+  class DependencyInjector
+    def registry
+      @registry ||= create_registry
+    end
+    
+    def create_registry
+      # define the service registry
+      @registry = GemInstaller::Registry.new
+    end
+  end
+  
+  class Registry
+    attr_accessor :file_reader, :yaml_loader, :output_proxy, :config_builder, :gem_source_index, :gem_runner_proxy
+    attr_accessor :gem_runner, :gem_command_manager, :gem_list_checker, :app, :arg_parser, :options, :noninteractive_chooser
+    attr_accessor :gem_interaction_handler, :install_processor, :missing_dependency_finder, :valid_platform_selector
+    attr_accessor :output_listener, :outs_output_observer, :errs_output_observer, :output_filter, :autogem, :rogue_gem_finder
+    attr_accessor :gem_spec_manager
+
+    def initialize
+      @options = {}
+      @arg_parser = GemInstaller::ArgParser.new
+      @arg_parser.options = @options
+      
+      @file_reader = GemInstaller::FileReader.new
+      @yaml_loader = GemInstaller::YamlLoader.new
+      @gem_arg_processor = GemInstaller::GemArgProcessor.new
+      @version_specifier = GemInstaller::VersionSpecifier.new
+      @output_proxy = GemInstaller::OutputProxy.new
+      @output_proxy.options = @options
+      @output_filter = GemInstaller::OutputFilter.new
+      @output_filter.options = @options
+      @output_filter.output_proxy = @output_proxy
+      
+
+      @output_listener = GemInstaller::OutputListener.new
+      @output_listener.output_filter = @output_filter
+
+      @valid_platform_selector = GemInstaller::ValidPlatformSelector.new
+      @valid_platform_selector.output_filter = @output_filter
+      @valid_platform_selector.options = @options
+
+      @config_builder = GemInstaller::ConfigBuilder.new
+      @config_builder.file_reader = @file_reader
+      @config_builder.yaml_loader = @yaml_loader
+
+      @gem_source_index = Gem::SourceIndex.new
+      @gem_source_index_proxy = GemInstaller::GemSourceIndexProxy.new
+      @gem_source_index_proxy.gem_source_index = @gem_source_index
+
+      @gem_interaction_handler = GemInstaller::GemInteractionHandler.new
+      @noninteractive_chooser_class = GemInstaller::NoninteractiveChooser
+      @gem_interaction_handler.noninteractive_chooser_class = @noninteractive_chooser_class
+      @gem_interaction_handler.valid_platform_selector = @valid_platform_selector
+      
+      @outs_output_observer = GemInstaller::OutputObserver.new
+      @outs_output_observer.stream = :stdout
+      @outs_output_observer.register(@output_listener)
+      @errs_output_observer = GemInstaller::OutputObserver.new
+      @errs_output_observer.stream = :stderr
+      @errs_output_observer.register(@output_listener)
+      
+      @enhanced_stream_ui = GemInstaller::EnhancedStreamUI.new
+      @enhanced_stream_ui.outs = @outs_output_observer
+      @enhanced_stream_ui.errs = @errs_output_observer
+      @enhanced_stream_ui.gem_interaction_handler = @gem_interaction_handler
+
+      @gem_runner_class = Gem::GemRunner
+      @gem_cmd_manager_class = Gem::CommandManager
+      @exact_match_list_command = GemInstaller::ExactMatchListCommand.new
+      @gem_runner_proxy = GemInstaller::GemRunnerProxy.new
+      @gem_runner_proxy.gem_runner_class = @gem_runner_class
+      @gem_runner_proxy.gem_cmd_manager_class = @gem_cmd_manager_class
+      @gem_runner_proxy.output_listener = @output_listener
+      @gem_runner_proxy.enhanced_stream_ui = @enhanced_stream_ui
+      @gem_runner_proxy.options = @options
+      @gem_runner_proxy.output_filter = @output_filter
+      @gem_runner_proxy.exact_match_list_command = @exact_match_list_command
+  
+      @gem_spec_manager = GemInstaller::GemSpecManager.new
+      @gem_spec_manager.valid_platform_selector = @valid_platform_selector
+      @gem_spec_manager.gem_source_index_proxy = @gem_source_index_proxy
+      @gem_spec_manager.output_filter = @output_filter
+        
+      @gem_command_manager = GemInstaller::GemCommandManager.new
+      @gem_command_manager.gem_spec_manager = @gem_spec_manager
+      @gem_command_manager.gem_runner_proxy = @gem_runner_proxy
+      @gem_command_manager.gem_interaction_handler = @gem_interaction_handler
+        
+      @rogue_gem_finder = GemInstaller::RogueGemFinder.new
+      @rogue_gem_finder.gem_command_manager = @gem_command_manager
+      @rogue_gem_finder.gem_spec_manager = @gem_spec_manager
+      @rogue_gem_finder.output_proxy = @output_proxy
+      
+      @autogem = GemInstaller::Autogem.new
+      @autogem.gem_command_manager = @gem_command_manager
+      @autogem.gem_source_index_proxy = @gem_source_index_proxy
+      @autogem.gem_spec_manager = @gem_spec_manager
+
+      @gem_list_checker = GemInstaller::GemListChecker.new
+      @gem_list_checker.gem_command_manager = @gem_command_manager
+      @gem_list_checker.gem_arg_processor = @gem_arg_processor
+      @gem_list_checker.version_specifier = @version_specifier
+
+      @missing_dependency_finder = GemInstaller::MissingDependencyFinder.new
+      @missing_dependency_finder.gem_command_manager = @gem_command_manager
+      @missing_dependency_finder.gem_spec_manager = @gem_spec_manager
+      @missing_dependency_finder.gem_arg_processor = @gem_arg_processor
+      @missing_dependency_finder.output_filter = @output_filter
+
+      @install_processor = GemInstaller::InstallProcessor.new
+      @install_processor.options = @options
+      @install_processor.gem_list_checker = @gem_list_checker
+      @install_processor.gem_command_manager = @gem_command_manager
+      @install_processor.gem_spec_manager = @gem_spec_manager
+      @install_processor.missing_dependency_finder = @missing_dependency_finder
+      @install_processor.output_filter = @output_filter
+
+      @app = GemInstaller::Application.new
+      @app.autogem = @autogem
+      @app.rogue_gem_finder = @rogue_gem_finder
+      @app.options = @options
+      @app.arg_parser = @arg_parser
+      @app.config_builder = @config_builder
+      @app.install_processor = @install_processor
+      @app.output_filter = @output_filter
+    end
+  end
+end

data/lib/geminstaller/enhanced_stream_ui.rb

@@ -0,0 +1,57 @@
+module GemInstaller
+  class EnhancedStreamUI < Gem::StreamUI
+    attr_writer :gem_interaction_handler, :outs, :errs
+    
+    def initialize()
+      # override default constructor to have no args
+    end
+    
+    def ask_yes_no(question, default=nil)
+      begin
+        @gem_interaction_handler.handle_ask_yes_no(question)
+      rescue Exception => e
+        @outs.print(question)
+        @outs.flush
+        raise e
+      end
+      raise_unexpected_prompt_error(question)
+    end
+    
+    def ask(question)
+      raise_unexpected_prompt_error(question)
+    end
+    
+    def choose_from_list(question, list)
+      @gem_interaction_handler.handle_choose_from_list(question, list)
+    end
+
+    def terminate_interaction!(status=-1)
+      raise_error(status)
+    end
+    
+    def terminate_interaction(status=0)
+      raise_error(status) unless status == 0
+      raise GemInstaller::RubyGemsExit.new(status)
+    end
+    
+    def alert_error(statement, question=nil)
+      # if alert_error got called due to a GemInstaller::UnexpectedPromptError, re-throw it
+      last_exception = $!
+      if last_exception.class == GemInstaller::UnauthorizedDependencyPromptError || last_exception.class == GemInstaller::RubyGemsExit
+        raise last_exception
+      end
+      # otherwise let alert_error continue normally...
+      super(statement, question)
+    end
+    
+    protected
+    def raise_error(status)
+      raise GemInstaller::GemInstallerError.new("RubyGems exited abnormally.  Status: #{status}\n")
+    end
+    
+    def raise_unexpected_prompt_error(question)
+      raise GemInstaller::UnexpectedPromptError.new("GemInstaller Internal Error - Unexpected prompt received from RubyGems: '#{question}'.")
+    end
+
+  end
+end

data/lib/geminstaller/exact_match_list_command.rb

@@ -0,0 +1,16 @@
+module GemInstaller
+  class ExactMatchListCommand < Gem::ListCommand
+    def execute
+      string = get_one_optional_argument || ''
+      # This overrides the default RubyGems ListCommand behavior of doing a wildcard match.  This caused problems
+      # when some gems (ActiveRecord-JDBC) caused exceptions during a remote list, causing a remote list
+      # of other gems (activerecord) to fail as well
+      options[:name] = /^#{string}$/i
+      # Do a little metaprogramming magic to avoid calling the problematic execute method on the ListCommand
+      # superclass, and instead directly call the method on the QueryCommand grandparent 'supersuperclass'
+      unbound_execute_method = Gem::QueryCommand.instance_method(:execute)
+      bound_execute_method = unbound_execute_method.bind(self)
+      bound_execute_method.call
+    end
+  end
+end

data/lib/geminstaller/file_reader.rb

@@ -0,0 +1,31 @@
+module GemInstaller
+  class FileReader
+    def read(file_path)
+      file_contents = nil
+      if !File.exist?(file_path) then
+        raise GemInstaller::MissingFileError.new("#{file_path}")
+      end
+
+      file = nil
+      begin
+        file = do_open(file_path)
+      rescue
+        raise GemInstaller::GemInstallerError.new("Error: Unable open file #{file_path}.  Please ensure that this file can be opened.\n")
+      end
+
+      begin
+        do_read(file)
+      rescue
+        raise GemInstaller::GemInstallerError.new("Error: Unable read file #{file_path}.  Please ensure that this file can be read.\n")
+      end
+    end
+    
+    def do_open(file_path)
+      File.open(file_path)
+    end
+    
+    def do_read(file)
+      file.read
+    end
+  end
+end

data/lib/geminstaller/gem_arg_processor.rb

@@ -0,0 +1,44 @@
+module GemInstaller
+  class GemArgProcessor
+    #Common Options:
+    #      --source URL                 Use URL as the remote source for gems
+    #  -p, --[no-]http-proxy [URL]      Use HTTP proxy for remote operations
+    #  -h, --help                       Get help on this command
+    #  -v, --verbose                    Set the verbose level of output
+    #      --config-file FILE           Use this config file instead of default
+    #      --backtrace                  Show stack backtrace on errors
+    #      --debug                      Turn on Ruby debugging
+    GEM_COMMON_OPTIONS_WITHOUT_ARG = ['--no-http-proxy','-v','--verbose','--backtrace','--debug']
+    GEM_COMMON_OPTIONS_WITH_ARG = ['--source','-p','--http_proxy','--config-file']
+    
+    # take an array of args, and strip all args that are not common gem command args
+    def strip_non_common_gem_args(args)
+      # I can't figure out a way to elegantly do this, so I hardcoded the options.  Here's how you print them
+      # Gem::Command.common_options.each do |option|
+      #  p option[0]
+      # end
+
+      common_args = [] 
+      i = 0
+      loop do
+        break if i == args.size
+        arg = args[i]
+        if GEM_COMMON_OPTIONS_WITHOUT_ARG.include?(arg)
+          common_args << arg
+        else
+          GEM_COMMON_OPTIONS_WITH_ARG.each do |option|
+            if arg.include?(option)
+              common_args << arg
+              unless arg.include?('=')
+                i += 1
+                common_args << args[i]
+              end
+            end
+          end
+        end
+        i += 1
+      end
+      common_args
+    end
+  end
+end

data/lib/geminstaller/gem_command_line_proxy.rb

@@ -0,0 +1,32 @@
+module GemInstaller
+  class GemCommandLineProxy
+    GEM_ERROR_REGEXP = /^ERROR.*/
+    def run(args)
+      args_string = args.join(" ")
+      output = `gem #{args_string} 2>&1`
+      return_value = $?
+      lines = output.split("\n")
+      # return value is always zero on windows (from gem.bat), so we have to resort to parsing the output
+      error_in_output = false
+      lines.each do |line|
+        if line.match(GemInstaller::GemCommandLineProxy::GEM_ERROR_REGEXP)
+          error_in_output = true
+          break
+        end
+      end
+      if (return_value != 0 or error_in_output)
+        error_message = "Error: gem command failed.  Command was 'gem #{args_string}', return value was '#{return_value}'.  Output was:\n"
+        lines.each do |line| 
+          error_message += '  ' + line + '\n'
+        end
+        raise GemInstaller::GemInstallerError.new(error_message)
+      end
+      return lines
+    end
+  end
+end
+
+
+
+
+

data/lib/geminstaller/gem_command_manager.rb

@@ -0,0 +1,62 @@
+module GemInstaller
+  class GemCommandManager
+    attr_writer :gem_spec_manager, :gem_runner_proxy, :gem_interaction_handler
+    
+    def list_remote_gem(gem, additional_options)
+      run_args = ["list",gem.name,"--remote"]
+      run_args += additional_options
+      @gem_runner_proxy.run(run_args)
+    end
+
+    def uninstall_gem(gem)
+      return if !@gem_spec_manager.is_gem_installed?(gem)
+      @gem_interaction_handler.dependent_gem = gem
+      run_gem_command('uninstall',gem)
+    end
+
+    def install_gem(gem)
+      return if @gem_spec_manager.is_gem_installed?(gem)
+      @gem_interaction_handler.dependent_gem = gem
+      run_gem_command('install',gem)
+    end
+    
+    def dependency(name, version, additional_options = [])
+      # it would be great to use the dependency --pipe option, but unfortunately, rubygems has a bug
+      # up to at least 0.9.2 where the pipe options uses 'puts', instead of 'say', so we can't capture it
+      # with enhanced_stream_ui.  Patch submitted: 
+      # http://rubyforge.org/tracker/index.php?func=detail&aid=9020&group_id=126&atid=577
+      run_args = ["dependency",/^#{name}$/,"--version",version]
+      run_args += additional_options
+      output_lines = @gem_runner_proxy.run(run_args)
+      # dependency output has all lines in the first element
+      output_array = output_lines[0].split("\n")
+      # drop the first line which just echoes the dependent gem
+      output_array.shift
+      # drop the line containing 'requires' (rubygems < 0.9.0)
+      if output_array[0] == '  Requires'
+        output_array.shift
+      end
+      # drop all empty lines
+      output_array.reject! { |line| line == "" }
+      # strip leading space
+      output_array.each { |line| line.strip! }
+      # convert into gems
+      output_gems = output_array.collect do |line|
+        name = line.split(' ')[0]
+        version_spec = line.split(/[()]/)[1]
+        GemInstaller::RubyGem.new(name, :version => version_spec)
+      end
+    end
+
+    def run_gem_command(gem_command,gem)
+      run_args = [gem_command,gem.name,"--version", "#{gem.version}"]
+      run_args += gem.install_options
+      @gem_runner_proxy.run(run_args)
+    end
+  end
+end
+
+
+
+
+

data/lib/geminstaller/gem_interaction_handler.rb

@@ -0,0 +1,30 @@
+module GemInstaller
+  class GemInteractionHandler
+    attr_writer :dependent_gem, :noninteractive_chooser_class, :valid_platform_selector
+    DEPENDENCY_PROMPT = 'Install required dependency'
+    
+    def handle_ask_yes_no(question)
+      return unless question.index(DEPENDENCY_PROMPT)
+      message = "Error: RubyGems is prompting to install a required dependency, and you have not " +
+                "specified the '--install-dependencies' option for the current gem.  You must modify your " +
+                "geminstaller config file to either specify the '--install-depencencies' (-y) " +
+                "option, or explicitly add an entry for the dependency gem earlier in the file.\n"
+      raise GemInstaller::UnauthorizedDependencyPromptError.new(message)
+    end
+    
+    def handle_choose_from_list(question, list, noninteractive_chooser = nil)
+      noninteractive_chooser ||= @noninteractive_chooser_class.new
+      valid_platforms = nil
+      if dependent_gem_with_platform_specified?(list, noninteractive_chooser) or noninteractive_chooser.uninstall_list_type?(question)
+        valid_platforms = [@dependent_gem.platform]
+      else
+        valid_platforms = @valid_platform_selector.select(@dependent_gem.platform)
+      end
+      noninteractive_chooser.choose(question, list, @dependent_gem.name, @dependent_gem.version, valid_platforms)
+    end
+    
+    def dependent_gem_with_platform_specified?(list, noninteractive_chooser)
+      noninteractive_chooser.dependent_gem?(@dependent_gem.name, list) and @dependent_gem.platform
+    end
+  end
+end

data/lib/geminstaller/gem_list_checker.rb

@@ -0,0 +1,55 @@
+module GemInstaller
+  class GemListChecker
+    attr_writer :gem_command_manager, :gem_arg_processor, :version_specifier
+    
+    def find_remote_matching_gem(gem)
+      gem_list_match_regexp =  /^#{gem.regexp_escaped_name} \(.*/
+      common_args = @gem_arg_processor.strip_non_common_gem_args(gem.install_options)
+      remote_list = @gem_command_manager.list_remote_gem(gem, common_args)
+
+      matched_lines = []
+      remote_list.each do |line|
+        if line.match(gem_list_match_regexp)
+          matched_lines << line
+        end
+      end
+      
+      if matched_lines.size > 1
+        error_message = "Error: more than one remote gem matches (this should not happen and is probably a bug in geminstaller).  Gem name = '#{gem.name}', install options = '#{gem.install_options}'.  Matching remote gems: \n"
+        matched_lines.each do |line|
+          error_message += line + "\n"
+        end
+        raise GemInstaller::GemInstallerError.new(error_message)
+      end
+
+      if matched_lines.size == 0
+        error_message = "Error: Could not find remote gem to install.  Gem name = '#{gem.name}', install options = '#{gem.install_options}'"
+        raise GemInstaller::GemInstallerError.new(error_message)
+      end
+
+      return matched_lines[0]
+    end
+    
+    def verify_and_specify_remote_gem!(gem)
+      # TODO: this seems like it is a hack, but we must have a non-ambiguous version on the gem in order for 
+      # noninteractive_chooser to be able to parse the gem list for multi-platform gems.  This will not be necessary
+      # if a future RubyGems release allows specification/searching of the platform, because then we won't need noninteractive_chooser
+      
+      version_list = available_versions(gem)
+      specified_version = @version_specifier.specify(gem.version, version_list, gem.name)
+      gem.version = specified_version
+    end
+
+    def available_versions(gem)
+      remote_match_line = find_remote_matching_gem(gem)
+      version_list = parse_out_version_list(remote_match_line)
+    end
+    
+    def parse_out_version_list(line)
+      # return everything between first set of parenthesis
+      version_list = line.split(/[()]/)[1]
+      version_list
+    end
+        
+  end
+end

data/lib/geminstaller/gem_runner_proxy.rb

@@ -0,0 +1,43 @@
+module GemInstaller
+  class GemRunnerProxy
+    attr_writer :gem_runner_class, :gem_cmd_manager_class, :output_listener, :exact_match_list_command
+    attr_writer :options, :enhanced_stream_ui, :output_filter
+
+    def run(args = [], stdin = [])
+      @output_filter.geminstaller_output(:commandecho,"'gem #{args.join(' ')}'\n")
+      gem_runner = create_gem_runner
+      # We have to manually initialize the configuration here, or else the GemCommandManager singleton
+      # will initialize with the (incorrect) default args when we call GemRunner.run.
+      gem_runner.do_configuration(args)
+      gem_cmd_manager = @gem_cmd_manager_class.instance
+      gem_cmd_manager.ui = @enhanced_stream_ui
+      gem_cmd_manager.register_command @exact_match_list_command
+      
+      exit_status = nil
+      begin
+        gem_runner.run(args)
+      rescue GemInstaller::RubyGemsExit => normal_exit
+        exit_status = normal_exit.message
+      rescue GemInstaller::GemInstallerError => exit_error
+        raise_error_with_output(exit_error, args, @output_listener)
+      end
+      output_lines = @output_listener.read!
+      output_lines.push(exit_status) if exit_status
+      return output_lines
+    end
+    
+    def create_gem_runner
+      rubygems_version = Gem::RubyGemsVersion
+      if rubygems_version.index('0.8') == 0
+        @gem_runner_class.new()
+      else
+        @gem_runner_class.new(:command_manager => @gem_cmd_manager_class)
+      end
+    end
+        
+    def raise_error_with_output(exit_error, args, listener)
+      descriptive_exit_message = exit_error.descriptive_exit_message(exit_error.message, 'gem', args, listener)
+      raise exit_error.class.new(descriptive_exit_message)
+    end
+  end
+end

data/lib/geminstaller/gem_source_index_proxy.rb

@@ -0,0 +1,21 @@
+module GemInstaller
+  class GemSourceIndexProxy
+    attr_writer :gem_source_index
+
+    def refresh!
+      @gem_source_index.refresh!
+    end
+
+    # NOTE: We will require an exact version requirement, rather than the standard default Gem version_requirement of ">= 0"
+    #       GemInstaller has it's own default defined elsewhere
+    def search(gem_pattern, version_requirement)
+      # Returns an array of Gem::Specification objects
+      @gem_source_index.search(gem_pattern, version_requirement)
+    end
+  end
+end
+
+
+
+
+