class Bundler::LazySpecification

Attributes

dependencies[RW]
force_ruby_platform[RW]
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 16
def self.from_spec(s)
  lazy_spec = new(s.name, s.version, s.platform, s.source)
  lazy_spec.dependencies = s.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 24
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
  @source        = source
  @force_ruby_platform = default_force_ruby_platform
end

Public Instance Methods

==(other) click to toggle source
# File bundler/lazy_specification.rb, line 51
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 126
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
  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 55
def eql?(other)
  full_name.eql?(other.full_name)
end
force_ruby_platform!() click to toggle source
# File bundler/lazy_specification.rb, line 147
def force_ruby_platform!
  @force_ruby_platform = true
end
full_name() click to toggle source
# File bundler/lazy_specification.rb, line 35
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 142
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 59
def hash
  full_name.hash
end
lock_name() click to toggle source
# File bundler/lazy_specification.rb, line 43
def lock_name
  @lock_name ||= name_tuple.lock_name
end
materialize_for_installation() click to toggle source
# File bundler/lazy_specification.rb, line 95
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
name_tuple() click to toggle source
# File bundler/lazy_specification.rb, line 47
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 77
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 83
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 138
def to_s
  lock_name
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 167
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 153
def use_exact_resolved_specifications?
  @use_exact_resolved_specifications ||= !source.is_a?(Source::Path) && ruby_platform_materializes_to_ruby_platform?
end