rubygems-update 0.9.4 → 0.9.5

data/lib/rubygems/uninstaller.rb

@@ -0,0 +1,183 @@
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+require 'fileutils'
+require 'rubygems'
+require 'rubygems/dependency_list'
+require 'rubygems/doc_manager'
+require 'rubygems/user_interaction'
+
+##
+# An Uninstaller.
+#
+class Gem::Uninstaller
+
+  include Gem::UserInteraction
+
+  ##
+  # Constructs an Uninstaller instance
+  #
+  # gem:: [String] The Gem name to uninstall
+  #
+  def initialize(gem, options)
+    @gem = gem
+    @version = options[:version] || Gem::Requirement.default
+    @force_executables = options[:executables]
+    @force_all = options[:all]
+    @force_ignore = options[:ignore]
+  end
+
+  ##
+  # Performs the uninstall of the Gem.  This removes the spec, the
+  # Gem directory, and the cached .gem file,
+  #
+  def uninstall
+    list = Gem.source_index.search(/^#{@gem}$/, @version)
+
+    if list.empty? then
+      raise Gem::InstallError, "Unknown gem #{@gem}-#{@version}"
+    elsif list.size > 1 && @force_all
+      remove_all(list.dup) 
+      remove_executables(list.last)
+    elsif list.size > 1 
+      say 
+      gem_names = list.collect {|gem| gem.full_name} + ["All versions"]
+      gem_name, index =
+        choose_from_list("Select gem to uninstall:", gem_names)
+      if index == list.size
+        remove_all(list.dup) 
+        remove_executables(list.last)
+      elsif index >= 0 && index < list.size
+        to_remove = list[index]
+        remove(to_remove, list)
+        remove_executables(to_remove)
+      else
+        say "Error: must enter a number [1-#{list.size+1}]"
+      end
+    else
+      remove(list[0], list.dup)
+      remove_executables(list.last)
+    end
+  end
+  
+  ##
+  # Remove executables and batch files (windows only) for the gem as
+  # it is being installed
+  #
+  # gemspec::[Specification] the gem whose executables need to be removed.
+  #
+  def remove_executables(gemspec)
+    return if gemspec.nil?
+    if(gemspec.executables.size > 0)
+      raise Gem::FilePermissionError.new(Gem.bindir) unless
+        File.writable?(Gem.bindir)
+      list = Gem.source_index.search(gemspec.name).delete_if { |spec|
+        spec.version == gemspec.version
+      }
+      executables = gemspec.executables.clone
+      list.each do |spec|
+        spec.executables.each do |exe_name|
+          executables.delete(exe_name)
+        end
+      end
+      return if executables.size == 0
+      answer = @force_executables || ask_yes_no(
+        "Remove executables and scripts for\n" +
+        "'#{gemspec.executables.join(", ")}' in addition to the gem?",
+        true) # " # appease ruby-mode - don't ask
+      unless answer
+        say "Executables and scripts will remain installed."
+        return
+      else
+        gemspec.executables.each do |exe_name|
+          say "Removing #{exe_name}"
+          File.unlink File.join(Gem.bindir, exe_name) rescue nil
+          File.unlink File.join(Gem.bindir, exe_name + ".bat") rescue nil
+        end
+      end
+    end
+  end
+  
+  #
+  # list:: the list of all gems to remove
+  #
+  # Warning: this method modifies the +list+ parameter.  Once it has
+  # uninstalled a gem, it is removed from that list.
+  #
+  def remove_all(list)
+    list.dup.each { |gem| remove(gem, list) }
+  end
+
+  #
+  # spec:: the spec of the gem to be uninstalled
+  # list:: the list of all such gems
+  #
+  # Warning: this method modifies the +list+ parameter.  Once it has
+  # uninstalled a gem, it is removed from that list.
+  #
+  def remove(spec, list)
+    unless ok_to_remove? spec then
+      raise Gem::DependencyRemovalException,
+            "Uninstallation aborted due to dependent gem(s)"
+    end
+
+    raise Gem::FilePermissionError, spec.installation_path unless
+      File.writable?(spec.installation_path)
+
+    FileUtils.rm_rf spec.full_gem_path
+
+    original_platform_name = [
+      spec.name, spec.version, spec.original_platform].join '-'
+
+    spec_dir = File.join spec.installation_path, 'specifications'
+    gemspec = File.join spec_dir, "#{spec.full_name}.gemspec"
+
+    unless File.exist? gemspec then
+      gemspec = File.join spec_dir, "#{original_platform_name}.gemspec"
+    end
+
+    FileUtils.rm_rf gemspec
+
+    cache_dir = File.join spec.installation_path, 'cache'
+    gem = File.join cache_dir, "#{spec.full_name}.gem"
+
+    unless File.exist? gemspec then
+      gem = File.join cache_dir, "#{original_platform_name}.gem"
+    end
+
+    FileUtils.rm_rf gem
+
+    Gem::DocManager.new(spec).uninstall_doc
+
+    say "Successfully uninstalled #{spec.full_name}"
+
+    list.delete spec
+  end
+
+  def ok_to_remove?(spec)
+    return true if @force_ignore
+
+    srcindex = Gem::SourceIndex.from_installed_gems
+    deplist = Gem::DependencyList.from_source_index srcindex
+    deplist.ok_to_remove?(spec.full_name) || ask_if_ok(spec)
+  end
+
+  def ask_if_ok(spec)
+    msg = ['']
+    msg << 'You have requested to uninstall the gem:'
+    msg << "\t#{spec.full_name}"
+    spec.dependent_gems.each do |gem,dep,satlist|
+      msg <<
+        ("#{gem.name}-#{gem.version} depends on " +
+        "[#{dep.name} (#{dep.version_requirements})]")
+    end
+    msg << 'If you remove this gems, one or more dependencies will not be met.'
+    msg << 'Continue with Uninstall?'
+    return ask_yes_no(msg.join("\n"), true)
+  end
+
+end
+

data/lib/rubygems/user_interaction.rb

@@ -81,6 +81,9 @@ module Gem
   ####################################################################
   # StreamUI implements a simple stream based user interface.
   class StreamUI
+
+    attr_reader :ins, :outs, :errs
+
     def initialize(in_stream, out_stream, err_stream=STDERR)
       @ins = in_stream
       @outs = out_stream
@@ -97,12 +100,28 @@ module Gem
       end
       @outs.print "> "
       @outs.flush
-      result = @ins.gets.strip.to_i - 1
+
+      result = @ins.gets
+
+      return nil, nil unless result
+
+      result = result.strip.to_i - 1
       return list[result], result
     end
 
-    # Ask a question.  Returns a true for yes, false for no.
+    # Ask a question.  Returns a true for yes, false for no.  If not
+    # connected to a tty, raises an exception if default is nil,
+    # otherwise returns default.
     def ask_yes_no(question, default=nil)
+      if not @ins.tty? then
+        if default.nil? then
+          raise(
+              Gem::OperationNotSupportedError,
+              "Not connected to a tty and no default specified")
+        else
+          return default
+        end
+      end
       qstr = case default
       when nil
         'yn'
@@ -119,15 +138,19 @@ module Gem
           true
         when /^[Nn].*/
           false
-        else
+        when /^$/
           default
+        else
+          nil
         end
       end
       return result
     end
     
-    # Ask a question.  Returns an answer.  
+    # Ask a question.  Returns an answer if connected to a tty, nil
+    # otherwise.
     def ask(question)
+      return nil if not @ins.tty?
       @outs.print(question + "  ")
       @outs.flush
       result = @ins.gets
@@ -186,7 +209,7 @@ module Gem
     class SilentProgressReporter
       attr_reader :count
 
-      def initialize(out_stream, size, initial_message)
+      def initialize(out_stream, size, initial_message, terminal_message = nil)
       end
 
       def updated(message)
@@ -201,10 +224,13 @@ module Gem
 
       attr_reader :count
 
-      def initialize(out_stream, size, initial_message)
+      def initialize(out_stream, size, initial_message,
+                     terminal_message = "complete")
         @out = out_stream
         @total = size
         @count = 0
+        @terminal_message = terminal_message
+
         @out.puts initial_message
       end
 
@@ -215,7 +241,7 @@ module Gem
       end
 
       def done
-        @out.puts "\ncomplete"
+        @out.puts "\n#{@terminal_message}"
       end
     end
 
@@ -224,10 +250,13 @@ module Gem
 
       attr_reader :count
 
-      def initialize(out_stream, size, initial_message)
+      def initialize(out_stream, size, initial_message,
+                     terminal_message = 'complete')
         @out = out_stream
         @total = size
         @count = 0
+        @terminal_message = terminal_message
+
         @out.puts initial_message
       end
 
@@ -237,7 +266,7 @@ module Gem
       end
 
       def done
-        @out.puts "complete"
+        @out.puts @terminal_message
       end
     end
   end

data/lib/rubygems/validator.rb

@@ -4,9 +4,13 @@
 # See LICENSE.txt for permissions.
 #++
 
-module Gem
+require 'find'
+
+require 'rubygems/digest/md5'
+require 'rubygems/format'
+require 'rubygems/installer'
 
-  class VerificationError < Gem::Exception; end
+module Gem
 
   ##
   # Validator performs various gem file and gem database validation
@@ -17,17 +21,19 @@ module Gem
     # 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 'rubygems/digest/md5'
-      unless(gem_data =~ /MD5SUM/m)
+      raise VerificationError, 'empty gem file' if gem_data.size == 0
+
+      unless gem_data =~ /MD5SUM/ then
         return # Don't worry about it...this sucks.  Need to fix MD5 stuff for
                # new format
                # FIXME
       end
-      unless (Gem::MD5.hexdigest(gem_data.gsub(/MD5SUM = "([a-z0-9]+)"/, "MD5SUM = \"" + ("F" * 32) + "\"")) == $1.to_s) 
-        raise VerificationError.new("Invalid checksum for Gem file")
+
+      sum_data = gem_data.gsub(/MD5SUM = "([a-z0-9]+)"/,
+                               "MD5SUM = \"#{"F" * 32}\"")
+
+      unless Gem::MD5.hexdigest(sum_data) == $1.to_s then
+        raise VerificationError, 'invalid checksum for gem file'
       end
     end
 
@@ -36,14 +42,12 @@ module Gem
     # 
     # 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}")
+      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
 
     private
@@ -73,9 +77,6 @@ module Gem
     # 
     # returns a hash of ErrorData objects, keyed on the problem gem's name.
     def alien
-      require 'rubygems/installer'
-      require 'find'
-      require 'rubygems/digest/md5'
       errors = {}
       Gem::SourceIndex.from_installed_gems.each do |gem_name, gem_spec|
         errors[gem_name] ||= []
@@ -89,15 +90,18 @@ module Gem
         end
     
         begin
-          require 'rubygems/format.rb'
           verify_gem_file(gem_path)
-          File.open(gem_path) do |file|
+          File.open(gem_path, 'rb') 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'])
+
+              next unless data # HACK `gem check -a mkrf`
+
               File.open(File.join(gem_directory, entry['path']), 'rb') do |f|
-                unless Gem::MD5.hexdigest(f.read).to_s == Gem::MD5.hexdigest(data).to_s
+                unless Gem::MD5.hexdigest(f.read).to_s ==
+                       Gem::MD5.hexdigest(data).to_s then
                   errors[gem_name] << ErrorData.new(entry['path'], "installed file doesn't match original from gem")
                 end
               end
@@ -117,6 +121,32 @@ module Gem
       end
       errors
     end
+
+    class TestRunner
+      def initialize(suite, ui)
+        @suite = suite
+        @ui = ui
+      end
+
+      def self.run(suite, ui)
+        require 'test/unit/ui/testrunnermediator'
+        return new(suite, ui).start
+      end
+
+      def start
+        @mediator = Test::Unit::UI::TestRunnerMediator.new(@suite)
+        @mediator.add_listener(Test::Unit::TestResult::FAULT, &method(:add_fault))
+        return @mediator.run_suite
+      end
+
+      def add_fault(fault)
+        if Gem.configuration.verbose then
+          @ui.say fault.long_display
+        end
+      end
+    end
+
+    autoload :TestRunner, 'test/unit/ui/testrunnerutilities'
    
     ##
     # Runs unit tests for a given gem specification
@@ -132,12 +162,11 @@ module Gem
       end
       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)
