britt-geminstaller 0.5.2 → 0.5.2.1

data/lib/geminstaller/autogem.rb

@@ -0,0 +1,46 @@
+module GemInstaller
+  class Autogem
+    attr_writer :gem_command_manager, :gem_source_index_proxy
+    def autogem(gems)
+      @gem_source_index_proxy.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 actiate gem '#{name}', version '#{version}'.  This is probably 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,10 @@
+# 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

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'])
+      @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}$/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 = QUERY_COMMAND_CLASS.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_manager.rb

@@ -0,0 +1,74 @@
+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)
+      p output_lines
+      # 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, 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