Class: Gem::Dependency (Ruby 2.7.3)
Description: Class : Gem::Dependency - Ruby 2.7.3

### Home Classes Methods

### In Files

- rubygems/dependency.rb
- rubygems/specification_policy.rb

### Parent

Object

### Methods

- ::new
- #<=>
- #===
- #=~
- #identity
- #latest_version?
- #match?
- #matches_spec?
- #matching_specs
- #merge
- #prerelease?
- #requirement
- #requirements_list
- #runtime?
- #specific?
- #to_spec
- #to_specs
- #type

### Class/Module Index

Quicksearch

- Gem::AvailableSet
- Gem::BasicSpecification
- Gem::BundlerVersionFinder
- Gem::Command
- Gem::CommandLineError
- Gem::CommandManager
- Gem::Commands
- Gem::Commands::BuildCommand
- Gem::Commands::CertCommand
- Gem::Commands::CheckCommand
- Gem::Commands::CleanupCommand
- Gem::Commands::ContentsCommand
- Gem::Commands::DependencyCommand
- Gem::Commands::EnvironmentCommand
- Gem::Commands::FetchCommand
- Gem::Commands::GenerateIndexCommand
- Gem::Commands::HelpCommand
- Gem::Commands::InfoCommand
- Gem::Commands::InstallCommand
- Gem::Commands::ListCommand
- Gem::Commands::LockCommand
- Gem::Commands::MirrorCommand
- Gem::Commands::OpenCommand
- Gem::Commands::OutdatedCommand
- Gem::Commands::OwnerCommand
- Gem::Commands::PristineCommand
- Gem::Commands::PushCommand
- Gem::Commands::QueryCommand
- Gem::Commands::RdocCommand
- Gem::Commands::SearchCommand
- Gem::Commands::ServerCommand
- Gem::Commands::SetupCommand
- Gem::Commands::SetupCommand::MakeDirs
- Gem::Commands::SigninCommand
- Gem::Commands::SignoutCommand
- Gem::Commands::SourcesCommand
- Gem::Commands::SpecificationCommand
- Gem::Commands::StaleCommand
- Gem::Commands::UninstallCommand
- Gem::Commands::UnpackCommand
- Gem::Commands::UpdateCommand
- Gem::Commands::WhichCommand
- Gem::Commands::YankCommand
- Gem::ConfigFile
- Gem::ConflictError
- Gem::ConsoleUI
- Gem::DefaultUserInteraction
- Gem::Dependency
- Gem::DependencyError
- Gem::DependencyInstaller
- Gem::DependencyList
- Gem::DependencyRemovalException
- Gem::DependencyResolutionError
- Gem::Deprecate
- Gem::Doctor
- Gem::DocumentError
- Gem::EndOfYAMLException
- Gem::ErrorReason
- Gem::Exception
- Gem::Ext
- Gem::Ext::BuildError
- Gem::Ext::Builder
- Gem::Ext::CmakeBuilder
- Gem::Ext::ConfigureBuilder
- Gem::Ext::ExtConfBuilder
- Gem::Ext::RakeBuilder
- Gem::FakeFetcher
- Gem::FilePermissionError
- Gem::FormatException
- Gem::GemNotFoundException
- Gem::GemNotInHomeException
- Gem::GemRunner
- Gem::GemcutterUtilities
- Gem::ImpossibleDependenciesError
- Gem::Indexer
- Gem::InstallError
- Gem::InstallUpdateOptions
- Gem::Installer
- Gem::Installer::FakePackage
- Gem::InstallerTestCase
- Gem::InvalidSpecificationException
- Gem::Licenses
- Gem::List
- Gem::LoadError
- Gem::LocalRemoteOptions
- Gem::MissingSpecError
- Gem::MissingSpecVersionError
- Gem::MockGemUi
- Gem::MockGemUi::InputEOFError
- Gem::MockGemUi::SystemExitException
- Gem::MockGemUi::TTY
- Gem::MockGemUi::TermError
- Gem::NameTuple
- Gem::NoAliasYAMLTree
- Gem::OperationNotSupportedError
- Gem::Package::DigestIO
- Gem::Package::Error
- Gem::Package::FormatError
- Gem::Package::NonSeekableIO
- Gem::Package::Old
- Gem::Package::PathError
- Gem::Package::TarHeader
- Gem::Package::TarInvalidError
- Gem::Package::TarReader
- Gem::Package::TarReader::Entry
- Gem::Package::TarReader::UnexpectedEOF
- Gem::Package::TarTestCase
- Gem::Package::TarWriter
- Gem::Package::TarWriter::BoundedStream
- Gem::Package::TarWriter::FileOverflow
- Gem::Package::TarWriter::RestrictedStream
- Gem::Package::TooLongFileName
- Gem::PackageTask
- Gem::PathSupport
- Gem::Platform
- Gem::PlatformMismatch
- Gem::RemoteError
- Gem::RemoteFetcher
- Gem::RemoteFetcher::FetchError
- Gem::RemoteFetcher::UnknownHostError
- Gem::RemoteInstallationCancelled
- Gem::RemoteInstallationSkipped
- Gem::RemoteSourceException
- Gem::RequestSet
- Gem::RequestSet::GemDependencyAPI
- Gem::RequestSet::Lockfile
- Gem::RequestSet::Lockfile::ParseError
- Gem::RequestSet::Lockfile::Parser
- Gem::RequestSet::Lockfile::Tokenizer
- Gem::Requirement
- Gem::Requirement::BadRequirementError
- Gem::Resolver
- Gem::Resolver::APISet
- Gem::Resolver::APISpecification
- Gem::Resolver::ActivationRequest
- Gem::Resolver::BestSet
- Gem::Resolver::ComposedSet
- Gem::Resolver::Conflict
- Gem::Resolver::CurrentSet
- Gem::Resolver::DependencyRequest
- Gem::Resolver::GitSet
- Gem::Resolver::GitSpecification
- Gem::Resolver::IndexSet
- Gem::Resolver::IndexSpecification
- Gem::Resolver::InstalledSpecification
- Gem::Resolver::InstallerSet
- Gem::Resolver::LocalSpecification
- Gem::Resolver::LockSet
- Gem::Resolver::LockSpecification
- Gem::Resolver::Molinillo
- Gem::Resolver::Molinillo::CircularDependencyError
- Gem::Resolver::Molinillo::Delegates
- Gem::Resolver::Molinillo::Delegates::ResolutionState
- Gem::Resolver::Molinillo::Delegates::SpecificationProvider
- Gem::Resolver::Molinillo::DependencyGraph
- Gem::Resolver::Molinillo::DependencyGraph::Action
- Gem::Resolver::Molinillo::DependencyGraph::AddEdgeNoCircular
- Gem::Resolver::Molinillo::DependencyGraph::DeleteEdge
- Gem::Resolver::Molinillo::DependencyGraph::DetachVertexNamed
- Gem::Resolver::Molinillo::DependencyGraph::Log
- Gem::Resolver::Molinillo::DependencyGraph::Tag
- Gem::Resolver::Molinillo::DependencyGraph::Vertex
- Gem::Resolver::Molinillo::DependencyState
- Gem::Resolver::Molinillo::NoSuchDependencyError
- Gem::Resolver::Molinillo::PossibilityState
- Gem::Resolver::Molinillo::ResolutionState
- Gem::Resolver::Molinillo::Resolver
- Gem::Resolver::Molinillo::Resolver::Resolution
- Gem::Resolver::Molinillo::ResolverError
- Gem::Resolver::Molinillo::SpecificationProvider
- Gem::Resolver::Molinillo::UI
- Gem::Resolver::Molinillo::VersionConflict
- Gem::Resolver::RequirementList
- Gem::Resolver::Set
- Gem::Resolver::SourceSet
- Gem::Resolver::SpecSpecification
- Gem::Resolver::Specification
- Gem::Resolver::Stats
- Gem::Resolver::VendorSet
- Gem::Resolver::VendorSpecification
- Gem::RubyVersionMismatch
- Gem::RuntimeRequirementNotMetError
- Gem::S3URISigner
- Gem::S3URISigner::ConfigurationError
- Gem::S3URISigner::InstanceProfileError
- Gem::SafeYAML
- Gem::Security
- Gem::Security::Exception
- Gem::Security::Policy
- Gem::Security::Signer
- Gem::Security::TrustDir
- Gem::SecurityOption
- Gem::Server
- Gem::SilentUI
- Gem::Source
- Gem::Source::Git
- Gem::Source::Installed
- Gem::Source::Local
- Gem::Source::Lock
- Gem::Source::SpecificFile
- Gem::Source::Vendor
- Gem::SourceFetchProblem
- Gem::SourceList
- Gem::SpecFetcher
- Gem::SpecificGemNotFoundException
- Gem::Specification
- Gem::SpecificationPolicy
- Gem::StreamUI
- Gem::StreamUI::SilentDownloadReporter
- Gem::StreamUI::SilentProgressReporter
- Gem::StreamUI::SimpleProgressReporter
- Gem::StreamUI::ThreadedDownloadReporter
- Gem::StreamUI::VerboseProgressReporter
- Gem::StubSpecification
- Gem::SystemExitException
- Gem::TestCase
- Gem::TestCase::SpecFetcherSetup
- Gem::TestCase::StaticSet
- Gem::Text
- Gem::UninstallError
- Gem::Uninstaller
- Gem::UnsatisfiableDependencyError
- Gem::UriFormatter
- Gem::UriParser
- Gem::UriParsing
- Gem::UserInteraction
- Gem::Util
- Gem::Validator
- Gem::VerificationError
- Gem::Version
- Gem::VersionOption
- Kernel
- Object
- TempIO
- YAML::Syck
- YAML::Syck