+      result = TestRunner.run(suite, ui())
       unless result.passed?
         alert_error(result.to_s)
         #unless ask_yes_no(result.to_s + "...keep Gem?", true) then

data/lib/rubygems/version.rb

@@ -4,318 +4,155 @@
 # See LICENSE.txt for permissions.
 #++
 
-module Gem
-  
-  ####################################################################
-  # The Dependency class holds a Gem name and Version::Requirement
-  #
-  class Dependency
-    attr_accessor :name
+require 'rubygems'
 
-    attr_writer :version_requirements
+##
+# The Version class processes string versions into comparable values
+class Gem::Version
 
-    def <=>(other)
-      [@name] <=> [other.name]
-    end
-    
-    ##
-    # 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
+  include Comparable
+
+  attr_reader :ints
 
-    def version_requirements
-      normalize if defined? @version_requirement and @version_requirement
-      @version_requirements
+  attr_reader :version
+
+  ##
+  # 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?(version)
+    case version
+    when Integer, /\A\s*(\d+(\.\d+)*)*\s*\z/ then true
+    else false
     end
+  end
 
-    def requirement_list
-      version_requirements.as_list
+  ##
+  # 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 then
+      input
+    elsif input.nil? then
+      nil
+    else
+      new input
     end
+  end
 
