jwhitmire-geminstaller 0.5.4

data/cruise_config.rb

@@ -0,0 +1,23 @@
+# Project-specific configuration for CruiseControl.rb
+require 'fileutils'
+require 'socket'
+
+Project.configure do |project|
+  triggers = []
+  if File.exists?(File.expand_path(File.dirname(project.path)) + '/../../RubyGems')
+    triggers << :RubyGems
+  end
+  if File.exists?(File.expand_path(File.dirname(project.path)) + '/../../dummyrepo')
+    triggers << :dummyrepo
+  end
+  project.triggered_by *triggers
+  project.email_notifier.emails = ['thewoolleyman@gmail.com'] if Socket.gethostname =~ /(thewoolleyweb.com|ci.pivotallabs.com)/ 
+  if project.name =~ /rubygems[_-](.*)$/ # geminstaller_using_rubygems_0-9-4
+    rubygems_version = $1
+    rubygems_version.gsub!('-','.')
+    ENV['RUBYGEMS_VERSION'] = rubygems_version
+  end
+  if project.name =~ /smoketest/i # smoketest project
+    project.rake_task = project.name
+  end
+end

data/focused_spec.sh

@@ -0,0 +1,2 @@
+# warning - experimental
+ruby -I spec/fixture/rubygems_dist/rubygems-1.0.1/lib/ /usr/local/bin/spec $1 --line=$2

data/focused_spec_debug.sh

@@ -0,0 +1,2 @@
+# warning - experimental
+ruby -I spec/lib/ruby-debug-0.10.0/cli:spec/lib/ruby-debug-0.10.0/bin:spec/lib/ruby-debug-base-0.10.0/lib:spec/lib/ruby-debug-0.10.0/bin/rdebug:spec/lib/rspec-1.1.1/lib spec/lib/ruby-debug-0.10.0/bin/rdebug spec/lib/rspec-1.1.1/bin/spec -- $1 --line=$2

data/geminstaller.yml

@@ -0,0 +1,47 @@
+---
+# GemInstaller config file which specifies the actual build, test, and doc dependencies for GemInstaller itself.
+defaults:
+  install_options: --no-ri --no-rdoc
+  #fix_dependencies: true
+gems:
+- name: diff-lcs
+  version: '>= 1.1.2'
+- name: hoe
+  version: '>= 2.3.2'
+- name: hoe-seattlerb
+  version: '>= 1.2.0'
+- name: open4
+  version: '>= 0.9.6'
+- name: rake
+  version: '>= 0.7.1'
+- name: rcov
+  version: '>= 0.7.0.1'
+  platform: <%= RUBY_PLATFORM =~ /mswin/ ? 'mswin32' : 'ruby'%>
+- name: RedCloth
+#  version: '= 3.0.4'
+  version: '= 4.0.4'
+- name: rspec
+  version: '>= 1.2.8'
+  # install dev dependencies for rspec, or else regression tests on older versions of rubygems with the dev dependencies
+  # bug (1.0, 1.1) fail - and currently Hoe swallows Rspec load error silently
+  install_options: --no-ri --no-rdoc --development
+- name: cmdparse
+  version: '>= 2.0.2'
+- name: ruby-debug
+  version: '>= 0.9.3'
+- name: webgen
+  version: '= 0.5.5'
+# - name: gettalong-webgen
+#   version: '>= 0.5.5.20081001'
+<% if RUBY_PLATFORM =~ /mswin/ %>
+- name: win32-process
+  version: '>= 0.5.5'
+  platform: 'mswin32'
+- name: win32console
+  version: '>= 1.0.8'
+  platform: 'mswin32'
+- name: win32-open3
+  version: '>= 0.2.5'
+  platform: 'mswin32'
+<% end %>
+    

data/lib/geminstaller/application.rb

