* lib/rubygems: update to 1.3.6.

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@26728 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

1 files changed, 78 insertions, 100 deletions

diff --git a/lib/rubygems/requirement.rb b/lib/rubygems/requirement.rb
index 471d84eb61..d9b510a76d 100644
--- a/lib/rubygems/requirement.rb
+++ b/lib/rubygems/requirement.rb
@@ -1,41 +1,33 @@
-#--
-# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
-# All rights reserved.
-# See LICENSE.txt for permissions.
-#++
+require "rubygems/version"
 
 ##
-# 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).
+# A Requirement is a set of one or more version restrictions. It supports a
+# few (<tt>=, !=, >, <, >=, <=, ~></tt>) different restriction operators.
 
 class Gem::Requirement
-
   include Comparable
 
-  attr_reader :requirements
-
-  OPS = {
+  OPS = { #:nodoc:
     "="  =>  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 },
     "<=" =>  lambda { |v, r| v <= r },
     "~>" =>  lambda { |v, r| v = v.release; v >= r && v < r.bump }
   }
 
-  OP_RE = OPS.keys.map{ |k| Regexp.quote k }.join '|'
+  quoted  = OPS.keys.map { |k| Regexp.quote k }.join "|"
+  PATTERN = /\A\s*(#{quoted})?\s*(#{Gem::Version::VERSION_PATTERN})\s*\z/
 
   ##
-  # Factory method to create a Gem::Requirement object.  Input may be a
-  # Version, a String, or nil.  Intended to simplify client code.
+  # Factory method to create a Gem::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.
+  # If the input is "weird", the default version requirement is
+  # returned.
 
-  def self.create(input)
+  def self.create input
     case input
     when Gem::Requirement then
       input
@@ -43,9 +35,9 @@ class Gem::Requirement
       new input
     else
       if input.respond_to? :to_str then
-        self.new [input.to_str]
+        new [input.to_str]
       else
-        self.default
+        default
       end
     end
   end
@@ -58,113 +50,99 @@ class Gem::Requirement
   # "A default "version requirement" can surely _only_ be '> 0'."
 
   def self.default
-    self.new ['>= 0']
+    new '>= 0'
   end
 
   ##
-  # Constructs a Requirement from +requirements+ which can be a String, a
-  # Gem::Version, or an Array of those.  See #parse for details on the
-  # formatting of requirement strings.
-
-  def initialize(requirements)
-    @requirements = case requirements
-                    when Array then
-                      requirements.map do |requirement|
-                        parse(requirement)
-                      end
-                    else
-                      [parse(requirements)]
-                    end
-    @version = nil   # Avoid warnings.
-  end
+  # Parse +obj+, returning an <tt>[op, version]</tt> pair. +obj+ can
+  # be a String or a Gem::Version.
+  #
+  # If +obj+ is a String, it can be either a full requirement
+  # specification, like <tt>">= 1.2"</tt>, or a simple version number,
+  # like <tt>"1.2"</tt>.
+  #
+  #     parse("> 1.0")                 # => [">", "1.0"]
+  #     parse("1.0")                   # => ["=", "1.0"]
+  #     parse(Gem::Version.new("1.0")) # => ["=,  "1.0"]
 
-  ##
-  # Marshal raw requirements, rather than the full object
+  def self.parse obj
+    return ["=", obj] if Gem::Version === obj
 
-  def marshal_dump # :nodoc:
-    [@requirements]
+    unless PATTERN =~ obj.to_s
+      raise ArgumentError, "Illformed requirement [#{obj.inspect}]"
+    end
+
+    [$1 || "=", Gem::Version.new($2)]
   end
 
   ##
-  # Load custom marshal format
+  # An array of requirement pairs. The first element of the pair is
+  # the op, and the second is the Gem::Version.
 
-  def marshal_load(array) # :nodoc:
-    @requirements = array[0]
-    @version = nil
+  attr_reader :requirements #:nodoc:
+
+  ##
+  # Constructs a requirement from +requirements+. Requirements can be
+  # Strings, Gem::Versions, or Arrays of those. +nil+ and duplicate
+  # requirements are ignored. An empty set of +requirements+ is the
+  # same as <tt>">= 0"</tt>.
+
+  def initialize *requirements
+    requirements = requirements.flatten
+    requirements.compact!
+    requirements.uniq!
+
+    requirements << ">= 0" if requirements.empty?
+    @requirements = requirements.map! { |r| self.class.parse r }
   end
 
-  def to_s # :nodoc:
-    as_list.join(", ")
+  def as_list # :nodoc:
+    requirements.map { |op, version| "#{op} #{version}" }
   end
 
-  def pretty_print(q) # :nodoc:
-    q.group 1, 'Gem::Requirement.new(', ')' do
-      q.pp as_list
-    end
+  def hash # :nodoc:
+    requirements.hash
   end
 
-  def as_list
-    normalize
-    @requirements.map do |op, version| "#{op} #{version}" end
+  def marshal_dump # :nodoc:
+    [@requirements]
   end
 
-  def normalize
-    return if not defined? @version or @version.nil?
-    @requirements = [parse(@version)]
-    @nums = nil
-    @version = nil
-    @op = nil
+  def marshal_load array # :nodoc:
+    @requirements = array[0]
   end
 
-  ##
-  # True if this requirement satisfied by the Gem::Version +version+.
+  def prerelease?
+    requirements.any? { |r| r.last.prerelease? }
+  end
 
-  def satisfied_by?(version)
-    normalize
-    @requirements.all? { |op, rv| satisfy?(op, version, rv) }
+  def pretty_print q # :nodoc:
+    q.group 1, 'Gem::Requirement.new(', ')' do
+      q.pp as_list
+    end
   end
 
   ##
-  # Is "+version+ +op+ +required_version+" satisfied?
+  # True if +version+ satisfies this Requirement.
 
-  def satisfy?(op, version, required_version)
-    OPS[op].call(version, required_version)
-  end
-
-  def prerelease?
-    # TODO: why is @requirements a nested array?
-    @requirements.any?{ |r| r[1].prerelease? }
+  def satisfied_by? version
+    requirements.all? { |op, rv| OPS[op].call version, rv }
   end
 
-  ##
-  # Parse the version requirement obj returning the operator and version.
-  #
-  # The requirement can be a String or a Gem::Version.  A String can be an
-  # operator (<, <=, =, >=, >, !=, ~>), a version number, or both, operator
-  # first.
-
-  def parse(obj)
-    case obj
-    when /^\s*(#{OP_RE})\s*(#{Gem::Version::VERSION_PATTERN})\s*$/o then
-      [$1, Gem::Version.new($2)]
-    when /^\s*(#{Gem::Version::VERSION_PATTERN})\s*$/o then
-      ['=', Gem::Version.new($1)]
-    when /^\s*(#{OP_RE})\s*$/o then
-      [$1, Gem::Version.new('0')]
-    when Gem::Version then
-      ['=', obj]
-    else
-      fail ArgumentError, "Illformed requirement [#{obj.inspect}]"
-    end
+  def to_s # :nodoc:
+    as_list.join ", "
   end
 
-  def <=>(other) # :nodoc:
+  def <=> other # :nodoc:
     to_s <=> other.to_s
   end
+end
 
-  def hash # :nodoc:
-    to_s.hash
-  end
+# :stopdoc:
+# Gem::Version::Requirement is used in a lot of old YAML specs. It's aliased
+# here for backwards compatibility. I'd like to remove this, maybe in RubyGems
+# 2.0.
 
-end
+::Gem::Version::Requirement = ::Gem::Requirement
+# :startdoc: