123456789_123456789_123456789_123456789_123456789_

Class: Bundler::LazySpecification

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

Class Method Summary

Instance Attribute Summary

MatchMetadata - Included

#matches_current_metadata?, #matches_current_ruby?, #matches_current_rubygems?

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

#content_address, #installable_on_platform?

MatchMetadata - Included

#expanded_dependencies, #matches_current_metadata_with_overrides?, #matches_current_ruby_with_overrides?, #matches_current_rubygems_with_overrides?, #metadata_dependency, #effective_required_version

Constructor Details

.new(name, version, platform, source = nil, content_address: nil, **materialization_options) ⇒ LazySpecification

[ GitHub ] 

  


# File 'lib/bundler/lazy_specification.rb', line 38



def initialize(name, version, platform, source = nil, content_address: nil, **materialization_options)
  @name          = name
  @version       = version
  @dependencies  = []
  @required_ruby_version = Gem::Requirement.default
  @required_rubygems_version = Gem::Requirement.default
  @platform = platform || Gem::Platform::RUBY
  @content_address = content_address

  @original_source = source
  @source = source
  @materialization_options = materialization_options

  @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 29



def self.from_spec(s)
  lazy_spec = new(s.name, s.version, s.platform, s.source, content_address: s.content_address)
  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.overrides = s.overrides if s.is_a?(LazySpecification)
  lazy_spec
end


  







Instance Attribute Details



  

    #content_address   (rw)
  

  [ GitHub ]


  

  


# File 'lib/bundler/lazy_specification.rb', line 11



attr_reader :name, :version, :platform, :materialization, :content_address


  








  

    #content_address=(value)   (rw)
  



  

    
Assigns the content address parsed from the lockfile's CONTENT
ADDRESSES section. The full name embeds the content address, so its
memoization must be invalidated.

  



  [ GitHub ]


  

  


# File 'lib/bundler/lazy_specification.rb', line 127



def content_address=(value)
  @content_address = value
  @full_name = nil
end


  








  

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



def incomplete?
  @materialization.nil?
end


  








  

    #materialization   (readonly)
  

  [ GitHub ]


  

  


# File 'lib/bundler/lazy_specification.rb', line 11



attr_reader :name, :version, :platform, :materialization, :content_address


  








  

    #missing?  ⇒ Boolean  (readonly)
  

  [ GitHub ]


  

  


# File 'lib/bundler/lazy_specification.rb', line 56



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 25



attr_accessor :most_specific_locked_platform


  








  

    #name   (readonly)
  

  [ GitHub ]


  

  


# File 'lib/bundler/lazy_specification.rb', line 11



attr_reader :name, :version, :platform, :materialization, :content_address


  








  

    #overrides   (rw)
  

  [ GitHub ]


  

  


# File 'lib/bundler/lazy_specification.rb', line 13



attr_accessor :overrides


  








  

    #platform   (readonly)
  

  [ GitHub ]


  

  


# File 'lib/bundler/lazy_specification.rb', line 11



attr_reader :name, :version, :platform, :materialization, :content_address


  








  

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



def ruby_platform_materializes_to_ruby_platform?
  generic_platform = Bundler.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 27



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 64



def source_changed?
  @original_source != source
end


  








  

    #use_exact_resolved_specifications?  ⇒ Boolean  (readonly, private)
  

  [ GitHub ]


  

  


# File 'lib/bundler/lazy_specification.rb', line 200



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, :content_address


  







Instance Method Details



  

    #==(other)  
  

  [ GitHub ]


  

  


# File 'lib/bundler/lazy_specification.rb', line 90



def ==(other)
  full_name == other.full_name
end


  








  

    #candidate_platforms(locked_platforms: nil)   (private)
  



  

    
Platforms to try in order of preference. Ruby platform is last since it
requires compilation, but works when precompiled gems are incompatible.
When a set of locked platforms is given (frozen mode), restrict the
candidates to those, so we never materialize a platform that wasn't locked.

  



  [ GitHub ]


  

  


# File 'lib/bundler/lazy_specification.rb', line 226



def candidate_platforms(locked_platforms: nil)
  target = source.is_a?(Source::Path) ? platform : Bundler.local_platform
  platforms = [target, platform, Gem::Platform::RUBY].uniq
  return platforms unless locked_platforms

  platforms & locked_platforms
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 262



def choose_compatible(candidates, fallback_to_non_installable: Bundler.frozen_bundle?)
  override_list = overrides || []
  search = candidates.reverse.find do |spec|
    spec.is_a?(StubSpecification) || spec.matches_current_metadata_with_overrides?(override_list)
  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 94



def eql?(other)
  full_name.eql?(other.full_name)
end


  








  

    #file_name  
  

  [ GitHub ]


  

  


# File 'lib/bundler/lazy_specification.rb', line 78



def file_name
  "#{full_name}.gem"
end


  








  

    #find_compatible_platform_spec(specs, locked_platforms: nil)   (private)
  

  [ GitHub ]


  

  


# File 'lib/bundler/lazy_specification.rb', line 213