@@ -0,0 +1,112 @@
+module GemInstaller
+  class Application
+    # we have accessors instead of just writers so that we can ensure it is assembled correctly in the dependency injector test
+    attr_accessor :config_builder, :install_processor, :output_filter, :arg_parser, :args, :options, :rogue_gem_finder, :bundler_exporter, :outdated_gem_finder
+    attr_writer :autogem
+    
+    def initialize
+      @args = nil
+    end
+    
+    def install
+      begin
+        exit_flag_and_return_code = handle_args
+        if exit_flag_and_return_code[0]
+          return exit_flag_and_return_code[1]
+        end
+        if @options[:bundler_export]
+          @bundler_exporter.output(@config_builder.build_config)
+          return 0
+        end
+        gems = create_gems_from_config
+        if @options[:print_rogue_gems]
+          @rogue_gem_finder.print_rogue_gems(gems, @config_builder.config_file_paths_array)
+          return 0
+        elsif @options[:print_outdated_gems]
+          @outdated_gem_finder.print_outdated_gems(gems, @config_builder.config_file_paths_array)
+          return 0
+        end
+        if gems.size == 0
+          message = "No gems found in config file.  Try the --print-rogue-gems option to help populate your config file."
+          @output_filter.geminstaller_output(:info,message + "\n")          
+        else
+          process_gems(gems)
+        end
+      rescue Exception => e
+        handle_exception(e)
+        return 1
+      end
+      return 0
+    end
+    
+    def autogem
+      begin
+        # TODO: do some validation that args only contains --config option, especially not print_rogue_gems since this would mask a missing file error
+        exit_flag_and_return_code = handle_args
+        if exit_flag_and_return_code[0]
+          return exit_flag_and_return_code[1]
+        end
+        gems = create_gems_from_config
+        message = "GemInstaller is automatically requiring gems: "
+        print_startup_message(gems, message)
+        return @autogem.autogem(gems)
+      rescue Exception => e
+        handle_exception(e)
+        return 1
+      end
+    end
+    
+    def handle_exception(e)
+      message = e.message
+      message += "\n"
+      @output_filter.geminstaller_output(:error,message)
+      backtrace_as_string = e.backtrace.join("\n")
+      @output_filter.geminstaller_output(:debug,"#{backtrace_as_string}\n")
+      raise e if @options[:exceptions]
+    end
+    
+    def create_gems_from_config
+      begin
+        config = @config_builder.build_config
+      rescue GemInstaller::MissingFileError => e
+        # if user wants to print rogue gems and they have no config at all, don't show an error
+        return [] if @options[:print_rogue_gems] && (@config_builder.config_file_paths_array.size == 1) 
+        missing_path = e.message
+        error_message = "Error: A GemInstaller config file is missing at #{missing_path}.  You can generate one with the --print-rogue-gems option.  See the GemInstaller docs at http://geminstaller.rubyforge.org for more info."
+        raise GemInstaller::MissingFileError.new(error_message)
+      end
+      config.gems
+    end
+    
+    def process_gems(gems)
+      message = "GemInstaller is verifying gem installation: "
+      print_startup_message(gems, message)
+      @install_processor.process(gems)
+    end
+
+    def handle_args
+      return_code = @arg_parser.parse(@args)
+      arg_parser_output = @arg_parser.output
+      if (arg_parser_output && arg_parser_output != '')
+        if return_code == 0
+          @output_filter.geminstaller_output(:info,arg_parser_output)
+        else
+          @output_filter.geminstaller_output(:error,arg_parser_output)
+        end
+        return [true, return_code]
+      end
+      config_file_paths = @options[:config_paths]
+      @config_builder.config_file_paths = config_file_paths if config_file_paths
+      return [false, 0]
+    end
+
+    def print_startup_message(gems, message)
+      gems.each_with_index do |gem, index|
+        gem_info = "#{gem.name} #{gem.version}"
+        message += gem_info 
+        message += ", " if index + 1 < gems.size
+      end
+      @output_filter.geminstaller_output(:debug,message + "\n")
+    end
+  end
+end

data/lib/geminstaller/arg_parser.rb

