rubygems-update 0.8.3

data/lib/rubygems/user_interaction.rb

@@ -0,0 +1,176 @@
+module Gem
+
+  ##
+  # Module that defines the default UserInteraction.  Any class
+  # including this module will have access to the +ui+ method that
+  # returns the default UI.
+  module DefaultUserInteraction
+
+    # Return the default UI.
+    def ui
+      DefaultUserInteraction.ui
+    end
+
+    # Set the default UI.  If the default UI is never explicity set, a
+    # simple console based UserInteraction will be used automatically.
+    def ui=(new_ui)
+      DefaultUserInteraction.ui = new_ui
+    end
+
+    def use_ui(new_ui, &block)
+      DefaultUserInteraction.use_ui(new_ui, &block)
+    end
+
+    # The default UI is a class variable of the singleton class for
+    # this module.
+    class << self
+      def ui
+        @ui ||= Gem::ConsoleUI.new
+      end
+      def ui=(new_ui)
+        @ui = new_ui
+      end
+      def use_ui(new_ui)
+        old_ui = @ui
+        @ui = new_ui
+        yield
+      ensure
+        @ui = old_ui
+      end
+    end
+  end
+
+  ##
+  # Make the default UI accessable without the "ui." prefix.  Classes
+  # including this module may use the interaction methods on the
+  # default UI directly.  Classes may also reference the +ui+ and
+  # <tt>ui=</tt> methods.
+  #
+  # Example:
+  #
+  #   class X
+  #     include Gem::UserInteraction
+  #
+  #     def get_answer
+  #       n = ask("What is the meaning of life?")
+  #     end
+  #   end
+  module UserInteraction
+    include DefaultUserInteraction
+    [
+      :choose_from_list, :ask, :ask_yes_no, :say, :alert, :alert_warning,
+      :alert_error, :terminate_interaction!, :terminate_interaction
+    ].each do |methname|
+      class_eval %{
+        def #{methname}(*args)
+          ui.#{methname}(*args)
+        end
+      }
+    end    
+  end
+
+  ##
+  # StreamUI implements a simple stream based user interface.
+  class StreamUI
+    def initialize(in_stream, out_stream, err_stream=STDERR)
+      @ins = in_stream
+      @outs = out_stream
+      @errs = err_stream
+    end
+    
+    # Choose from a list of options.  +question+ is a prompt displayed
+    # above the list.  +list+ is a list of option strings.  Returns
+    # the pair [option_name, option_index].
+    def choose_from_list(question, list)
+      @outs.puts question
+      list.each_with_index do |item, index|
+        @outs.puts " #{index+1}. #{item}"
+      end
+      @outs.print "> "
+      @outs.flush
+      result = @ins.gets.strip.to_i - 1
+      return list[result], result
+    end
+
+    # Ask a question.  Returns a true for yes, false for no.
+    def ask_yes_no(question, default=nil)
+      qstr = case default
+      when nil
+        'yn'
+      when true
+        'Yn'
+      else
+        'yN'
+      end
+      result = nil
+      while result.nil?
+        result = ask("#{question} [#{qstr}]")
+        result = case result
+        when /^[Yy].*/
+          true
+        when /^[Nn].*/
+          false
+        else
+          default
+        end
+      end
+      return result
+    end
+    
+    # Ask a question.  Returns an answer.  
+    def ask(question)
+      @outs.print(question + "  ")
+      @outs.flush
+      result = @ins.gets
+      result.chomp! if result
+      result
+    end
+    
+    # Display a statement.
+    def say(statement="")
+      @outs.puts statement
+    end
+    
+    # Display an informational alert.
+    def alert(statement, question=nil)
+      @outs.puts "INFO:  #{statement}"
+      return ask(question) if question 
+    end
+    
+    # Display a warning in a location expected to get error messages.
+    def alert_warning(statement, question=nil)
+      @errs.puts "WARNING:  #{statement}"
+      ask(question) if question 
+    end
+    
+    # Display an error message in a location expected to get error
+    # messages.
+    def alert_error(statement, question=nil)
+      @errs.puts "ERROR:  #{statement}"
+      ask(question) if question
+    end
+
+    # Terminate the application immediately without running any exit
+    # handlers.
+    def terminate_interaction!(status=-1)
+      exit!(status)
+    end
+    
+    # Terminate the appliation normally, running any exit handlers
+    # that might have been defined.
+    def terminate_interaction(status=0)
+      exit(status)
+    end
+  end
+
+
+  ##
+  # Subclass of StreamUI that instantiates the user interaction using
+  # standard in, out and error.
+  class ConsoleUI < StreamUI
+    def initialize
+      super(STDIN, STDOUT, STDERR)
+    end
+  end
+end
+

