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 13
def initialize(name, version, platform, source = nil)
  @name          = name
  @version       = version
  @dependencies  = []
  @platform      = platform || Gem::Platform::RUBY
  @source        = source
  @force_ruby_platform = default_force_ruby_platform
end

Public Instance Methods

==(other) click to toggle source

# File bundler/lazy_specification.rb, line 30
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 110
def __materialize__(candidates, fallback_to_non_installable: Bundler.frozen_bundle?)
  search = candidates.reverse.find do |spec|
    spec.is_a?(StubSpecification) ||
      (spec.matches_current_ruby? &&
        spec.matches_current_rubygems?)
  end
  if search.nil? && fallback_to_non_installable
    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

eql?(other) click to toggle source

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

full_name() click to toggle source

# File bundler/lazy_specification.rb, line 22
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 132
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 38
def hash
  full_name.hash
end

materialize_for_installation() click to toggle source

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

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

  candidates = if use_exact_resolved_specifications?
    matching_specs
  else
    target_platform = ruby_platform_materializes_to_ruby_platform? ? 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

    installable_candidates
  end

  __materialize__(candidates)
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 56
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 62
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 124
def to_s
  @to_s ||= if platform == Gem::Platform::RUBY
    "#{name} (#{version})"
  else
    "#{name} (#{version}-#{platform})"
  end
end

Private Instance Methods

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

use_exact_resolved_specifications?() click to toggle source

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