123456789_123456789_123456789_123456789_123456789_

Class: Bundler::LazySpecification

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

Constant Summary

GemHelpers - Included

GENERICS, GENERIC_CACHE

Class Method Summary

Instance Attribute Summary

GemHelpers - Included

#generic_local_platform_is_ruby?

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

#match_platform

GemHelpers - Included

#generic, #generic_local_platform, #local_platform, #platform_specificity_match, #same_deps, #same_specificity, #select_best_local_platform_match, #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 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

  @original_source = source
  @source = source

  @force_ruby_platform = default_force_ruby_platform
end


  







Class Method Details



  

    .from_spec(s)  
  

  [ GitHub ]


  

  


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


  







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


  








  

    #name   (readonly)
  

  [ GitHub ]


  

  


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



attr_reader :name, :version, :platform


  








  

    #platform   (readonly)
  

  [ GitHub ]


  

  


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



attr_reader :name, :version, :platform


  








  

    #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


  








  

    #runtime_dependencies   (readonly)
  



  

    

Alias for #dependencies.


  



  [ GitHub ]


  

  


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



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 38



def source_changed?
  @original_source != source
end


  








  

    #version   (readonly)
  

  [ GitHub ]


  

  


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



attr_reader :name, :version, :platform


  







Instance Method Details



  

    #==(other)  
  

  [ GitHub ]


  

  


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



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 140



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
  elsif search && search.full_name == full_name
    # We don't validate locally installed dependencies but accept what's in
    # the lockfile instead for performance, since loading locally installed
    # dependencies would mean evaluating all gemspecs, which would affect
    # `bundler/setup` performance
    if search.is_a?(StubSpecification)
      search.dependencies = dependencies
    else
      if !source.is_a?(Source::Path) && search.runtime_dependencies.sort != dependencies.sort
        raise IncorrectLockfileDependencies.new(self)
      end

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


  








  

    #eql?(other)  ⇒ Boolean 
  



  

    
  





  


  [ GitHub ]


  

  


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



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


  








  

    #force_ruby_platform!  
  

  [ GitHub ]


  

  


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



def force_ruby_platform!
  @force_ruby_platform = true
end


  








  

    #full_name  
  

  [ GitHub ]


  

  


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



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 172



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 66



def hash
  full_name.hash
end


  








  

    #inspect  
  

  [ GitHub ]


  

  


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



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


  








  

    #lock_name  
  

  [ GitHub ]


  

  


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



def lock_name
  @lock_name ||= name_tuple.lock_name
end


  








  

    #materialize_for_installation(most_specific_locked_platform = nil)  
  

  [ GitHub ]


  

  


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



def materialize_for_installation(most_specific_locked_platform = nil)
  source.local!

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

    target_platform = source.is_a?(Source::Path) ? 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

    __materialize__(installable_candidates)
  end
end


  








  

    #materialize_strictly  
  

  [ GitHub ]


  

  


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



def materialize_strictly
  source.local!

  matching_specs = source.specs.search(self)
  return self if matching_specs.empty?

  __materialize__(matching_specs)
end


  








  

    #name_tuple  
  

  [ GitHub ]


  

  


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



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


  








  

    #ruby_platform_materializes_to_ruby_platform?(most_specific_locked_platform)  ⇒ Boolean  (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 197



def ruby_platform_materializes_to_ruby_platform?(most_specific_locked_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


  








  

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



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 90



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 168



def to_s
  lock_name
end


  








  

    #use_exact_resolved_specifications?(most_specific_locked_platform)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


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



def use_exact_resolved_specifications?(most_specific_locked_platform)
  !source.is_a?(Source::Path) && ruby_platform_materializes_to_ruby_platform?(most_specific_locked_platform)
end