jwhitmire-geminstaller 0.5.4

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_manager.rb

@@ -0,0 +1,71 @@
+module GemInstaller
+  class GemCommandManager
+    attr_writer :gem_spec_manager, :gem_runner_proxy
+    attr_writer :gem_interaction_handler if GemInstaller::RubyGemsVersionChecker.matches?('<=0.9.4')
+    
+    def list_remote_gem(gem, additional_options)
+      run_args = ["list",gem.name,"--remote","--details"]
+      run_args << "--all" if GemInstaller::RubyGemsVersionChecker.matches?('>1.0.1')
+      run_args += additional_options
+      @gem_runner_proxy.run(run_args)
+    end
+
+    def uninstall_gem(gem)
+      return if !@gem_spec_manager.is_gem_installed?(gem)
+      init_gem_interaction_handler(gem)
+      run_gem_command('uninstall', gem, gem.uninstall_options)
+    end
+
+    def install_gem(gem, force_reinstall = false)
+      return [] if @gem_spec_manager.is_gem_installed?(gem) && !force_reinstall
+      init_gem_interaction_handler(gem)
+      run_gem_command('install', gem, gem.install_options)
+    end
+    
+    def init_gem_interaction_handler(gem)
+      @gem_interaction_handler.dependent_gem = gem if GemInstaller::RubyGemsVersionChecker.matches?('<=0.9.4')
+    end
+    
+    def dependency(name, version, additional_options = [])
+      # rubygems has bug up to 0.9.4 where the pipe options uses 'puts', instead of 'say', so we can't capture it
+      # with enhanced_stream_ui.  Patched: http://rubyforge.org/tracker/index.php?func=detail&aid=9020&group_id=126&atid=577
+      # TODO: use pipe option on later versions which support it
+      
+      name_regexp = "^#{name}$"
+      name_regexp = "/#{name_regexp}/" if GemInstaller::RubyGemsVersionChecker.matches?('>=1.2.0')
+      run_args = ["dependency", name_regexp, "--version", version]
+      run_args += additional_options
+      output_lines = @gem_runner_proxy.run(run_args)
+      # drop the first line which just echoes the dependent gem
+      output_lines.shift
+      # drop the line containing 'requires' (rubygems < 0.9.0)
+      if output_lines[0] == '  Requires'
+        output_lines.shift
+      end
+      # drop all empty lines
+      output_lines.reject! { |line| line == "" }
+      # strip leading space
+      output_lines.each { |line| line.strip! }
+      # convert into gems
+      output_gems = output_lines.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, options)
+      run_args = [gem_command,gem.name,"--version", "#{gem.version}"]
+      if GemInstaller::RubyGemsVersionChecker.matches?('>=0.9.5')
+        run_args += ['--platform', "#{gem.platform}"] if gem.platform && !gem.platform.empty?
+      end
+      run_args += options
+      @gem_runner_proxy.run(run_args)
+    end
+  end
+end
+
+
+
+
+

data/lib/geminstaller/gem_interaction_handler.rb

