britt-geminstaller 0.5.2 → 0.5.2.1

data/bin/geminstaller

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+dir = File.dirname(__FILE__)
+
+begin
+  require 'geminstaller'
+rescue LoadError
+  require 'rubygems'
+  begin
+    # try load path
+    require 'geminstaller'
+  rescue LoadError
+    begin
+      # try lib subdir (TODO: is this necessary?)
+      require 'lib/geminstaller'
+    rescue LoadError
+      # try lib dir as peer of current dir
+      require "#{dir}/../lib/geminstaller"
+    end
+  end
+end
+
+geminstaller_executable ||= File.join(File.expand_path(dir), 'geminstaller')
+
+if ARGV.include?('--geminstaller-exec-path')
+  print "geminstaller_exec_path=#{geminstaller_executable}"
+  exit 0
+end
+
+exit GemInstaller.install(ARGV, geminstaller_executable)

data/cruise_config.rb

@@ -0,0 +1,14 @@
+# Project-specific configuration for CruiseControl.rb
+require 'fileutils'
+
+Project.configure do |project|
+  project.email_notifier.emails = ['thewoolleyman@gmail.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,42 @@
+---
+# GemInstaller config file which specifies the actual build, test, and doc dependencies for GemInstaller itself.
+defaults:
+  install_options: --include-dependencies
+  fix_dependencies: true
+gems:
+- name: diff-lcs
+  version: '>= 1.1.2'
+- name: hoe
+  version: '= 1.8.3'
+- 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.1.12'
+- 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.rb

@@ -0,0 +1,103 @@
+dir = File.dirname(__FILE__)
+require File.expand_path("#{dir}/geminstaller/requires.rb")
+
+module GemInstaller
+  def self.install(args = [], geminstaller_executable = nil)
+    args_copy = args.dup
+    args_copy = args_copy.split(' ') unless args.respond_to? :join
+    # recursively call script with sudo, if --sudo option is specified
+    if platform_supports_sudo? and (args_copy.include?("-s") or args_copy.include?("--sudo"))
+      result = reinvoke_with_sudo(args_copy, geminstaller_executable)
+      if result != 0 and (args_copy.include?("-e") or args_copy.include?("--exceptions"))
+        message = "Error: GemInstaller failed while being invoked with --sudo option.  See prior output for error, and use '--geminstaller-output=all --rubygems-output=all' options to get more details."
+        raise GemInstaller::GemInstallerError.new(message)
+      end
+      return result
+    else
+      app = create_application(args_copy)
+      app.install
+    end
+  end
+  
+  def self.run(args = [], geminstaller_executable = nil)
+    # run is now an alias for install
+    install(args, geminstaller_executable)
+  end
+  
+  def self.autogem(args = [])
+    args_copy = args.dup
+    args_copy = args_copy.split(' ') unless args.respond_to? :join
+    # TODO: should explicitly remove all args not applicable to autogem (anything but config, silent, and geminstaller_output)
+    args_without_sudo = strip_sudo(args_copy)
+    app = create_application(args_without_sudo)
+    app.autogem
+  end
+
+  def self.version
+    "0.5.2"
+  end
+
+  def self.create_application(args = [], registry = nil)
+    registry ||= create_registry
+    app = registry.app
+    app.args = args
+    app
+  end
+  
+  def self.create_registry
+    GemInstaller::Registry.new
+  end
+  
+  def self.parse_config_paths(config_paths)
+    return nil unless config_paths
+    return config_paths unless config_paths.respond_to? :join
+    return config_paths.join(',')
+  end
+  
+  def self.platform_supports_sudo?
+    return true unless RUBY_PLATFORM =~ /mswin/
+    return false
+  end
+  
+  def self.reinvoke_with_sudo(args, geminstaller_executable)
+    # Sudo support is a hack, better to use other alternatives.
+    geminstaller_executable ||= find_geminstaller_executable
+    args_without_sudo = strip_sudo(args)
+    args_without_sudo << '--redirect-stderr-to-stdout'
+    cmd = "sudo ruby #{geminstaller_executable} #{args_without_sudo.join(' ')}"
+    # TODO: this eats any output.  There currently is no standard way to get a return code AND stdin AND stdout.
+    # Some non-standard packages like Open4 handle this, but not synchronously.  The Simplest Thing That Could
+    # Possibly Work is to have a command line option which will cause all stderr output to be redirected to stdout.
+    result = system(cmd)
+    return 1 unless result
+    return $?.exitstatus
+  end
+  
+  def self.strip_sudo(args)
+    return args.reject {|arg| arg == "-s" || arg == "--sudo"}
+  end
+  
+  def self.find_geminstaller_executable
+    possible_locations = [
+      'ruby -S geminstaller',
+      'ruby /usr/local/bin/geminstaller',
+      'ruby /usr/bin/geminstaller',
+      'ruby ./bin/geminstaller'
+      ]
+    path_key = 'geminstaller_exec_path='
+    possible_locations.each do |possible_location|
+      cmd = "#{possible_location} --geminstaller-exec-path"
+
+      $stderr_backup = $stderr.dup
+      $stderr.reopen("/dev/null", "w")
+      io = IO.popen(cmd)
+      $stderr.reopen($stderr_backup)
+      STDERR.reopen($stderr_backup) # Why are these not the same?  It is an old question: http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/47596
+      output = io.read
+      next unless output =~ /#{path_key}/
+      path = output.sub(path_key,'')
+      return path
+    end
+    raise GemInstaller::GemInstallerError.new("Error: Unable to locate the geminstaller executable.  Specify it explicitly, or don't use the sudo option.")
+  end
+end

data/lib/geminstaller/application.rb

@@ -0,0 +1,105 @@
+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
+    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
+        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
+        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,166 @@
+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_rogue_gems_msg =               "Print a report of all locally installed gems which are not specified\n" +
+        "                                     in the geminstaller config file."
+        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 option."
+        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("-p", "--print-rogue-gems", print_rogue_gems_msg) do
+          @options[:print_rogue_gems] = 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