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   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 40
40:   def self.create(input)
41:     case input
42:     when Gem::Requirement then
43:       input
44:     when Gem::Version, Array then
45:       new input
46:     else
47:       if input.respond_to? :to_str then
48:         self.new [input.to_str]
49:       else
50:         self.default
51:       end
52:     end
53:   end
default()

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

[Source]

    # File lib/rubygems/requirement.rb, line 62
62:   def self.default
63:     self.new ['>= 0']
64:   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 71
71:   def initialize(requirements)
72:     @requirements = case requirements
73:                     when Array then
74:                       requirements.map do |requirement|
75:                         parse(requirement)
76:                       end
77:                     else
78:                       [parse(requirements)]
79:                     end
80:     @version = nil   # Avoid warnings.
81:   end

Public Instance methods

as_list()

[Source]

     # File lib/rubygems/requirement.rb, line 102
102:   def as_list
103:     normalize
104:     @requirements.collect { |req|
105:       "#{req[0]} #{req[1]}"
106:     }
107:   end
normalize()

[Source]

     # File lib/rubygems/requirement.rb, line 109
109:   def normalize
110:     return if not defined? @version or @version.nil?
111:     @requirements = [parse(@version)]
112:     @nums = nil
113:     @version = nil
114:     @op = nil
115:   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 139
139:   def parse(obj)
140:     case obj
141:     when /^\s*(#{OP_RE})\s*([0-9.]+)\s*$/o then
142:       [$1, Gem::Version.new($2)]
143:     when /^\s*([0-9.]+)\s*$/ then
144:       ['=', Gem::Version.new($1)]
145:     when /^\s*(#{OP_RE})\s*$/o then
146:       [$1, Gem::Version.new('0')]
147:     when Gem::Version then
148:       ['=', obj]
149:     else
150:       fail ArgumentError, "Illformed requirement [#{obj.inspect}]"
151:     end
152:   end
satisfied_by?(version)

True if this requirement satisfied by the Gem::Version version.

[Source]

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

Is "version op required_version" satisfied?

[Source]

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

[Validate]