# class Gem::Dependency

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

### Constants

TYPES

  Valid dependency types.

### Attributes

name [RW]

`Dependency` name or regular expression.

prerelease [W]

Allows you to force this dependency to be a prerelease.

### Public Class Methods

new (name, *requirements)
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

<=> (other)
Source

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

Dependencies are ordered by name.

=== (other)
Alias for: =~
=~ (other)
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: ===
identity ()
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

latest_version? ()
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?

match? name → true or false
match? name, version → true or false
match? spec → true or false
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.

matches_spec? (spec)
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.

matching_specs (platform_only = false)
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

merge (other)
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

prerelease? ()
Source

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

Does this dependency require a prerelease?

requirement ()
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?

requirements_list ()
Source

    # File lib/rubygems/dependency.rb, line 145
    def requirements_list
      requirement.as_list
    end

runtime? ()
Source

    # File lib/rubygems/dependency.rb, line 164
    def runtime?
      @type == :runtime || !@type
    end

specific? ()
Source

    # File lib/rubygems/dependency.rb, line 288
    def specific?
      @requirement.specific?
    end

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

to_spec ()
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

to_specs ()
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

type ()
Source

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

`Dependency` type.