class Gem::Dependency

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

Constants

TYPES

Valid dependency types.

Attributes

Dependency name or regular expression.

Allows you to force this dependency to be a prerelease.

Public Class Methods

Source
# File lib/rubygems/dependency.rb, line 36
def initialize(name, *requirements)
  case name
  when String then # ok
  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 # unpack

  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

  # This is for Marshal backwards compatibility. See the comments in
  # +requirement+ for the dirty details.

  @version_requirements = @requirement
end

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

Public Instance Methods

Source
# File lib/rubygems/dependency.rb, line 178
def <=>(other)
  name <=> other.name
end

Dependencies are ordered by name.

Alias for: =~
Source
# 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

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.

Also aliased as: ===
Source
# 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
Source
# File lib/rubygems/dependency.rb, line 94
def latest_version?
  @requirement.none?
end

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

Source
# 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 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.

Source
# 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

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.

Source
# 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
Source
# 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

Merges the requirements of other into this dependency

Source
# File lib/rubygems/dependency.rb, line 86
def prerelease?
  @prerelease || requirement.prerelease?
end

Does this dependency require a prerelease?

Source
# File lib/rubygems/dependency.rb, line 116
def requirement
  return @requirement if defined?(@requirement) && @requirement

  # @version_requirements and @version_requirement are legacy ivar
  # names, and supported here because older gems need to keep
  # working and Dependency doesn't implement marshal_dump and
  # marshal_load. In a happier world, this would be an
  # attr_accessor. The horrifying instance_variable_get you see
  # below is also the legacy of some old restructurings.
  #
  # Note also that because of backwards compatibility (loading new
  # gems in an old RubyGems installation), we can't add explicit
  # marshaling to this class until we want to make a big
  # break. Maybe 2.0.
  #
  # Children, define explicit marshal and unmarshal behavior for
  # public classes. Marshal formats are part of your public API.

  # REFACTOR: See above

  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

What does this dependency require?

Source
# File lib/rubygems/dependency.rb, line 145
def requirements_list
  requirement.as_list
end
Source
# File lib/rubygems/dependency.rb, line 164
def runtime?
  @type == :runtime || !@type
end
Source
# File lib/rubygems/dependency.rb, line 288
def specific?
  @requirement.specific?
end

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

Source
# File lib/rubygems/dependency.rb, line 312
def to_spec
  matches = to_specs.compact

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

  unless prerelease?
    # Consider prereleases only as a fallback
    pre, matches = matches.partition {|spec| spec.version.prerelease? }
    matches = pre if matches.empty?
  end

  matches.first
end
Source
# File lib/rubygems/dependency.rb, line 292
def to_specs
  matches = matching_specs true

  # TODO: check Gem.activated_spec[self.name] in case matches falls outside

  if matches.empty?
    specs = Gem::Specification.stubs_for name

    if specs.empty?
      raise Gem::MissingSpecError.new name, requirement
    else
      raise Gem::MissingSpecVersionError.new name, requirement, specs
    end
  end

  # TODO: any other resolver validations should go here

  matches
end
Source
# File lib/rubygems/dependency.rb, line 160
def type
  @type ||= :runtime
end

Dependency type.