@@ -0,0 +1,177 @@
+module GemInstaller
+  class ArgParser
+    attr_reader :output
+    attr_writer :options
+    
+    VALID_GEMINSTALLER_OUTPUT_FLAGS = [:none,:error,:install,:info,:commandecho,:debug,:all]
+    VALID_RUBYGEMS_OUTPUT_FLAGS = [:none,:stdout,:stderr,:all]
+    
+    def parse(args = [])
+      raise GemInstaller::GemInstallerError.new("Args must be passed as an array.") unless args.nil? or args.respond_to? :shift
+      args = ARGV if args.nil? || args == []
+      # check to see if args is an array of (nothing but) gems here...  if so, set args as [@options[:gems] and return
+
+      raise GemInstaller::GemInstallerError.new("Error: An array of options to be populated must be injected prior to calling GemInstaller::ArgParser.parse") unless @options
+      @options[:exceptions] = false
+      @options[:redirect_stderr_to_stdout] = false
+      @options[:silent] = false
+      @options[:sudo] = false
+      @options[:geminstaller_output] = [:error,:install,:info]
+      @options[:rubygems_output] = [:stderr]
+      @output = ""
+      @unparsed_geminstaller_output_flags = nil
+      @unparsed_rubygems_output_flags = nil
+      opts = OptionParser.new do |opts|
+        opts.banner = "Usage: geminstaller [options]"
+
+        opts.separator ""
+
+        config_msg =                         "Comma-delimited path(s) to GemInstaller config file(s)."
+        exceptions_msg =                     "Raise any exceptions, rather than just printing them and exiting\n" +
+        "                                     with a non-zero return code."
+        redirect_stderr_to_stdout_msg =      "Redirect all STDERR output to STDOUT.  Useful to get all output when\n" +
+        "                                     invoking GemInstaller via system()."
+        geminstaller_output_msg =            "Comma-delimited list of output types to show from GemInstaller.\n" +
+        "                                       Examples:\n" + 
+        "                                         --gall\n" +
+        "                                         --geminstaller-output=error,install,commandecho\n" +
+        "                                       Default: error,install,info\n" +
+        "                                       Valid types:\n" +
+        "                                         - none:        print only fatal errors\n" +
+        "                                         - error:       print error messages\n" +
+        "                                         - install:     print install messages\n" +
+        "                                         - info:        print informational messages\n" +
+        "                                         - commandecho: print rubygems commands as they are invoked\n" +
+        "                                         - debug:       print debug messages\n" +
+        "                                         - all:         print all messages"
+        help_msg =                           "Show this message."
+        print_outdated_gems_msg =            "Print a report of all locally installed gems which have a later\n" +
+        "                                     version installed than is specified in the geminstaller config file."
+        print_rogue_gems_msg =               "Print a report of all locally installed gems which are not specified\n" +
+        "                                     in the geminstaller config file."
+        bundler_export_msg =                 "Export a Bundler manifest Gemfile based on the geminstaller config"
+        rubygems_output_msg =                "Comma-delimited list of output types to show from internal:\n" +
+        "                                       RubyGems command invocation.\n" +
+        "                                       Examples:\n" + 
+        "                                         --rall\n" +
+        "                                         --rubygems-output=stderr\n" +
+        "                                       Default: stderr\n" +
+        "                                       Valid types:\n" +
+        "                                         - none:        print no output\n" +
+        "                                         - stdout:      print standard output stream\n" +
+        "                                         - stderr:      print standard error stream\n" +
+        "                                         - all:         print all output"
+        sudo_msg =                           "Perform all gem operations under sudo (as root).  Will only work on\n" +
+        "                                     correctly configured, supported systems.  See docs for more info."
+        silent_msg =                         "Suppress all output except fatal exceptions, and output from\n" +
+        "                                     rogue-gems and outdated-gems options."
+        version_msg =                        "Show GemInstaller version and exit."
+
+        opts.on("-cCONFIGPATHS", "--config=CONFIGPATHS", String, config_msg) do |config_paths|
+          @options[:config_paths] = config_paths
+        end
+
+        opts.on("-e", "--exceptions", exceptions_msg) do
+          @options[:exceptions] = true
+        end
+
+        opts.on("-d", "--redirect-stderr-to-stdout", redirect_stderr_to_stdout_msg) do
+          @options[:redirect_stderr_to_stdout] = true
+        end
+
+        opts.on("-gTYPES", "--geminstaller-output=TYPES", String, geminstaller_output_msg) do |geminstaller_output_flags|
+          @unparsed_geminstaller_output_flags = geminstaller_output_flags
+        end
+
+        opts.on("-h", "--help", help_msg) do
+          @output = opts.to_s
+        end
+
+        opts.on("-o", "--print-outdated-gems", print_outdated_gems_msg) do
+          @options[:print_outdated_gems] = true
+        end
+
+        opts.on("-p", "--print-rogue-gems", print_rogue_gems_msg) do
+          @options[:print_rogue_gems] = true
+        end
+
+        opts.on("-b", "--bundler-export", bundler_export_msg) do
+          @options[:bundler_export] = true
+        end
+
+        opts.on("-rTYPES", "--rubygems-output=TYPES", String, rubygems_output_msg) do |rubygems_output_flags|
+          @unparsed_rubygems_output_flags = rubygems_output_flags
+        end
+
+        opts.on("-s", "--sudo", sudo_msg) do
+          @options[:sudo] = true
+        end
+
+        opts.on("-t", "--silent", silent_msg) do
+          @options[:silent] = true
+        end
+
+        opts.on("-v", "--version", version_msg) do
+          @output = "#{GemInstaller::version}\n"
+        end
+      end
+
+      begin
+        opts.parse!(args)
+      rescue(OptionParser::InvalidOption)
+        @output << opts.to_s
+        return 1
+      end
+      
+      if @options[:silent] and (@unparsed_geminstaller_output_flags or @unparsed_rubygems_output_flags)
+        @output = "The rubygems-output or geminstaller-output option cannot be specified if the silent option is true."
+        return 1
+      end
+
+      if (@options[:sudo])
+        @output = "The sudo option is not (yet) supported when invoking GemInstaller programatically.  It is only supported when using the command line 'geminstaller' executable.  See the docs for more info."
+        return 1
+      end
+      
+      # TODO: remove duplication
+      if @unparsed_geminstaller_output_flags
+        flags = @unparsed_geminstaller_output_flags.split(',') 
+        flags.delete_if {|flag| flag == nil or flag == ''}
+        flags.map! {|flag| flag.downcase}
+        flags.sort!
+        flags.uniq!
+        flags.map! {|flag| flag.to_sym}
+        geminstaller_output_valid = true
+        flags.each do |flag|
+          unless VALID_GEMINSTALLER_OUTPUT_FLAGS.include?(flag)
+            @output = "Invalid geminstaller-output flag: #{flag}\n" 
+            geminstaller_output_valid = false
+          end
+        end
+        @options[:geminstaller_output] = flags if geminstaller_output_valid
+      end
+
+      if @unparsed_rubygems_output_flags
+        flags = @unparsed_rubygems_output_flags.split(',') 
+        flags.delete_if {|flag| flag == nil or flag == ''}
+        flags.map! {|flag| flag.downcase}
+        flags.sort!
+        flags.uniq!
+        flags.map! {|flag| flag.to_sym}
+        rubygems_output_valid = true
+        flags.each do |flag|
+          unless VALID_RUBYGEMS_OUTPUT_FLAGS.include?(flag)
+            @output = "Invalid rubygems-output flag: #{flag}\n" 
+            rubygems_output_valid = false
+          end
+        end
+        @options[:rubygems_output] = flags if rubygems_output_valid
+      end
+
+      # nil out @output if there was no output
+      @output = nil if @output == ""
+      return 0
+      
+    end
+  end
+end