def find_compatible_platform_spec(specs, locked_platforms: nil)
  candidate_platforms(locked_platforms: locked_platforms).each do |plat|
    candidates = MatchPlatform.select_best_platform_match(specs, plat)
    spec = choose_compatible(candidates, fallback_to_non_installable: false)
    return spec if spec
  end
  nil
end


  








  

    #force_ruby_platform!  
  

  [ GitHub ]


  

  


# File 'lib/bundler/lazy_specification.rb', line 186



def force_ruby_platform!
  @force_ruby_platform = true
end


  








  

    #frozen_bundle_fallback(specs)   (private)
  



  

    
In frozen mode, accept any candidate. Will error at install time.
When target differs from locked platform, prefer locked platform's candidates
to preserve lockfile integrity.

  



  [ GitHub ]


  

  


# File 'lib/bundler/lazy_specification.rb', line 237



def frozen_bundle_fallback(specs)
  target = source.is_a?(Source::Path) ? platform : Bundler.local_platform
  fallback_platform = target == platform ? target : platform
  candidates = MatchPlatform.select_best_platform_match(specs, fallback_platform)
  choose_compatible(candidates)
end


  








  

    #full_name  
  

  [ GitHub ]


  

  


# File 'lib/bundler/lazy_specification.rb', line 68



def full_name
  @full_name ||= if Gem::ContentAddress.content_addressed?(self, validate_ruby_abi: false)
    "#{@name}-#{@version}-#{@content_address}"
  elsif platform == Gem::Platform::RUBY
    "#{@name}-#{@version}"
  else
    "#{@name}-#{@version}-#{platform}"
  end
end


  








  

    #git_version  
  

  [ GitHub ]


  

  


# File 'lib/bundler/lazy_specification.rb', line 181



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 98



def hash
  full_name.hash
end


  








  

    #inspect  
  

  [ GitHub ]


  

  


# File 'lib/bundler/lazy_specification.rb', line 173



def inspect
  "#<#{self.class} @name=\"#{name}\" (#{full_name.delete_prefix("#{name}-")})>"
end


  








  

    #lock_name  
  

  [ GitHub ]


  

  


# File 'lib/bundler/lazy_specification.rb', line 82



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 250



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 144



def materialize_for_cache
  source.remote!

  materialize(self, &:first)
end


  








  

    #materialize_for_installation(locked_platforms)  
  

  [ GitHub ]


  

  


# File 'lib/bundler/lazy_specification.rb', line 156



def materialize_for_installation(locked_platforms)
  source.local!

  if use_exact_resolved_specifications?
    spec = materialize(self) {|specs| choose_compatible(specs, fallback_to_non_installable: false) }
    return spec if spec

    # Exact spec is incompatible; in frozen mode, try to find a compatible platform variant
    # In non-frozen mode, return nil to trigger re-resolution and lockfile update
    if Bundler.frozen_bundle?
      materialize([name, version]) {|specs| resolve_best_platform(specs, locked_platforms: locked_platforms) }
    end
  else
    materialize([name, version]) {|specs| resolve_best_platform(specs) }
  end
end


  








  

    #materialized_for_installation(locked_platforms = nil)  
  

  [ GitHub ]


  

  


# File 'lib/bundler/lazy_specification.rb', line 150



def materialized_for_installation(locked_platforms = nil)
  @materialization = materialize_for_installation(locked_platforms)

  self unless incomplete?
end


  








  

    #name_tuple  
  

  [ GitHub ]


  

  


# File 'lib/bundler/lazy_specification.rb', line 86



def name_tuple
  Gem::NameTuple.new(@name, @version, @platform, content_address: @content_address)
end


  








  

    #replace_source_with!(gemfile_source)  
  

  [ GitHub ]


  

  


# File 'lib/bundler/lazy_specification.rb', line 190



def replace_source_with!(gemfile_source)
  return unless gemfile_source.can_lock?(self)

  @source = gemfile_source

  true
end


  








  

    #resolve_best_platform(specs, locked_platforms: nil)   (private)
  



  

    
Try platforms in order of preference until finding a compatible spec.
Used for legacy lockfiles and as a fallback when the exact locked spec
is incompatible. Falls back to frozen bundle behavior if none match.

  



  [ GitHub ]


  

  


# File 'lib/bundler/lazy_specification.rb', line 207



def resolve_best_platform(specs, locked_platforms: nil)
  specs = MatchPlatform.select_all_content_address_match(specs, content_address)

  find_compatible_platform_spec(specs, locked_platforms: locked_platforms) || frozen_bundle_fallback(specs)
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 116



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 132



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 177



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 unless we are in strict mode (which we set during installation)
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 287



def validate_dependencies(spec)
  if !@materialization_options[:strict] && spec.is_a?(StubSpecification)
    spec.dependencies = dependencies
  else
    if !source.is_a?(Source::Path) && spec.runtime_dependencies.sort != dependencies.sort
      raise IncorrectLockfileDependencies.new(self, spec.runtime_dependencies, dependencies)
    end
  end
end