@@ -0,0 +1,41 @@
+module GemInstaller
+  class GemInteractionHandler
+    attr_writer :dependent_gem, :noninteractive_chooser_class, :valid_platform_selector
+    DEPENDENCY_PROMPT = 'Install required dependency'
+    
+    def initialize
+      check_rubygems_version
+    end
+    
+    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
+  
+    def check_rubygems_version
+      if GemInstaller::RubyGemsVersionChecker.matches?('>=0.9.5')
+        # gem_interaction_handler is not used for RubyGems >= 0.9.5
+        raise RuntimeError.new("Internal GemInstaller Error: GemInteractionHandler should not be used for RubyGems >= 0.9.5")
+      end
+    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.join(' ')}'.  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}', Gem version = '#{gem.version}', install options = '#{gem.install_options.join(' ')}'.  Your remote gem server may be having problems.  You should try to list the remote gem yourself:  'gem list -r -v '#{gem.version}' #{common_args.join(' ')} #{gem.name}'.  If it exists on the server, try running geminstaller again and report your experience here: http://thewoolleyweb.lighthouseapp.com/projects/11580-geminstaller/tickets/5-sometimes-installing-fails.  Output of remote gem list command: \n#{remote_list}"
+        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,65 @@
+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.commands[:list] = @exact_match_list_command
+      
+      exit_status = nil
+      begin
+        # The call below is to work around RubyGem's behavior of caching (only) the last-used source when
+        # multiple gem commands for gems on different sources are issued via the API
+        Gem.sources.replace Gem.default_sources
+        gem_runner.run(args)
+      rescue SystemExit => system_exit
+        if GemInstaller::RubyGemsVersionChecker.matches?('>1.0.1')
+          raise system_exit unless system_exit.is_a? Gem::SystemExitException
+          exit_status = system_exit.message
+        else
+          raise system_exit
+        end
+      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
+      output_lines.collect do |line|
+        line.split("\n")
+      end.flatten
+    end
+    
+    def create_gem_runner
+      if GemInstaller::RubyGemsVersionChecker.matches?('< 0.9')
+        @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)
+      error_class = exit_error.class
+      error_message = exit_error.message
+      gem_command_output = listener.read!
+      if gem_command_output.join('') =~ /Errno::EACCES/
+        error_message = access_error_message + "\n" + error_message
+        error_class = GemInstaller::GemInstallerAccessError
+      end      
+      descriptive_exit_message = exit_error.descriptive_exit_message(error_message, 'gem', args, gem_command_output)
+      raise error_class.new(descriptive_exit_message)
+    end
+    
+    def access_error_message
+      "You don't have permission to install a gem.\nThis is not a problem with GemInstaller.\nYou probably want use the --sudo option or run GemInstaller as sudo,\nor install your gems to a non-root-owned location.\nSee http://geminstaller.rubyforge.org/documentation/documentation.html#dealing_with_sudo\n"
+    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
+
+
+
+
+

data/lib/geminstaller/gem_spec_manager.rb

@@ -0,0 +1,53 @@
+module GemInstaller
+  class GemSpecManager
+    attr_writer :source_index_search_adapter, :valid_platform_selector, :output_filter
+
+    def is_gem_installed?(gem)
+      return local_matching_gems(gem).size > 0
+    end
+    
+    def all_local_gems
+      all_local_specs = @source_index_search_adapter.all_local_specs
+      return [] unless all_local_specs
+      all_local_gems = all_local_specs.collect do |spec|
+        gem = GemInstaller::RubyGem.new(spec.name, :version  => spec.version.version)
+      end
+      return all_local_gems
+    end
+    
+    def local_matching_gems(gem, exact_platform_match = true)
+      found_gem_specs = @source_index_search_adapter.search(gem,gem.version)
+      return [] unless found_gem_specs
+
+      if GemInstaller::RubyGemsVersionChecker.matches?('<=0.9.4')
+        found_gem_specs = found_gem_specs.select do |gem_spec|
+          valid_platforms = @valid_platform_selector.select(gem.platform, exact_platform_match)
+          valid_platforms.include?(gem_spec.platform)
+        end
+      else
+        # TODO: this is a hack because source_index#search doesn't allow specification of platform
+        if exact_platform_match
+          found_gem_specs = found_gem_specs.select do |spec|
+            spec_platform_matches?(spec, gem.platform)
+          end
+        end
+      end
+      matching_gems = found_gem_specs.map do |gem_spec|
+        GemInstaller::RubyGem.new(gem_spec.name, {:version => gem_spec.version.version, :platform => gem_spec.platform })
+      end
+      return matching_gems
+    end
+
+    def spec_platform_matches?(spec, platform)
+      if GemInstaller::RubyGemsVersionChecker.matches?('>0.9.5')
+        return Gem::Platform.new(spec.platform) == Gem::Platform.new(platform)
+      end
+      return spec.platform == platform
+    end
+  end
+end
+
+
+
+
+

data/lib/geminstaller/geminstaller_access_error.rb