data/lib/geminstaller/autogem.rb

@@ -0,0 +1,48 @@
+module GemInstaller
+  class Autogem
+    attr_writer :gem_command_manager, :gem_source_index_proxy
+    def autogem(gems)
+      @gem_source_index_proxy.refresh!
+      # REALLY refresh - refreshing the source_index directly isn't enough.
+      Gem.refresh
+      @completed_names = []
+      @completed_gems = []
+      gems.each do |gem|
+        process_gem(gem)
+      end
+      @completed_gems
+    end
+    
+    def process_gem(gem)
+      name = gem.name
+      version = gem.version
+      unless @completed_names.index(name) or gem.no_autogem
+        begin
+          invoke_require_gem_command(name, version)
+        rescue Gem::LoadError => load_error
+          load_error_message = load_error.message
+          load_error_message.strip!
+          error_message = "Error: GemInstaller attempted to load gem '#{name}', version '#{version}', but that version is not installed.  Use GemInstaller to install the gem.  Original Gem::LoadError was: '#{load_error_message}'"
+          raise GemInstaller::GemInstallerError.new(error_message)
+        end
+        @completed_names << name
+        @completed_gems << gem
+      end
+    end
+    
+    def invoke_require_gem_command(name, version)
+      if GemInstaller::RubyGemsVersionChecker.matches?('< 0.9')
+        require_gem(name, version)
+      else
+        begin
+          result = gem(name, version)
+        rescue Gem::Exception => e
+          exception_message = e.message
+          exception_message.strip!
+          error_message = "Error: GemInstaller failed to activate gem '#{name}', version '#{version}'.  This may be because GemInstaller processes gems in order (was alphabetical prior to 0.5.0), and an earlier gem in your geminstaller.yml config already activated another version.  Use the 'gem dependency [-R]' command to track this down, and reorder/edit your config as necessary.  Original Gem::Exception was: '#{exception_message}'"
+          raise GemInstaller::GemInstallerError.new(error_message)
+        end
+      end
+    end
+  end
+end

