123456789_123456789_123456789_123456789_123456789_

Class: Bundler::LazySpecification

Relationships & Source Files
Super Chains via Extension / Inclusion / Inheritance
Instance Chain:
self, 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

MatchPlatform - Included

#match_platform

GemHelpers - Included

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

Constructor Details

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

[ GitHub ] 

  


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



def initialize(name, version, platform, source = nil)
  @name          = name
  @version       = version
  @dependencies  = []
  @platform      = platform || Gem::Platform::RUBY
  @source        = source
  @specification = nil
end


  







Dynamic Method Handling

  

    This class handles dynamic methods through the method_missing method




  

    #method_missing(method, *args, &blk)   (private)
  

  [ GitHub ]


  

  


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



def method_missing(method, *args, &blk)
  raise "LazySpecification has not been materialized yet (calling :#{method} #{args.inspect})" unless @specification

  return super unless respond_to?(method)

  @specification.send(method, *args, &blk)
end


  







Instance Attribute Details



  

    #dependencies   (readonly)
  

  [ GitHub ]


  

  


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



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


  








  

    #name   (readonly)
  

  [ GitHub ]


  

  


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



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


  








  

    #platform   (readonly)
  

  [ GitHub ]


  

  


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



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


  








  

    #remote   (rw)
  

  [ GitHub ]


  

  


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



attr_accessor :source, :remote


  








  

    #ruby_platform_materializes_to_ruby_platform?  ⇒ Boolean  (readonly, private)
  



  

    

For backwards compatibility with existing lockfiles, if the most specific locked platform is RUBY, 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 154



def ruby_platform_materializes_to_ruby_platform?
  !Bundler.most_specific_locked_platform?(Gem::Platform::RUBY) || Bundler.settings[:force_ruby_platform]
end


  








  

    #source   (rw)
  

  [ GitHub ]


  

  


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



attr_accessor :source, :remote


  








  

    #version   (readonly)
  

  [ GitHub ]


  

  


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



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


  







Instance Method Details



  

    #==(other)  
  

  [ GitHub ]


  

  


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



def ==(other)
  identifier == other.identifier
end


  








  

    #__materialize__  
  

  [ GitHub ]


  

  


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



def __materialize__
  @specification = if source.is_a?(Source::Gemspec) && source.gemspec.name == name
    source.gemspec.tap {|s| s.source = source }
  else
    search_object = if source.is_a?(Source::Path)
      Dependency.new(name, version)
    else
      ruby_platform_materializes_to_ruby_platform? ? self : Dependency.new(name, version)
    end
    platform_object = Gem::Platform.new(platform)
    candidates = source.specs.search(search_object)
    same_platform_candidates = candidates.select do |spec|
      MatchPlatform.platforms_match?(spec.platform, platform_object)
    end
    installable_candidates = same_platform_candidates.select do |spec|
      !spec.is_a?(EndpointSpecification) ||
        (spec.required_ruby_version.satisfied_by?(Gem.ruby_version) &&
          spec.required_rubygems_version.satisfied_by?(Gem.rubygems_version))
    end
    search = installable_candidates.last || same_platform_candidates.last
    search.dependencies = dependencies if search && (search.is_a?(RemoteSpecification) || search.is_a?(EndpointSpecification))
    search
  end
end


  








  

    #eql?(other)  ⇒ Boolean 
  



  

    
  





  


  [ GitHub ]


  

  


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



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


  








  

    #full_name  
  

  [ GitHub ]


  

  


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



def full_name
  if platform == Gem::Platform::RUBY || platform.nil?
    "#{@name}-#{@version}"
  else
    "#{@name}-#{@version}-#{platform}"
  end
end


  








  

    #git_version  
  

  [ GitHub ]


  

  


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



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 37



def hash
  identifier.hash
end


  








  

    #identifier  
  

  [ GitHub ]


  

  


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



def identifier
  @__identifier ||= [name, version, platform_string]
end


  








  

    #platform_string   (protected)
  

  [ GitHub ]


  

  


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



def platform_string
  platform_string = platform.to_s
  platform_string == Index::RUBY ? Index::NULL : platform_string
end


  








  

    #respond_to?(*args)  ⇒ Boolean 
  



  

    
  





  


  [ GitHub ]


  

  


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



def respond_to?(*args)
  super || @specification ? @specification.respond_to?(*args) : nil
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 55



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_ary   (private)
  

  [ GitHub ]


  

  


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



def to_ary
  nil
end


  








  

    #to_lock  
  

  [ GitHub ]


  

  


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



def to_lock
  out = String.new

  if platform == Gem::Platform::RUBY || platform.nil?
    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 107



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