Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.rubydoc.info/github/rubygems/rubygems/Gem/Dependency below:

Dependency – Documentation for rubygems/rubygems (master) – RubyDoc.info

Inherits:

Object

• Object
• Gem::Dependency

show all

Defined in:

lib/rubygems/dependency.rb

The Dependency class holds a Gem name and a Gem::Requirement.

TYPES =

Valid dependency types. – When this list is updated, be sure to change Gem::Specification::CURRENT_SPECIFICATION_VERSION as well.

REFACTOR: This type of constant, TYPES, indicates we might want two classes, used via inheritance or duck typing.

[
  :development,
  :runtime,
].freeze

• #name ⇒ Object

  Dependency name or regular expression.

• #prerelease ⇒ Object writeonly

  Allows you to force this dependency to be a prerelease.

• #<=>(other) ⇒ Object

  Dependencies are ordered by name.

• #==(other) ⇒ Object

  :nodoc:.

• #=~(other) ⇒ Object (also: #===)

  Uses this dependency as a pattern to compare to other.

• #encode_with(coder) ⇒ Object

  :nodoc:.

• #hash ⇒ Object

  A dependency’s hash is the XOR of the hashes of name, type, and requirement.

• #identity ⇒ Object
• #initialize(name, *requirements) ⇒ Dependency constructor

  Constructs a dependency with name and requirements.

• #inspect ⇒ Object

  :nodoc:.

• #latest_version? ⇒ Boolean

  Is this dependency simply asking for the latest version of a gem?.

• #match?(obj, version = nil, allow_prerelease = false) ⇒ Boolean

  :call-seq: dep.match? name => true or false dep.match? name, version => true or false dep.match? spec => true or false.

• #matches_spec?(spec) ⇒ Boolean

  Does this dependency match spec?.

• #matching_specs(platform_only = false) ⇒ Object
• #merge(other) ⇒ Object

  Merges the requirements of other into this dependency.

• #prerelease? ⇒ Boolean

  Does this dependency require a prerelease?.

• #pretty_print(q) ⇒ Object

  :nodoc:.

• #requirement ⇒ Object

  What does this dependency require?.

• #requirements_list ⇒ Object
• #runtime? ⇒ Boolean
• #specific? ⇒ Boolean

  True if the dependency will not always match the latest version.

• #to_s ⇒ Object

  :nodoc:.

• #to_spec ⇒ Object
• #to_specs ⇒ Object
• #type ⇒ Object

  Dependency type.

Constructs a dependency with name and requirements. The last argument can optionally be the dependency type, which defaults to :runtime.

36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

# File 'lib/rubygems/dependency.rb', line 36

def initialize(name, *requirements)
  case name
  when String then   when Regexp then
    msg = ["NOTE: Dependency.new w/ a regexp is deprecated.",
           "Dependency.new called from #{Gem.location_of_caller.join(":")}"]
    warn msg.join("\n") unless Gem::Deprecate.skip
  else
    raise ArgumentError,
          "dependency name must be a String, was #{name.inspect}"
  end

  type         = Symbol === requirements.last ? requirements.pop : :runtime
  requirements = requirements.first if requirements.length == 1 
  unless TYPES.include? type
    raise ArgumentError, "Valid types are #{TYPES.inspect}, " \
                         "not #{type.inspect}"
  end

  @name        = name
  @requirement = Gem::Requirement.create requirements
  @type        = type
  @prerelease  = false

    
  @version_requirements = @requirement
end

Dependency name or regular expression.

24
25
26

# File 'lib/rubygems/dependency.rb', line 24

def name
  @name
end

Allows you to force this dependency to be a prerelease.

29
30
31

# File 'lib/rubygems/dependency.rb', line 29

def prerelease=(value)
  @prerelease = value
end

Dependencies are ordered by name.

178
179
180

# File 'lib/rubygems/dependency.rb', line 178

def <=>(other)
  name <=> other.name
end

168
169
170
171
172
173

# File 'lib/rubygems/dependency.rb', line 168

def ==(other)   Gem::Dependency === other &&
    name        == other.name &&
    type        == other.type &&
    requirement == other.requirement
end

Uses this dependency as a pattern to compare to other. This dependency will match if the name matches the other’s name, and other has only an equal version requirement that satisfies this dependency.

188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204

# File 'lib/rubygems/dependency.rb', line 188

def =~(other)
  unless Gem::Dependency === other
    return unless other.respond_to?(:name) && other.respond_to?(:version)
    other = Gem::Dependency.new other.name, other.version
  end

  return false unless name === other.name

  reqs = other.requirement.requirements

  return false unless reqs.length == 1
  return false unless reqs.first.first == "="

  version = reqs.first.last

  requirement.satisfied_by? version
end

341
342
343
344
345
346
347

# File 'lib/rubygems/dependency.rb', line 341

def encode_with(coder)   coder.add "name", @name
  coder.add "requirement", @requirement
  coder.add "type", @type
  coder.add "prerelease", @prerelease
  coder.add "version_requirements", @version_requirements
end

A dependency’s hash is the XOR of the hashes of name, type, and requirement.

