123456789_123456789_123456789_123456789_123456789_

Class: Bundler::LazySpecification

Relationships & Source Files
Super Chains via Extension / Inclusion / Inheritance
Instance Chain:
Inherits: Object
Defined in: lib/bundler/lazy_specification.rb

Constant Summary

GemHelpers - Included

GENERICS, GENERIC_CACHE

Class Method Summary

Instance Attribute Summary

GemHelpers - Included

MatchMetadata - Included

Instance Method Summary

ForcePlatform - Included

#default_force_ruby_platform

The :force_ruby_platform value used by dependencies for resolution, and by locked specifications for materialization is false by default, except for TruffleRuby.

MatchPlatform - Included

GemHelpers - Included

MatchMetadata - Included

Constructor Details

.new(name, version, platform, source = nil) ⇒ LazySpecification

[ GitHub ]

  
# File 'lib/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

Class Method Details

.from_spec(s)

[ GitHub ]

  
# File 'lib/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

Instance Attribute Details

#dependencies (rw) Also known as: #runtime_dependencies

[ GitHub ]

  
# File 'lib/bundler/lazy_specification.rb', line 12
attr_accessor :source, :remote, :force_ruby_platform, :dependencies, :required_ruby_version, :required_rubygems_version

#force_ruby_platform (rw)

[ GitHub ]

  
# File 'lib/bundler/lazy_specification.rb', line 12
attr_accessor :source, :remote, :force_ruby_platform, :dependencies, :required_ruby_version, :required_rubygems_version

#incomplete?Boolean (readonly)

[ GitHub ]

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

#materialization (readonly)

[ GitHub ]

  
# File 'lib/bundler/lazy_specification.rb', line 11
attr_reader :name, :version, :platform, :materialization

#missing?Boolean (readonly)

[ GitHub ]

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

#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.

[ GitHub ]

  
# File 'lib/bundler/lazy_specification.rb', line 24
attr_accessor :most_specific_locked_platform

#name (readonly)

[ GitHub ]

  
# File 'lib/bundler/lazy_specification.rb', line 11
attr_reader :name, :version, :platform, :materialization

#platform (readonly)

[ GitHub ]

  
# File 'lib/bundler/lazy_specification.rb', line 11
attr_reader :name, :version, :platform, :materialization

#remote (rw)

[ GitHub ]

  
# File 'lib/bundler/lazy_specification.rb', line 12
attr_accessor :source, :remote, :force_ruby_platform, :dependencies, :required_ruby_version, :required_rubygems_version

#required_ruby_version (rw)

[ GitHub ]

  
# File 'lib/bundler/lazy_specification.rb', line 12
attr_accessor :source, :remote, :force_ruby_platform, :dependencies, :required_ruby_version, :required_rubygems_version

#required_rubygems_version (rw)

[ GitHub ]

  
# File 'lib/bundler/lazy_specification.rb', line 12
attr_accessor :source, :remote, :force_ruby_platform, :dependencies, :required_ruby_version, :required_rubygems_version

#ruby_platform_materializes_to_ruby_platform?Boolean (readonly, private)

[ GitHub ]

  
# File 'lib/bundler/lazy_specification.rb', line 192
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

#runtime_dependencies (readonly)

Alias for #dependencies.

[ GitHub ]

  
# File 'lib/bundler/lazy_specification.rb', line 26
alias_method :runtime_dependencies, :dependencies

#source (rw)

[ GitHub ]

  
# File 'lib/bundler/lazy_specification.rb', line 12
attr_accessor :source, :remote, :force_ruby_platform, :dependencies, :required_ruby_version, :required_rubygems_version

#source_changed?Boolean (readonly)

[ GitHub ]

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

#use_exact_resolved_specifications?Boolean (readonly, private)

[ GitHub ]

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

#version (readonly)

[ GitHub ]

  
# File 'lib/bundler/lazy_specification.rb', line 11
attr_reader :name, :version, :platform, :materialization

Instance Method Details

#==(other)

[ GitHub ]

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

#choose_compatible(candidates, fallback_to_non_installable: Bundler.frozen_bundle?) (private)

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 lockfile, 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.

[ GitHub ]

  
# File 'lib/bundler/lazy_specification.rb', line 210
def choose_compatible(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
  end

  if search
    validate_dependencies(search) if search.platform == platform

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

#eql?(other) ⇒ Boolean

[ GitHub ]

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

#force_ruby_platform!

[ GitHub ]

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

#full_name

[ GitHub ]

  
# File 'lib/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

[ GitHub ]

  
# File 'lib/bundler/lazy_specification.rb', line 169
def git_version
  return unless source.is_a?(Bundler::Source::Git)
  " #{source.revision[0..6]}"
end

#hash

[ GitHub ]

  
# File 'lib/bundler/lazy_specification.rb', line 88
def hash
  full_name.hash
end

#inspect

[ GitHub ]

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

#lock_name

[ GitHub ]

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

#materialize(query) {|matching_specs| ... } (private)

Yields:

  • (matching_specs)
[ GitHub ]

  
# File 'lib/bundler/lazy_specification.rb', line 198
def materialize(query)
  matching_specs = source.specs.search(query)
  return self if matching_specs.empty?

  yield matching_specs
end

#materialize_for_cache

[ GitHub ]

  
# File 'lib/bundler/lazy_specification.rb', line 124
def materialize_for_cache
  source.remote!

  materialize(self, &:first)
end

#materialize_for_installation

[ GitHub ]

  
# File 'lib/bundler/lazy_specification.rb', line 136
def materialize_for_installation
  source.local!

  if use_exact_resolved_specifications?
    materialize(self) do |matching_specs|
      choose_compatible(matching_specs)
    end
  else
    materialize([name, version]) do |matching_specs|
      target_platform = source.is_a?(Source::Path) ? platform : local_platform

      installable_candidates = GemHelpers.select_best_platform_match(matching_specs, target_platform)

      specification = choose_compatible(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

      choose_compatible(installable_candidates)
    end
  end
end

#materialized_for_installation

[ GitHub ]

  
# File 'lib/bundler/lazy_specification.rb', line 130
def materialized_for_installation
  @materialization = materialize_for_installation

  self unless incomplete?
end

#name_tuple

[ GitHub ]

  
# File 'lib/bundler/lazy_specification.rb', line 76
def name_tuple
  Gem::NameTuple.new(@name, @version, @platform)
end

#replace_source_with!(gemfile_source)

[ GitHub ]

  
# File 'lib/bundler/lazy_specification.rb', line 178
def replace_source_with!(gemfile_source)
  return unless gemfile_source.can_lock?(self)

  @source = gemfile_source

  true
end

#satisfies?(dependency) ⇒ Boolean

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.

[ GitHub ]

  
# File 'lib/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

#to_lock

[ GitHub ]

  
# File 'lib/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

[ GitHub ]

  
# File 'lib/bundler/lazy_specification.rb', line 165
def to_s
  lock_name
end

#validate_dependencies(spec) (private)

Validate dependencies of this locked spec are consistent with dependencies of the actual spec that was materialized.

Note that we don’t validate dependencies of locally installed gems but accept what’s in the lockfile instead for performance, since loading dependencies of locally installed gems would mean evaluating all gemspecs, which would affect bundler/setup performance.

[ GitHub ]

  
# File 'lib/bundler/lazy_specification.rb', line 233
def validate_dependencies(spec)
  if spec.is_a?(StubSpecification)
    spec.dependencies = dependencies
  else
    if !source.is_a?(Source::Path) && spec.runtime_dependencies.sort != dependencies.sort
      raise IncorrectLockfileDependencies.new(self)
    end
  end
end