-    alias requirements_list requirement_list
+  ##
+  # 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
+      self.class.correct?(version)
 
-    def normalize
-      ver = @version_requirement.instance_eval { @version }
-      @version_requirements = Version::Requirement.new([ver])
-      @version_requirement = nil
-    end
+    self.version = version
+  end
 
-    def to_s
-      "#{name} (#{version_requirements})"
-    end
+  def inspect # :nodoc:
+    "#<#{self.class} #{@version.inspect}>"
+  end
 
-    def ==(other)
-      other.kind_of?(self.class) &&
-        self.name == other.name &&
-        self.version_requirements == other.version_requirements
-    end
+  # Dump only the raw version string, not the complete object
+  def marshal_dump
+    [@version]
+  end
 
-    def hash
-      name.hash + version_requirements.hash
-    end
-    
+  # Load custom marshal format
+  def marshal_load(array)
+    self.version = array[0]
   end
-  
-  ####################################################################
-  # The Version class processes string versions into comparable values
-  #
-  class Version
-    include Comparable
 
-    # The originating definition of Requirement is left nested in
-    # Version for compatibility.  The full definition is given in
-    # Gem::Requirement.
-    class Requirement
-    end
-    
-    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
+  # Strip ignored trailing zeros.
+  def normalize
+    @ints = @version.to_s.scan(/\d+/).map { |s| s.to_i }
 
