Class Gem::Requirement
In: lib/rubygems/requirement.rb
Parent: Object

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).

Methods

<=>   as_list   create   default   marshal_dump   marshal_load   new   normalize   parse   satisfied_by?   satisfy?  

Included Modules

Comparable

Constants

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 = /#{OPS.keys.map{ |k| Regexp.quote k }.join '|'}/o

Attributes

requirements  [R] 

Public Class methods

create(input)

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.

[Source]

    # File lib/rubygems/requirement.rb, line 39
39:   def self.create(input)
40:     case input
41:     when Gem::Requirement then
42:       input
43:     when Gem::Version, Array then
44:       new input
45:     else
46:       if input.respond_to? :to_str then
47:         self.new [input.to_str]
48:       else
49:         self.default
50:       end
51:     end
52:   end
default()

A default "version requirement" can surely only be ’>= 0’.

[Source]

    # File lib/rubygems/requirement.rb, line 60
60:   def self.default
61:     self.new ['>= 0']
62:   end
new(requirements)

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.

[Source]

    # File lib/rubygems/requirement.rb, line 68
68:   def initialize(requirements)
69:     @requirements = case requirements
70:                     when Array then
71:                       requirements.map do |requirement|
72:                         parse(requirement)
73:                       end
74:                     else
75:                       [parse(requirements)]
76:                     end
77:     @version = nil   # Avoid warnings.
78:   end

Public Instance methods

<=>(other)

[Source]

     # File lib/rubygems/requirement.rb, line 150
150:   def <=>(other)
151:     to_s <=> other.to_s
152:   end
as_list()

[Source]

     # File lib/rubygems/requirement.rb, line 95
 95:   def as_list
 96:     normalize
 97:     @requirements.collect { |req|
 98:       "#{req[0]} #{req[1]}"
 99:     }
100:   end
marshal_dump()

Marshal raw requirements, rather than the full object

[Source]

    # File lib/rubygems/requirement.rb, line 81
81:   def marshal_dump
82:     [@requirements]
83:   end
marshal_load(array)

Load custom marshal format

[Source]

    # File lib/rubygems/requirement.rb, line 86
86:   def marshal_load(array)
87:     @requirements = array[0]
88:     @version = nil
89:   end
normalize()

[Source]

     # File lib/rubygems/requirement.rb, line 102
102:   def normalize
103:     return if not defined? @version or @version.nil?
104:     @requirements = [parse(@version)]
105:     @nums = nil
106:     @version = nil
107:     @op = nil
108:   end
parse(obj)

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.

[Source]

     # File lib/rubygems/requirement.rb, line 135
135:   def parse(obj)
136:     case obj
137:     when /^\s*(#{OP_RE})\s*([0-9.]+)\s*$/o then
138:       [$1, Gem::Version.new($2)]
139:     when /^\s*([0-9.]+)\s*$/ then
140:       ['=', Gem::Version.new($1)]
141:     when /^\s*(#{OP_RE})\s*$/o then
142:       [$1, Gem::Version.new('0')]
143:     when Gem::Version then
144:       ['=', obj]
145:     else
146:       fail ArgumentError, "Illformed requirement [#{obj.inspect}]"
147:     end
148:   end
satisfied_by?(version)

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

[Source]

     # File lib/rubygems/requirement.rb, line 117
117:   def satisfied_by?(version)
118:     normalize
119:     @requirements.all? { |op, rv| satisfy?(op, version, rv) }
120:   end
satisfy?(op, version, required_version)

Is "version op required_version" satisfied?

[Source]

     # File lib/rubygems/requirement.rb, line 125
125:   def satisfy?(op, version, required_version)
126:     OPS[op].call(version, required_version)
127:   end

[Validate]