71
72
73

# File 'lib/rubygems/dependency.rb', line 71

def hash   name.hash ^ type.hash ^ requirement.hash
end

327
328
329
330
331
332
333
334
335
336
337
338
339

# File 'lib/rubygems/dependency.rb', line 327

def identity
  if prerelease?
    if specific?
      :complete
    else
      :abs_latest
    end
  elsif latest_version?
    :latest
  else
    :released
  end
end

75
76
77
78
79
80
81

# File 'lib/rubygems/dependency.rb', line 75

def inspect   if prerelease?
    format("<%s type=%p name=%p requirements=%p prerelease=ok>", self.class, type, name, requirement.to_s)
  else
    format("<%s type=%p name=%p requirements=%p>", self.class, type, name, requirement.to_s)
  end
end

Is this dependency simply asking for the latest version of a gem?

94
95
96

# File 'lib/rubygems/dependency.rb', line 94

def latest_version?
  @requirement.none?
end

:call-seq:

dep.match? name          => true or false
dep.match? name, version => true or false
dep.match? spec          => true or false

Does this dependency match the specification described by name and version or match spec?

NOTE: Unlike #matches_spec? this method does not return true when the version is a prerelease version unless this is a prerelease dependency.

220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238

# File 'lib/rubygems/dependency.rb', line 220

def match?(obj, version=nil, allow_prerelease=false)
  if !version
    name = obj.name
    version = obj.version
  else
    name = obj
  end

  return false unless self.name === name

  version = Gem::Version.new version

  return true if requirement.none? && !version.prerelease?
  return false if version.prerelease? &&
                  !allow_prerelease &&
                  !prerelease?

  requirement.satisfied_by? version
end

Does this dependency match spec?

NOTE: This is not a convenience method. Unlike #match? this method returns true when spec is a prerelease version even if this dependency is not a prerelease dependency.

247
248
249
250
251
252

# File 'lib/rubygems/dependency.rb', line 247

def matches_spec?(spec)
  return false unless name === spec.name
  return true  if requirement.none?

  requirement.satisfied_by?(spec.version)
end

273
274
275
276
277
278
279
280
281
282
283

# File 'lib/rubygems/dependency.rb', line 273

def matching_specs(platform_only = false)
  matches = Gem::Specification.find_all_by_name(name, requirement)

  if platform_only
    matches.reject! do |spec|
      spec.nil? || !Gem::Platform.match_spec?(spec)
    end
  end

  matches.reject(&:ignored?)
end

Merges the requirements of other into this dependency

257
258
259
260
261
262
263
264
265
266
267
268
269
270
271

# File 'lib/rubygems/dependency.rb', line 257

def merge(other)
  unless name == other.name
    raise ArgumentError,
          "#{self} and #{other} have different names"
  end

  default = Gem::Requirement.default
  self_req = requirement
  other_req = other.requirement

  return self.class.new name, self_req  if other_req == default
  return self.class.new name, other_req if self_req  == default

  self.class.new name, self_req.as_list.concat(other_req.as_list)
end

Does this dependency require a prerelease?

86
87
88

# File 'lib/rubygems/dependency.rb', line 86

def prerelease?
  @prerelease || requirement.prerelease?
end

98
99
100
101
102
103
104
105
106
107
108
109
110
111

# File 'lib/rubygems/dependency.rb', line 98

def pretty_print(q)   q.group 1, "Gem::Dependency.new(", ")" do
    q.pp name
    q.text ","
    q.breakable

    q.pp requirement

    q.text ","
    q.breakable

    q.pp type
  end
end

What does this dependency require?

116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

# File 'lib/rubygems/dependency.rb', line 116

def requirement
  return @requirement if defined?(@requirement) && @requirement

                            
  
  if defined?(@version_requirement) && @version_requirement
    version = @version_requirement.instance_variable_get :@version
    @version_requirement = nil
    @version_requirements = Gem::Requirement.new version
  end

  @requirement = @version_requirements if defined?(@version_requirements)
end

145
146
147

# File 'lib/rubygems/dependency.rb', line 145

def requirements_list
  requirement.as_list
end

164
165
166

# File 'lib/rubygems/dependency.rb', line 164

def runtime?
  @type == :runtime || !@type
end

True if the dependency will not always match the latest version.

288
289
290

# File 'lib/rubygems/dependency.rb', line 288

def specific?
  @requirement.specific?
end

149
150
151
152
153
154
155

# File 'lib/rubygems/dependency.rb', line 149

def to_s   if type != :runtime
    "#{name} (#{requirement}, #{type})"
  else
    "#{name} (#{requirement})"
  end
end

312
313
314
315
316
317
318
319
320
321
322
323
324
325

# File 'lib/rubygems/dependency.rb', line 312

def to_spec
  matches = to_specs.compact

  active = matches.find(&:activated?)
  return active if active

  unless prerelease?
        pre, matches = matches.partition {|spec| spec.version.prerelease? }
    matches = pre if matches.empty?
  end

  matches.first
end

160
161
162

# File 'lib/rubygems/dependency.rb', line 160

def type
  @type ||= :runtime
end

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4