data/lib/geminstaller/backward_compatibility.rb

@@ -0,0 +1,17 @@
+# this file supports backward compatibility for prior versions of RubyGems
+
+# 0.9.3 reorganized commands to Gem::Commands:: module from Gem::
+if GemInstaller::RubyGemsVersionChecker.matches?('<0.9.3')
+  LIST_COMMAND_CLASS = Gem::ListCommand
+  QUERY_COMMAND_CLASS = Gem::QueryCommand
+else
+  LIST_COMMAND_CLASS = Gem::Commands::ListCommand
+  QUERY_COMMAND_CLASS = Gem::Commands::QueryCommand
+end
+
+# >1.3.5 changed Gem::Version::Requirement to Gem::Requirement
+if GemInstaller::RubyGemsVersionChecker.matches?('>1.3.5')
+  GemInstaller::REQUIREMENT_CLASS = Gem::Requirement
+else
+  GemInstaller::REQUIREMENT_CLASS = Gem::Version::Requirement
+end

data/lib/geminstaller/bundler_exporter.rb

@@ -0,0 +1,19 @@
+module GemInstaller
+  class BundlerExporter
+    attr_writer :output_proxy
+    
+    def output(config)
+      output_string = convert(config)
+      @output_proxy.sysout output_string
+      output_string
+    end
+
+    def convert(config)
+      manifest = ""
+      config.gems.each do |gem|
+        manifest += %Q{gem "#{gem.name}", "#{gem.version}"\n}
+      end
+      manifest
+    end
+  end
+end

data/lib/geminstaller/config.rb