@@ -0,0 +1,4 @@
+module GemInstaller
+  class GemInstallerAccessError < GemInstaller::GemInstallerError
+  end
+end

data/lib/geminstaller/geminstaller_error.rb

@@ -0,0 +1,13 @@
+module GemInstaller
+  class GemInstallerError < RuntimeError
+    def descriptive_exit_message(message, command, args, gem_command_output)
+      args_string = args.join(" ")
+      descriptive_exit_message = "\n=========================================================\n"
+      descriptive_exit_message += "#{message}\n"
+      descriptive_exit_message += "Gem command was:\n  #{command} #{args_string}\n\n"
+      descriptive_exit_message += "Gem command output was:\n"
+      descriptive_exit_message += gem_command_output.join("\n")
+      descriptive_exit_message += "\n=========================================================\n\n"
+    end
+  end
+end

data/lib/geminstaller/hoe_extensions.rb

@@ -0,0 +1,9 @@
+class IndependentHoe < Hoe
+  def extra_deps
+    []
+  end
+
+  def extra_dev_deps
+    []
+  end
+end

data/lib/geminstaller/install_processor.rb

@@ -0,0 +1,71 @@
+module GemInstaller
+  class InstallProcessor
+    attr_writer :gem_list_checker, :gem_command_manager, :gem_spec_manager, :missing_dependency_finder, :options, :output_filter
+    def process(gems)
+      gems.each do |gem|
+        install_gem(gem)
+      end
+    end
+    
+    def install_gem(gem)
+      already_specified = false
+      if gem.check_for_upgrade
+        @gem_list_checker.verify_and_specify_remote_gem!(gem)
+        already_specified = true
+      end
+      gem_is_installed = @gem_spec_manager.is_gem_installed?(gem)
+      if gem_is_installed
+        @output_filter.geminstaller_output(:debug,"Gem #{gem.name}, version #{gem.version} is already installed.\n")
+      else
+        perform_install(gem, already_specified)
+        installation_performed = true
+      end
+      if gem.fix_dependencies
+        if GemInstaller::RubyGemsVersionChecker.matches?('>=0.9.5')
+          # RubyGems >=0.9.5 automatically handles missing dependencies, so just perform an install
+          unless installation_performed
+            @output_filter.geminstaller_output(:install,"The 'fix_dependencies' option was specified for #{gem.name}, version #{gem.version}, so it will be reinstalled to fix any missing dependencies.\n")
+            perform_install(gem, already_specified, true)
+          end
+        else
+          # RubyGems <=0.9.4 does not automatically handles missing dependencies, so GemInstaller must find them
+          # manually with missing_dependency_finder
+          fix_dependencies(gem)
+        end
+      end
+    end
+    
+    def perform_install(gem, already_specified, force_install = false)
+      @gem_list_checker.verify_and_specify_remote_gem!(gem) unless already_specified
+      @output_filter.geminstaller_output(:install,"Invoking gem install for #{gem.name}, version #{gem.version}.\n")
+      output_lines = @gem_command_manager.install_gem(gem, force_install)
+      print_dependency_install_messages(gem, output_lines) unless @options[:silent]
+    end
+    
+    def print_dependency_install_messages(gem, output_lines)
+      output_lines.each do |line|
+        line =~ /Successfully installed /
+        match = $'
+        next unless match
+        next if match =~ /#{gem.name}-/
+        @output_filter.geminstaller_output(:install,"Rubygems automatically installed dependency gem #{match}\n")
+      end
+    end
+
+    def fix_dependencies(gem)
+      missing_dependencies = @missing_dependency_finder.find(gem)
+      while (missing_dependencies.size > 0)
+        missing_dependencies.each do |missing_dependency|
+          @output_filter.geminstaller_output(:install,"Installing #{missing_dependency.name} (#{missing_dependency.version})\n")
+          # recursively call install_gem to install the missing dependency.  Since fix_dependencies
+          # should never be set on an auto-created missing dependency gem, there is no risk of an 
+          # endless loop or stack overflow.
+          install_gem(missing_dependency)
+        end
+        # continue to look for and install missing dependencies until none are found
+        missing_dependencies = @missing_dependency_finder.find(gem)
+      end
+    end
+    
+  end
+end