-    ##
-    # 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
+    return if @ints.length == 1
 
-    ##
-    # 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?)
+    @ints.pop while @ints.last == 0
 
-      return r <=> v
-    end
+    @ints = [0] if @ints.empty?
+  end
 
-    def hash
-      to_ints.inject { |hash_code, n| hash_code + n }
-    end
+  ##
+  # Returns the text representation of the version
+  #
+  # return:: [String] version as string
+  #
+  def to_s
+    @version
+  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
-    
+  ##
+  # Convert version to integer array
+  #
+  # return:: [Array] list of integers
+  #
+  def to_ints
+    normalize unless @ints
+    @ints
+  end
+
+  def to_yaml_properties
+    ['@version']
+  end
+
+  def version=(version)
+    @version = version.to_s.strip
+    normalize
   end
 
-  # Class Requirement's original definition is nested in Version.
-  # Although an probably inappropriate place, current gems specs
-  # reference the nested class name explicitly.  To remain compatible
-  # with old software loading gemspecs, we leave the original
-  # definition in Version, but define an alias Gem::Requirement for
-  # use everywhere else.
-  Requirement = ::Gem::Version::Requirement
+  def yaml_initialize(tag, values)
+    self.version = values['version']
+  end
 
-  ##################################################################
-  # Requirement version includes a prefaced comparator in addition
-  # to a version number.
+  ##
+  # Compares two versions
   #
-  # A Requirement object can actually contain multiple, er,
-  # requirements, as in (> 1.2, < 2.0).
+  # other:: [Version or .ints] other version to compare to
+  # return:: [Fixnum] -1, 0, 1
   #
-  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
-    #
-    # NOTE: Commented out because I don't think it is used.
-    #       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 not defined? @version or @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
+  def <=>(other)
+    return 1 unless other
+    @ints <=> other.ints
+  end
 
-    def hash
-      to_s.hash
-    end
-    public :hash
+  def hash
+    to_ints.inject { |hash_code, n| hash_code + n }
+  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 = @ints.dup
+    ints.pop if ints.size > 1
+    ints[-1] += 1
+    self.class.new(ints.join("."))
   end
-  
+
+  #:stopdoc:
+
+  require 'rubygems/requirement'
+
+  # Gem::Requirement's original definition is nested in Version.
+  # Although an inappropriate place, current gems specs reference the nested
+  # class name explicitly.  To remain compatible with old software loading
+  # gemspecs, we leave a copy of original definition in Version, but define an
+  # alias Gem::Requirement for use everywhere else.
+
+  Requirement = ::Gem::Requirement
+
+  # :startdoc:
+
 end
+