@@ -0,0 +1,68 @@
+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
+      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,65 @@
+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, :yaml_loader, :config_file_paths, :output_filter
+    
+    def initialize(default_config_file_paths_array = ['geminstaller.yml','config/geminstaller.yml','ci/geminstaller.yml'])
+      @default_config_file_paths_array = default_config_file_paths_array
+    end
+    
+    def build_config
+      @config_file_paths_array = @config_file_paths ? @config_file_paths.split(",") : @default_config_file_paths_array
+      merged_defaults = {}
+      merged_gems_in_order = []
+      merged_gems_by_key = {}
+      file_found = false
+      @config_file_paths_array.reverse.each do |path| # reverse because last config files win
+        if File.exists?(path)
+          file_found = true
+        else
+          next
+        end
+        file_contents = @file_reader.read(path)
+        next unless file_contents
+        next if file_contents.empty?
+        expanded_path = File.expand_path(path)
+        @output_filter.geminstaller_output(:debug,"Found GemInstaller config file at: #{expanded_path}\n")
+        erb = ERB.new(%{#{file_contents}})
+        erb_result = nil
+        Dir.chdir(File.dirname(expanded_path)) do |yaml_file_dir|
+          erb_result = erb.result(include_config_binding)
+        end
+        yaml = @yaml_loader.load(erb_result)
+        merged_defaults.merge!(yaml['defaults']) unless yaml['defaults'].nil?
+        next unless yaml['gems']
+        yaml['gems'].each do |new_gem|
+          gem_key = [new_gem['name'],new_gem['version'],new_gem['platform']].join('-')
+          existing_gem = merged_gems_by_key[gem_key]
+          unless existing_gem
+            merged_gems_in_order << new_gem
+            merged_gems_by_key[gem_key] = new_gem
+          end
+        end
+      end
+      raise GemInstaller::MissingFileError.new("No config files found at any of these paths: #{@config_file_paths_array.join(', ')}") unless file_found
+      merged_yaml = {}
+      merged_yaml['defaults'] = merged_defaults
+      merged_yaml['gems'] = merged_gems_in_order
+      config = GemInstaller::Config.new(merged_yaml)
+      config
+    end
+  
+    def include_config_binding
+      def include_config(config_file)
+        Dir.chdir(File.dirname(config_file)) do |yaml_file_dir|
+          erb = File.open(config_file) { |io| ERB.new(io.read) }
+          erb.result(include_config_binding)
+        end
+      end
+      binding
+    end
+  end
+end

data/lib/geminstaller/enhanced_stream_ui.rb

@@ -0,0 +1,71 @@
+module GemInstaller
+  class EnhancedStreamUI < Gem::StreamUI
+    attr_writer :outs, :errs
+    attr_writer :gem_interaction_handler if GemInstaller::RubyGemsVersionChecker.matches?('<=0.9.4')
+    
+    def initialize()
+      # override default constructor to have no args
+    end
+    
+    def ask_yes_no(question, default=nil)
+      if GemInstaller::RubyGemsVersionChecker.matches?('<=0.9.4')
+        # Using defaults, we expect no interactive prompts RubyGems >= 0.9.5
+        begin
+          @gem_interaction_handler.handle_ask_yes_no(question)
+        rescue Exception => e
+          @outs.print(question)
+          @outs.flush
+          raise e
+        end
+      end
+      raise_unexpected_prompt_error(question)
+    end
+    
+    def ask(question)
+      raise_unexpected_prompt_error(question)
+    end
+    
+    def choose_from_list(question, list)
+      if GemInstaller::RubyGemsVersionChecker.matches?('<=0.9.4')
+        # Using defaults, we expect no interactive prompts RubyGems >= 0.9.5
+        @gem_interaction_handler.handle_choose_from_list(question, list)
+      else
+        list_string = list.join("\n")
+        question_and_list = "#{question}\n#{list_string}"
+        raise_unexpected_prompt_error(question_and_list)
+      end
+    end
+
+    if GemInstaller::RubyGemsVersionChecker.matches?('<=1.0.1')
+    # explicit exit in terminate_interation was removed after 1.0.1
+    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
+    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 < LIST_COMMAND_CLASS
+    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}$/
+      # 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 = QUERY_COMMAND_CLASS.instance_method(:execute)
+      bound_execute_method = unbound_execute_method.bind(self)
+      bound_execute_method.call
+    end
+  end
+end