data/lib/geminstaller/missing_dependency_finder.rb

@@ -0,0 +1,46 @@
+module GemInstaller
+  class MissingDependencyFinder
+    attr_writer :gem_command_manager, :gem_spec_manager, :gem_arg_processor, :output_filter
+    def find(dependent_gem)
+      if GemInstaller::RubyGemsVersionChecker.matches?('>=0.9.5')
+        # missing_dependency_finder is not used for RubyGems >= 0.9.5
+        raise RuntimeError.new("Internal GemInstaller Error: MissingDependencyFinder should not be used for RubyGems >= 0.9.5")
+      end
+      
+      # NOTE: this doesn't resolve platforms, there's currently no way to know what
+      # platform should be selected for a dependency gem.  Best-effort handling
+      # of ambiguous platforms on dependency gems will be handled elsewhere
+      matching_dependent_gems = @gem_spec_manager.local_matching_gems(dependent_gem)
+      missing_dependencies = []
+      install_options = dependent_gem.install_options
+      add_include_dependency_option(install_options)
+      common_args = @gem_arg_processor.strip_non_common_gem_args(install_options)
+      matching_dependent_gems.each do |matching_dependent_gem|
+        message_already_printed = false
+        dependency_gems = @gem_command_manager.dependency(matching_dependent_gem.name, matching_dependent_gem.version.to_s, common_args)
+        dependency_gems.each do |dependency_gem|
+          dependency_gem.install_options = install_options
+          local_matching_dependency_gems = @gem_spec_manager.local_matching_gems(dependency_gem, false)
+          unless local_matching_dependency_gems.size > 0
+            unless message_already_printed
+              @output_filter.geminstaller_output(:info, "Missing dependencies found for #{matching_dependent_gem.name} (#{matching_dependent_gem.version}):\n")
+              message_already_printed = true
+            end
+            # TODO: print install options too?
+            @output_filter.geminstaller_output(:info, "  #{dependency_gem.name} (#{dependency_gem.version})\n")
+            missing_dependencies << dependency_gem
+          end        
+          # recurse to find any missing dependencies in the tree
+          sub_dependencies = find(dependency_gem)
+          missing_dependencies += sub_dependencies if sub_dependencies.size > 0 
+        end
+      end
+      return missing_dependencies
+    end
+    
+    def add_include_dependency_option(install_options)
+      return if install_options.index('-y') or install_options.index('--include-dependencies')
+      install_options << '--include-dependencies'
+    end
+  end
+end

data/lib/geminstaller/missing_file_error.rb

@@ -0,0 +1,4 @@
+module GemInstaller
+  class MissingFileError < GemInstaller::GemInstallerError
+  end
+end

data/lib/geminstaller/noninteractive_chooser.rb

