123456789_123456789_123456789_123456789_123456789_

Class: Gem::Dependency

Relationships & Source Files
Inherits: Object
Defined in: lib/rubygems/dependency.rb

Overview

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

Constant Summary

Class Method Summary

Instance Attribute Summary

Instance Method Summary

Constructor Details

.new(name, *requirements) ⇒ Dependency

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

[ GitHub ] 

  


# 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


  







Instance Attribute Details



  

    #latest_version?  ⇒ Boolean  (readonly)
  



  

    

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


  





  


  [ GitHub ]


  

  


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



def latest_version?
  @requirement.none?
end


  








  

    #name   (rw)
  



  

    

Dependency name or regular expression.


  



  [ GitHub ]


  

  


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



attr_accessor :name


  








  

    #prerelease=(value)   (rw)
  



  

    

Allows you to force this dependency to be a prerelease.


  



  [ GitHub ]


  

  


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



attr_writer :prerelease


  








  

    #prerelease?  ⇒ Boolean  (rw)
  



  

    

Does this dependency require a prerelease?


  





  


  [ GitHub ]


  

  


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



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


  








  

    #runtime?  ⇒ Boolean  (readonly)
  

  [ GitHub ]


  

  


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



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


  








  

    #specific?  ⇒ Boolean  (readonly)
  



  

    

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


  





  


  [ GitHub ]


  

  


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



def specific?
  @requirement.specific?
end


  







Instance Method Details



  

    #<=>(other)  
  



  

    

Dependencies are ordered by name.


  



  [ GitHub ]


  

  


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



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


  








  

    #==(other)  
  

  

    This method is for internal use only.
  

  [ GitHub ]


  

  


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



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


  








  

    #===(other)  
  



  

    

Alias for #=~.


  



  [ GitHub ]


  

  


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



alias_method :===, :=~


  








  

    #=~(other)  
    Also known as: #===
  



  

    

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.


  



  [ GitHub ]


  

  


# 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


  








  

    #encode_with(coder)  
  

  

    This method is for internal use only.
  

  [ GitHub ]


  

  


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



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


  








  

    #hash  
  

  

    This method is for internal use only.
  



  

    

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


  



  [ GitHub ]


  

  


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



def hash # :nodoc:
  name.hash ^ type.hash ^ requirement.hash
end


  








  

    #identity  
  

  [ GitHub ]


  

  


# 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


  








  

    #inspect  
  

  

    This method is for internal use only.
  

  [ GitHub ]


  

  


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



def inspect # :nodoc:
  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


  








  

    

      #match?(name)  ⇒ Boolean 
      #match?(name, version)  ⇒ Boolean 
      #match?(spec)  ⇒ Boolean 
    

  



  

    

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.


  





  


  [ GitHub ]


  

  


# 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


  








  

    #matches_spec?(spec)  ⇒ Boolean 
  



  

    

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.


  





  


  [ GitHub ]


  

  


# 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


  








  

    #matching_specs(platform_only = false)  
  

  [ GitHub ]


  

  


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



  

    

Merges the requirements of other into this dependency


  



  [ GitHub ]


  

  


# 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


  








  

    #pretty_print(q)  
  

  

    This method is for internal use only.
  

  [ GitHub ]


  

  


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



def pretty_print(q) # :nodoc:
  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


  








  

    #requirement  
  



  

    

What does this dependency require?


  



  [ GitHub ]


  

  


# 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


  








  

    #requirements_list  
  

  [ GitHub ]


  

  


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



def requirements_list
  requirement.as_list
end


  








  

    #to_s  
  

  

    This method is for internal use only.
  

  [ GitHub ]


  

  


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



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


  








  

    #to_spec  
  

  [ GitHub ]


  

  


# 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  
  

  [ GitHub ]


  

  


# 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  
  



  

    

Dependency type.


  



  [ GitHub ]


  

  


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



def type
  @type ||= :runtime
end