Methods
#
L
M
N
P
R
S
T
Constants
TYPES = [ :development, :runtime, ]
 

Valid dependency types.

Attributes
[RW] name

Dependency name or regular expression.

[W] prerelease

Allows you to force this dependency to be a prerelease.

Class Public methods
new(name, *requirements)

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

# File lib/rubygems/dependency.rb, line 37
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 1 == requirements.length # 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
Instance Public methods
<=>(other)

Dependencies are ordered by name.

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

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

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

# File lib/rubygems/dependency.rb, line 97
def latest_version?
  @requirement.none?
end
match?(obj, version=nil)

DOC: this method needs either documented or :nodoc'd

# File lib/rubygems/dependency.rb, line 210
def match? obj, version=nil
  if !version
    name = obj.name
    version = obj.version
  else
    name = obj
  end

  return false unless self.name === name
  return true if requirement.none?

  requirement.satisfied_by? Gem::Version.new(version)
end
matches_spec?(spec)

DOC: this method needs either documented or :nodoc'd

# File lib/rubygems/dependency.rb, line 226
def matches_spec? spec
  return false unless name === spec.name
  return true  if requirement.none?

  requirement.satisfied_by?(spec.version)
end
matching_specs(platform_only = false)

DOC: this method needs either documented or :nodoc'd

# File lib/rubygems/dependency.rb, line 254
def matching_specs platform_only = false
  matches = Gem::Specification.stubs.find_all { |spec|
    self.name === spec.name and # TODO: == instead of ===
      requirement.satisfied_by? spec.version
  }.map(&:to_spec)

  if platform_only
    matches.reject! { |spec|
      not Gem::Platform.match spec.platform
    }
  end

  matches = matches.sort_by { |s| s.sort_obj } # HACK: shouldn't be needed
end
merge(other)

Merges the requirements of other into this dependency

# File lib/rubygems/dependency.rb, line 236
def merge other
  unless name == other.name then
    raise ArgumentError,
          "#{self} and #{other} have different names"
  end

  default = Gem::Requirement.default
  self_req  = self.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
prerelease?()

Does this dependency require a prerelease?

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

What does this dependency require?

# File lib/rubygems/dependency.rb, line 119
def requirement
  return @requirement if defined?(@requirement) and @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
requirements_list()

DOC: this method needs documentation or :nodoc''d

# File lib/rubygems/dependency.rb, line 149
def requirements_list
  requirement.as_list
end
specific?()

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

# File lib/rubygems/dependency.rb, line 272
def specific?
  @requirement.specific?
end
to_spec()

DOC: this method needs either documented or :nodoc'd

# File lib/rubygems/dependency.rb, line 308
def to_spec
  matches = self.to_specs

  matches.find { |spec| spec.activated? } or matches.last
end
to_specs()

DOC: this method needs either documented or :nodoc'd

# File lib/rubygems/dependency.rb, line 278
def to_specs
  matches = matching_specs true

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

  if matches.empty? then
    specs = Gem::Specification.find_all { |s|
              s.name == name
            }.map { |x| x.full_name }

    if specs.empty?
      total = Gem::Specification.to_a.size
      error = Gem::LoadError.new            "Could not find '#{name}' (#{requirement}) among #{total} total gem(s)"
    else
      error = Gem::LoadError.new            "Could not find '#{name}' (#{requirement}) - did find: [#{specs.join ','}]"
    end
    error.name        = self.name
    error.requirement = self.requirement
    raise error
  end

  # TODO: any other resolver validations should go here

  matches
end
type()

Dependency type.

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