@@ -0,0 +1,114 @@
+module GemInstaller
+  # Format for "install" prompt list: "#{spec.name} #{spec.version} (#{spec.platform})"
+  # Format for "uninstall" prompt list: "#{spec.name}-#{spec.version}" for ruby,  "#{spec.name}-#{spec.version}-#{spec.platform}" (gem.full_name) for binary
+  class NoninteractiveChooser
+    def initialize
+      check_rubygems_version
+      @question = nil
+    end
+    
+    def choose(question, list, dependent_gem_name, dependent_gem_version, valid_platforms)
+      @question = question
+      @list = list
+      @dependent_gem_name = dependent_gem_name
+      @dependent_gem_version = dependent_gem_version
+      @valid_platforms = valid_platforms
+      raise GemInstaller::GemInstallerError.new("Internal GemInstaller Error, unexpected choice prompt question: '#{question}'") unless
+        install_list_type? or uninstall_list_type?
+
+      raise GemInstaller::GemInstallerError.new("valid_platforms must be passed as an array.") unless 
+        valid_platforms.respond_to? :shift
+
+      raise GemInstaller::GemInstallerError.new("Internal GemInstaller Error, multiple platforms cannot be specified for an uninstall prompt") if
+        uninstall_list_type? and valid_platforms.size > 1
+
+      index = nil
+      valid_platforms.each do |platform|
+        index = find_matching_line(platform)
+        break if index 
+      end
+      
+      return @list[index], index if index
+      
+      # if we didn't find a match, raise a descriptive error
+      action = install_list_type? ? 'install' : 'uninstall'
+      name = @dependent_gem_name ? "#{@dependent_gem_name}" : "'any name'"
+      version = @dependent_gem_version ? "#{@dependent_gem_version}" : "'any version'"
+      platform = @valid_platforms ? " (#{@valid_platforms.join(' or ')})" : ''
+      error_message = "Error: Unable to select gem from list: \"#{name} #{version}#{platform}\".  Available gems are:\n"
+      list.each do |item|
+        # skip last 'cancel' list entry, it's not a real gem
+        next if item == list.last
+        error_message += "  " + item + "\n"
+      end
+      raise GemInstaller::GemInstallerError.new(error_message)
+    end
+    
+    def find_matching_line(platform)
+      required_list_item_regexp = required_name_and_version_regexp + required_platform_regexp(platform)
+      line_selector = /^#{required_list_item_regexp}$/
+      @list.each_with_index do |item, index|
+        if item =~ line_selector
+          return index
+        end
+      end
+      return nil
+    end
+    
+    def required_name_and_version_regexp
+      required_name_regexp = ".*?"
+      required_version_regexp = ".*?"
+      if uninstall_list_type? or dependent_gem?
+         # match the exact name and version if it's an uninstall prompt or a dependent gem
+        required_name_regexp = Regexp.escape(@dependent_gem_name) if @dependent_gem_name
+        required_version_regexp = Regexp.escape(@dependent_gem_version) if @dependent_gem_version
+      end
+      "#{required_name_regexp}[\s-]{0,1}#{required_version_regexp}"
+    end
+
+    def required_platform_regexp(platform_to_match)
+      return "" unless platform_to_match
+      required_platform = ""
+      escaped_platform_to_match = Regexp.escape(platform_to_match)
+      platform_regex = nil
+      if dependent_gem?
+        # do an exact match on the platform if this is the dependent gem
+        platform_regex = "#{escaped_platform_to_match}"
+      else
+        # do a wildcard match on the platform if it's not the dependent gem
+        platform_regex = ".*?#{escaped_platform_to_match}.*?"
+      end
+      # install list types always have the platform for each gem in parenthesis, even if it is ruby
+      if (install_list_type?)
+        required_platform = " \\(#{platform_regex}\\)"
+      end
+      # uninstall list types have the gem full_name, which is the platform for each gem appended after a dash, but only if it is not ruby
+      if (uninstall_list_type? && platform_to_match.to_s != GemInstaller::RubyGem.default_platform)
+        required_platform = "-.*?#{platform_regex}.*?"
+      end
+      required_platform
+    end
+    
+    def install_list_type?(question = @question)
+      question =~ /to install/
+    end
+  
+    def uninstall_list_type?(question = @question)
+      question =~ /to uninstall/
+    end
+    
+    def dependent_gem?(dependent_gem_name = @dependent_gem_name, list = @list)
+      # return true if it's an install prompt, and the list contains the gem for which the original install request
+      # was made (in other words, it's a dependent gem, not a dependency gem)
+      install_format_exact_name_match_regexp = /^#{dependent_gem_name}\s.*/
+      install_list_type? and list[0] =~ install_format_exact_name_match_regexp
+    end
+
+    def check_rubygems_version
+      if GemInstaller::RubyGemsVersionChecker.matches?('>=0.9.5')
+        # noninteractive_chooser is not used for RubyGems >= 0.9.5
+        raise RuntimeError.new("Internal GemInstaller Error: NoninteractiveChooser should not be used for RubyGems >= 0.9.5")
+      end
+    end
+  end
+end