data/lib/rubygems/validator.rb

@@ -0,0 +1,148 @@
+module Gem
+
+  class VerificationError < Gem::Exception; end
+
+  ##
+  # Validator performs various gem file and gem database validation
+  class Validator
+    include UserInteraction
+
+    ##
+    # Given a gem file's contents, validates against its own MD5 checksum
+    # gem_data:: [String] Contents of the gem file
+    def verify_gem(gem_data)
+      if(gem_data.size == 0) then
+        raise VerificationError.new("Empty Gem file")
+      end
+      require 'md5'
+     unless(gem_data =~ /MD5SUM/m)
+       return # Don't worry about it...this sucks.  Need to fix MD5 stuff for
+		# new format
+		# FIXME
+      end
+      unless (MD5.md5(gem_data.gsub(/MD5SUM = "([a-z0-9]+)"/, "MD5SUM = \"" + ("F" * 32) + "\"")) == $1.to_s) 
+        raise VerificationError.new("Invalid checksum for Gem file")
+      end
+    end
+
+    ##
+    # Given the path to a gem file, validates against its own MD5 checksum
+    # 
+    # gem_path:: [String] Path to gem file
+    def verify_gem_file(gem_path)
+      begin
+        File.open(gem_path, 'rb') do |file|
+          gem_data = file.read
+          verify_gem(gem_data)
+        end
+      rescue Errno::ENOENT
+        raise Gem::VerificationError.new("Missing gem file #{gem_path}")
+      end
+    end
+
+    private
+    def find_files_for_gem(gem_directory)
+      installed_files = []
+      Find.find(gem_directory) {|file_name|
+        fn = file_name.slice((gem_directory.size)..(file_name.size-1)).sub(/^\//, "")
+        if(!(fn =~ /CVS/ || File.directory?(fn) || fn == "")) then 
+          installed_files << fn
+        end
+        
+      }
+      installed_files
+    end
+ 
+
+    public 
+    ErrorData = Struct.new(:path, :problem)
+
+    ##
+    # Checks the gem directory for the following potential 
+    # inconsistencies/problems:
+    # * Checksum gem itself
+    # * For each file in each gem, check consistency of installed versions
+    # * Check for files that aren't part of the gem but are in the gems directory
+    # * 1 cache - 1 spec - 1 directory.  
+    # 
+    # returns a hash of ErrorData objects, keyed on the problem gem's name.
+    def alien
+      require 'rubygems/installer'
+      require 'find'
+      require 'md5'
+      errors = {}
+      Gem::SourceIndex.from_installed_gems.each do |gem_name, gem_spec|
+        errors[gem_name] ||= []
+        gem_path = File.join(Gem.dir, "cache", gem_spec.full_name) + ".gem"
+        spec_path = File.join(Gem.dir, "specifications", gem_spec.full_name) + ".gemspec"
+        gem_directory = File.join(Gem.dir, "gems", gem_spec.full_name)
+        installed_files = find_files_for_gem(gem_directory)
+    
+        if(!File.exist?(spec_path)) then
+          errors[gem_name] << ErrorData.new(spec_path, "Spec file doesn't exist for installed gem")
+        end
+    
+        begin
+          require 'rubygems/format.rb'
+          verify_gem_file(gem_path)
+          File.open(gem_path) do |file|
+            format = Gem::Format.from_file_by_path(gem_path)
+            format.file_entries.each do |entry, data|
+              # Found this file.  Delete it from list
+	      installed_files.delete remove_leading_dot_dir(entry['path'])
+              File.open(File.join(gem_directory, entry['path']), 'rb') do |f|
+                unless MD5.md5(f.read).to_s == MD5.md5(data).to_s
+	          errors[gem_name] << ErrorData.new(entry['path'], "installed file doesn't match original from gem")
+                end
+              end
+            end
+          end
+        rescue VerificationError => e
+          errors[gem_name] << ErrorData.new(gem_path, e.message)
+        end
+        # Clean out directories that weren't explicitly included in the gemspec
+        # FIXME: This still allows arbitrary incorrect directories.
+        installed_files.delete_if {|potential_directory|	
+          File.directory?(File.join(gem_directory, potential_directory))
+        }
+        if(installed_files.size > 0) then
+          errors[gem_name] << ErrorData.new(gem_path, "Unmanaged files in gem: #{installed_files.inspect}")
+        end
+      end
+      errors
+    end
+   
+    ##
+    # Runs unit tests for a given gem specification
+    def unit_test(gem_spec)
+     start_dir = Dir.pwd
+     Dir.chdir(gem_spec.full_gem_path)
+      $: << File.join(Gem.dir, "gems", gem_spec.full_name)
+        # XXX: why do we need this gem_spec when we've already got 'spec'?
+      test_files = gem_spec.test_files
+      if test_files.empty?
+        say "There are no unit tests to run for #{gem_spec.name}-#{gem_spec.version}"
+        return
+      end
+      require_gem gem_spec.name, "= #{gem_spec.version.version}"
+      test_files.each do |f| require f end
+      require 'test/unit/ui/console/testrunner'
+      suite = Test::Unit::TestSuite.new("#{gem_spec.name}-#{gem_spec.version}")
+      ObjectSpace.each_object(Class) do |klass|
+        suite << klass.suite if (klass < Test::Unit::TestCase)
+      end
+      result = Test::Unit::UI::Console::TestRunner.run(suite, Test::Unit::UI::SILENT)
+      unless result.passed?
+        alert_error(result.to_s)
+        #unless ask_yes_no(result.to_s + "...keep Gem?", true) then
+          #Gem::Uninstaller.new(gem_spec.name, gem_spec.version.version).uninstall
+        #end
+      end
+      Dir.chdir(start_dir)
+    end
+
+    def remove_leading_dot_dir(path)
+      path.sub(/^\.\//, "")
+    end
+  end
+end

data/lib/rubygems/version.rb

@@ -0,0 +1,279 @@
+module Gem
+  
+  ##
+  # The Dependency class holds a Gem name and Version::Requirement
+  #
+  class Dependency
+    attr_accessor :name, :version_requirements
+    
+    ##
+    # Constructs the dependency
+    #
+    # name:: [String] name of the Gem
+    # version_requirements:: [String Array] version requirement (e.g. ["> 1.2"])
+    #
+    def initialize(name, version_requirements)
+      @name = name
+      @version_requirements = Version::Requirement.new(version_requirements)
+      @version_requirement = nil   # Avoid warnings.
+    end
+
+    undef version_requirements
+    def version_requirements
+      normalize if @version_requirement
+      @version_requirements
+    end
+
+    def requirement_list
+      version_requirements.as_list
+    end
+
+    alias requirements_list requirement_list
+
+    def normalize
+      ver = @version_requirement.instance_eval { @version }
+      @version_requirements = Version::Requirement.new([ver])
+      @version_requirement = nil
+    end
+
+    def to_s
+      "#{name} (#{version_requirements})"
+    end
+
+    def ==(other)
+      self.name = other.name and
+        self.version_requirements == other.version_requirements
+    end
+  end
+  
+  ##
+  # The Version class processes string versions into comparable values
+  #
+  class Version
+    include Comparable
+
+    attr_accessor :version
+
+    NUM_RE = /\s*(\d+(\.\d+)*)*\s*/
+
+    ##
+    # Checks if version string is valid format
+    #
+    # str:: [String] the version string
+    # return:: [Boolean] true if the string format is correct, otherwise false
+    #
+    def self.correct?(str)
+      /^#{NUM_RE}$/.match(str)
+    end
+
+    ##
+    # Factory method to create a Version object.  Input may be a Version or a
+    # String.  Intended to simplify client code.
+    #
+    #   ver1 = Version.create('1.3.17')   # -> (Version object)
+    #   ver2 = Version.create(ver1)       # -> (ver1)
+    #   ver3 = Version.create(nil)        # -> nil
+    #
+    def self.create(input)
+      if input.respond_to? :version
+        return input
+      elsif input.nil?
+        return nil
+      else
+        return Version.new(input)
+      end
+    end
+
+    ##
+    # Constructs a version from the supplied string
+    #
+    # version:: [String] The version string.  Format is digit.digit...
+    #
+    def initialize(version)
+      raise ArgumentError, 
+        "Malformed version number string #{version}" unless Version.correct?(version)
+      @version = version
+    end
+    
+    ##
+    # Returns the text representation of the version
+    #
+    # return:: [String] version as string
+    #
+    def to_s
+      @version
+    end
+    
+    ##
+    # Convert version to integer array
+    #
+    # return:: [Array] list of integers
+    #
+    def to_ints
+      @version.scan(/\d+/).map {|s| s.to_i}
+    end
+    
+    ##
+    # Compares two versions
+    #
+    # other:: [Version or .to_ints] other version to compare to
+    # return:: [Fixnum] -1, 0, 1
+    #
+    def <=>(other)
+      return 1 unless other
+      rnums, vnums = to_ints, other.to_ints
+      [rnums.size, vnums.size].max.times {|i|
+        rnums[i] ||= 0
+        vnums[i] ||= 0
+      }
+      
+      begin
+        r,v = rnums.shift, vnums.shift
+      end until (r != v || rnums.empty?)
+
+      return r <=> v
+    end
+
+    # Return a new version object where the next to the last revision
+    # number is one greater. (e.g.  5.3.1 => 5.4)
+    def bump
+      ints = to_ints
+      ints.pop if ints.size > 1
+      ints[-1] += 1
+      self.class.new(ints.join("."))
+    end
+    
+    ##
+    # Requirement version includes a prefaced comparator in addition
+    # to a version number.
+    #
+    # A Requirement object can actually contain multiple, er, requirements, as
+    # in (> 1.2, < 2.0).
+    #
+    class Requirement
+      include Comparable
+
+      OPS = {
+        "="  =>  lambda { |v, r| v == r },
+        "!=" =>  lambda { |v, r| v != r },
+        ">"  =>  lambda { |v, r| v > r },
+        "<"  =>  lambda { |v, r| v < r },
+        ">=" =>  lambda { |v, r| v >= r },
+        "<=" =>  lambda { |v, r| v <= r },
+        "~>" =>  lambda { |v, r| v >= r && v < r.bump }
+      }
+        
+      OP_RE = Regexp.new(OPS.keys.collect{|k| Regexp.quote(k)}.join("|"))
+      REQ_RE = /\s*(#{OP_RE})\s*/
+
+      ##
+      # Factory method to create a Version::Requirement object.  Input may be a
+      # Version, a String, or nil.  Intended to simplify client code.
+      #
+      # If the input is "weird", the default version requirement is returned.
+      #
+      def self.create(input)
+        if input.kind_of?(Requirement)
+          return input
+	elsif input.kind_of?(Array)
+	  return self.new(input)
+        elsif input.respond_to? :to_str
+          return self.new([input.to_str])
+        else
+          return self.default
+        end
+      end
+
+      ##
+      # A default "version requirement" can surely _only_ be '> 0'.
+      #
+      def self.default
+        self.new(['> 0.0.0'])
+      end
+
+      ##
+      # Constructs a version requirement instance
+      #
+      # str:: [String Array] the version requirement string (e.g. ["> 1.23"])
+      #
+      def initialize(reqs)
+        @requirements = reqs.collect do |rq|
+          op, version_string = parse(rq)
+          [op, Version.new(version_string)]
+        end
+        @version = nil   # Avoid warnings.
+      end
+      
+      ##
+      # Overrides to check for comparator
+      #
+      # str:: [String] the version requirement string
+      # return:: [Boolean] true if the string format is correct, otherwise false
+      #
+      def correct?(str)
+        /^#{REQ_RE}#{NUM_RE}$/.match(str)
+      end
+      
+      def to_s
+        as_list.join(", ")
+      end
+
+      def as_list
+        normalize
+        @requirements.collect { |req|
+                "#{req[0]} #{req[1]}"
+        }
+      end
+      
+      def normalize
+        return if @version.nil?
+        @requirements = [parse(@version)]
+        @nums = nil
+        @version = nil
+        @op = nil
+      end
+      
+      ##
+      # Is the requirement satifised by +version+.
+      #
+      # version:: [Gem::Version] the version to compare against
+      # return:: [Boolean] true if this requirement is satisfied by
+      #          the version, otherwise false 
+      #
+      def satisfied_by?(version)
+        normalize
+        @requirements.all? { |op, rv| satisfy?(op, version, rv) }
+      end
+  
+      private
+       
+      ##
+      # Is "version op required_version" satisfied?
+      #
+      def satisfy?(op, version, required_version)
+        OPS[op].call(version, required_version)
+      end
+
+      ##
+      # Parse the version requirement string. Return the operator and
+      # version strings.
+      #
+      def parse(str)
+        if md = /^\s*(#{OP_RE})\s*([0-9.]+)\s*$/.match(str)
+          [md[1], md[2]]
+        elsif md = /^\s*([0-9.]+)\s*$/.match(str)
+          ["=", md[1]]
+        elsif md = /^\s*(#{OP_RE})\s*$/.match(str)
+          [md[1], "0"]
+        else
+          fail ArgumentError, "Illformed requirement [#{str}]"
+        end
+      end
+
+      def <=>(other)
+        to_s <=> other.to_s
+      end
+
+    end
+  end
+end