class Bundler::LazySpecification

Attributes

dependencies[RW]

force_ruby_platform[RW]

materialization[R]

most_specific_locked_platform[RW]

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.

name[R]

platform[R]

remote[RW]

required_ruby_version[RW]

required_rubygems_version[RW]

runtime_dependencies[RW]

source[RW]

version[R]

Public Class Methods

from_spec(s) click to toggle source

# File bundler/lazy_specification.rb, line 28
def self.from_spec(s)
  lazy_spec = new(s.name, s.version, s.platform, s.source)
  lazy_spec.dependencies = s.runtime_dependencies
  lazy_spec.required_ruby_version = s.required_ruby_version
  lazy_spec.required_rubygems_version = s.required_rubygems_version
  lazy_spec
end

new(name, version, platform, source = nil) click to toggle source

# File bundler/lazy_specification.rb, line 36
def initialize(name, version, platform, source = nil)
  @name          = name
  @version       = version
  @dependencies  = []
  @required_ruby_version = Gem::Requirement.default
  @required_rubygems_version = Gem::Requirement.default
  @platform = platform || Gem::Platform::RUBY

  @original_source = source
  @source = source

  @force_ruby_platform = default_force_ruby_platform
  @most_specific_locked_platform = nil
  @materialization = nil
end

Public Instance Methods

==(other) click to toggle source

# File bundler/lazy_specification.rb, line 80
def ==(other)
  full_name == other.full_name
end

__materialize__(candidates, fallback_to_non_installable: Bundler.frozen_bundle?) click to toggle source

If in frozen mode, we fallback to a non-installable candidate because by doing this we avoid re-resolving and potentially end up changing the lock file, which is not allowed. In that case, we will give a proper error about the mismatch higher up the stack, right before trying to install the bad gem.

# File bundler/lazy_specification.rb, line 168
def __materialize__(candidates, fallback_to_non_installable: Bundler.frozen_bundle?)
  search = candidates.reverse.find do |spec|
    spec.is_a?(StubSpecification) || spec.matches_current_metadata?
  end
  if search.nil? && fallback_to_non_installable
    search = candidates.last
  elsif search && search.full_name == full_name
    # We don't validate locally installed dependencies but accept what's in
    # the lockfile instead for performance, since loading locally installed
    # dependencies would mean evaluating all gemspecs, which would affect
    # `bundler/setup` performance
    if search.is_a?(StubSpecification)
      search.dependencies = dependencies
    else
      if !source.is_a?(Source::Path) && search.runtime_dependencies.sort != dependencies.sort
        raise IncorrectLockfileDependencies.new(self)
      end

      search.locked_platform = platform if search.instance_of?(RemoteSpecification) || search.instance_of?(EndpointSpecification)
    end
  end
  search
end

eql?(other) click to toggle source

# File bundler/lazy_specification.rb, line 84
def eql?(other)
  full_name.eql?(other.full_name)
end

force_ruby_platform!() click to toggle source

# File bundler/lazy_specification.rb, line 205
def force_ruby_platform!
  @force_ruby_platform = true
end

full_name() click to toggle source

# File bundler/lazy_specification.rb, line 64
def full_name
  @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 200
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 88
def hash
  full_name.hash
end

incomplete?() click to toggle source

# File bundler/lazy_specification.rb, line 56
def incomplete?
  @materialization.nil?
end

inspect() click to toggle source

# File bundler/lazy_specification.rb, line 192
def inspect
  "#<#{self.class} @name=\"#{name}\" (#{full_name.delete_prefix("#{name}-")})>"
end

lock_name() click to toggle source

# File bundler/lazy_specification.rb, line 72
def lock_name
  @lock_name ||= name_tuple.lock_name
end

materialize_for_installation() click to toggle source

# File bundler/lazy_specification.rb, line 139
def materialize_for_installation
  source.local!

  if use_exact_resolved_specifications?
    materialize_strictly
  else
    matching_specs = source.specs.search([name, version])
    return self if matching_specs.empty?

    target_platform = source.is_a?(Source::Path) ? platform : local_platform

    installable_candidates = GemHelpers.select_best_platform_match(matching_specs, target_platform)

    specification = __materialize__(installable_candidates, fallback_to_non_installable: false)
    return specification unless specification.nil?

    if target_platform != platform
      installable_candidates = GemHelpers.select_best_platform_match(matching_specs, platform)
    end

    __materialize__(installable_candidates)
  end
end

materialize_strictly() click to toggle source

# File bundler/lazy_specification.rb, line 124
def materialize_strictly
  source.local!

  matching_specs = source.specs.search(self)
  return self if matching_specs.empty?

  __materialize__(matching_specs)
end

materialized_for_installation() click to toggle source

# File bundler/lazy_specification.rb, line 133
def materialized_for_installation
  @materialization = materialize_for_installation

  self unless incomplete?
end

missing?() click to toggle source

# File bundler/lazy_specification.rb, line 52
def missing?
  @materialization == self
end

name_tuple() click to toggle source

# File bundler/lazy_specification.rb, line 76
def name_tuple
  Gem::NameTuple.new(@name, @version, @platform)
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 106
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

source_changed?() click to toggle source

# File bundler/lazy_specification.rb, line 60
def source_changed?
  @original_source != source
end

to_lock() click to toggle source

# File bundler/lazy_specification.rb, line 112
def to_lock
  out = String.new
  out << "    #{lock_name}\n"

  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 196
def to_s
  lock_name
end

Private Instance Methods

ruby_platform_materializes_to_ruby_platform?() click to toggle source

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

  (most_specific_locked_platform != generic_platform) || force_ruby_platform || Bundler.settings[:force_ruby_platform]
end

use_exact_resolved_specifications?() click to toggle source

# File bundler/lazy_specification.rb, line 211
def use_exact_resolved_specifications?
  !source.is_a?(Source::Path) && ruby_platform_materializes_to_ruby_platform?
end