class Bundler::LazySpecification

Attributes

dependencies[R]
force_ruby_platform[RW]
name[R]
platform[R]
remote[RW]
source[RW]
version[R]

Public Class Methods

new(name, version, platform, source = nil) click to toggle source
# File bundler/lazy_specification.rb, line 10
def initialize(name, version, platform, source = nil)
  @name          = name
  @version       = version
  @dependencies  = []
  @platform      = platform || Gem::Platform::RUBY
  @source        = source
  @specification = nil
end

Public Instance Methods

==(other) click to toggle source
# File bundler/lazy_specification.rb, line 27
def ==(other)
  identifier == other.identifier
end
__materialize__(candidates) click to toggle source
# File bundler/lazy_specification.rb, line 92
def __materialize__(candidates)
  @specification = begin
    search = candidates.reverse.find do |spec|
      spec.is_a?(StubSpecification) ||
        (spec.matches_current_ruby? &&
          spec.matches_current_rubygems?)
    end
    if search.nil? && Bundler.frozen_bundle?
      search = candidates.last
    else
      search.dependencies = dependencies if search && search.full_name == full_name && (search.is_a?(RemoteSpecification) || search.is_a?(EndpointSpecification))
    end
    search
  end
end
eql?(other) click to toggle source
# File bundler/lazy_specification.rb, line 31
def eql?(other)
  identifier.eql?(other.identifier)
end
full_name() click to toggle source
# File bundler/lazy_specification.rb, line 19
def full_name
  if platform == Gem::Platform::RUBY
    "#{@name}-#{@version}"
  else
    "#{@name}-#{@version}-#{platform}"
  end
end
git_version() click to toggle source
# File bundler/lazy_specification.rb, line 124
def git_version
  return unless source.is_a?(Bundler::Source::Git)
  " #{source.revision[0..6]}"
end
hash() click to toggle source
# File bundler/lazy_specification.rb, line 35
def hash
  identifier.hash
end
identifier() click to toggle source
# File bundler/lazy_specification.rb, line 120
def identifier
  @__identifier ||= [name, version, platform.to_s]
end
materialize_for_installation() click to toggle source
# File bundler/lazy_specification.rb, line 76
def materialize_for_installation
  source.local!

  candidates = if source.is_a?(Source::Path) || !ruby_platform_materializes_to_ruby_platform?
    target_platform = ruby_platform_materializes_to_ruby_platform? ? platform : local_platform

    GemHelpers.select_best_platform_match(source.specs.search(Dependency.new(name, version)), target_platform)
  else
    source.specs.search(self)
  end

  return self if candidates.empty?

  __materialize__(candidates)
end
respond_to?(*args) click to toggle source
Calls superclass method
# File bundler/lazy_specification.rb, line 108
def respond_to?(*args)
  super || @specification ? @specification.respond_to?(*args) : nil
end
satisfies?(dependency) click to toggle source

Does this locked specification satisfy dependency?

NOTE: Rubygems default requirement is “>= 0”, which doesn’t match prereleases of 0 versions, like “0.0.0.dev” or “0.0.0.SNAPSHOT”. However, bundler users expect those to work. We need to make sure that Gemfile dependencies without explicit requirements (which use “>= 0” under the hood by default) are still valid for locked specs using this kind of versions. The method implements an ad-hoc fix for that. A better solution might be to change default rubygems requirement of dependencies to be “>= 0.A” but that’s a major refactoring likely to break things. Hopefully we can attempt it in the future.

# File bundler/lazy_specification.rb, line 53
def satisfies?(dependency)
  effective_requirement = dependency.requirement == Gem::Requirement.default ? Gem::Requirement.new(">= 0.A") : dependency.requirement

  @name == dependency.name && effective_requirement.satisfied_by?(Gem::Version.new(@version))
end
to_lock() click to toggle source
# File bundler/lazy_specification.rb, line 59
def to_lock
  out = String.new

  if platform == Gem::Platform::RUBY
    out << "    #{name} (#{version})\n"
  else
    out << "    #{name} (#{version}-#{platform})\n"
  end

  dependencies.sort_by(&:to_s).uniq.each do |dep|
    next if dep.type == :development
    out << "    #{dep.to_lock}\n"
  end

  out
end
to_s() click to toggle source
# File bundler/lazy_specification.rb, line 112
def to_s
  @__to_s ||= if platform == Gem::Platform::RUBY
    "#{name} (#{version})"
  else
    "#{name} (#{version}-#{platform})"
  end
end

Private Instance Methods

method_missing(method, *args, &blk) click to toggle source
Calls superclass method
# File bundler/lazy_specification.rb, line 135
def method_missing(method, *args, &blk)
  raise "LazySpecification has not been materialized yet (calling :#{method} #{args.inspect})" unless @specification

  return super unless respond_to?(method)

  @specification.send(method, *args, &blk)
end
ruby_platform_materializes_to_ruby_platform?() click to toggle source

For backwards compatibility with existing lockfiles, if the most specific locked platform is not a specific platform like x86_64-linux or universal-java-11, then we keep the previous behaviour of resolving the best platform variant at materiliazation time. For previous bundler versions (before 2.2.0) this was always the case (except when the lockfile only included non-ruby platforms), but we’re also keeping this behaviour on newer bundlers unless users generate the lockfile from scratch or explicitly add a more specific platform.

# File bundler/lazy_specification.rb, line 153
def ruby_platform_materializes_to_ruby_platform?
  generic_platform = generic_local_platform == Gem::Platform::JAVA ? Gem::Platform::JAVA : Gem::Platform::RUBY

  !Bundler.most_specific_locked_platform?(generic_platform) || force_ruby_platform || Bundler.settings[:force_ruby_platform]
end
to_ary() click to toggle source
# File bundler/lazy_specification.rb, line 131
def to_ary
  nil
end