123456789_123456789_123456789_123456789_123456789_

Class: Bundler::LazySpecification

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

Constant Summary

GemHelpers - Included

GENERICS, GENERIC_CACHE

Class Method Summary

Instance Attribute Summary

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

#match_platform

GemHelpers - Included

#generic, #generic_local_platform, #local_platform, #platform_specificity_match, #same_deps, #same_specificity, #select_best_platform_match, #sort_best_platform_match

Constructor Details

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

[ GitHub ] 

  


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


  







Instance Attribute Details



  

    #dependencies   (readonly)
  

  [ GitHub ]


  

  


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



attr_reader :name, :version, :dependencies, :platform


  








  

    #force_ruby_platform   (rw)
  

  [ GitHub ]


  

  


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



attr_accessor :source, :remote, :force_ruby_platform


  








  

    #name   (readonly)
  

  [ GitHub ]


  

  


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



attr_reader :name, :version, :dependencies, :platform


  








  

    #platform   (readonly)
  

  [ GitHub ]


  

  


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



attr_reader :name, :version, :dependencies, :platform


  








  

    #remote   (rw)
  

  [ GitHub ]


  

  


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



attr_accessor :source, :remote, :force_ruby_platform


  








  

    #ruby_platform_materializes_to_ruby_platform?  ⇒ Boolean  (readonly, private)
  



  

    

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


  








  

    #source   (rw)
  

  [ GitHub ]


  

  


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



attr_accessor :source, :remote, :force_ruby_platform


  








  

    #use_exact_resolved_specifications?  ⇒ Boolean  (readonly, private)
  

  [ GitHub ]


  

  


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


  








  

    #version   (readonly)
  

  [ GitHub ]


  

  


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



attr_reader :name, :version, :dependencies, :platform


  







Instance Method Details



  

    #==(other)  
  

  [ GitHub ]


  

  


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



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


  








  

    #__materialize__(candidates, fallback_to_non_installable: Bundler.frozen_bundle?)  
  



  

    

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.


  



  [ GitHub ]


  

  


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



  

    
  





  


  [ GitHub ]


  

  


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



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


  








  

    #full_name  
  

  [ GitHub ]


  

  


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

  [ GitHub ]


  

  


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



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 38



def hash
  full_name.hash
end


  








  

    #materialize_for_installation  
  

  [ GitHub ]


  

  


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

  [ GitHub ]


  

  


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

  [ GitHub ]


  

  


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



def to_s
  @to_s ||= if platform == Gem::Platform::RUBY
    "#{name} (#{version})"
  else
    "#{name} (#{version}-#{platform})"
  end
end