No matching classes.

# Gem::Dependency

### 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) click to toggle source

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

                   # File rubygems/dependency.rb, line 39
    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

### Public Instance Methods

<=>(other) click to toggle source

Dependencies are ordered by name.

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

===(other) click to toggle source
Alias for: =~
=~(other) click to toggle source

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.

                   # File rubygems/dependency.rb, line 193
    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

Also aliased as: ===
identity() click to toggle source

                   # File rubygems/dependency.rb, line 337
    def identity
      if prerelease?
        if specific?
          :complete
        else
          :abs_latest
        end
      elsif latest_version?
        :latest
      else
        :released
      end
    end

latest_version?() click to toggle source

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

                   # File rubygems/dependency.rb, line 99
    def latest_version?
      @requirement.none?
    end

match? name => true or false click to toggle source
match? name, version => true or false
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.

                   # File rubygems/dependency.rb, line 225
    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? and not version.prerelease?
      return false if version.prerelease? and
                      not allow_prerelease and
                      not prerelease?

      requirement.satisfied_by? version
    end

matches_spec?(spec) click to toggle source

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.

                   # File rubygems/dependency.rb, line 252
    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) click to toggle source

                   # File rubygems/dependency.rb, line 278
    def matching_specs(platform_only = false)
      env_req = Gem.env_requirement(name)
      matches = Gem::Specification.stubs_for(name).find_all do |spec|
        requirement.satisfied_by?(spec.version) && env_req.satisfied_by?(spec.version)
      end.map(&:to_spec)

      Gem::BundlerVersionFinder.filter!(matches) if name == "bundler".freeze && !requirement.specific?

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

      matches
    end

merge(other) click to toggle source

Merges the requirements of `other` into this dependency

                   # File rubygems/dependency.rb, line 262
    def merge(other)
      unless name == other.name
        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?() click to toggle source

Does this dependency require a prerelease?

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

requirement() click to toggle source

What does this dependency require?

                   # File rubygems/dependency.rb, line 121
    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() click to toggle source

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

runtime?() click to toggle source

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

specific?() click to toggle source

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

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

to_spec() click to toggle source

                   # File rubygems/dependency.rb, line 322
    def to_spec
      matches = self.to_specs.compact

      active = matches.find { |spec| spec.activated? }
      return active if active

      return matches.first if prerelease?

      # Move prereleases to the end of the list for >= 0 requirements
      pre, matches = matches.partition { |spec| spec.version.prerelease? }
      matches += pre if requirement == Gem::Requirement.default

      matches.first
    end

to_specs() click to toggle source

                   # File rubygems/dependency.rb, line 302
    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() click to toggle source

`Dependency` type.

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