class Bundler::LazySpecification - bundler: Ruby Standard Library Documentation

# class Bundler::LazySpecification

### Attributes

dependencies[RW]
force_ruby_platform[RW]
materialization[R]
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.

name[R]
platform[R]
remote[RW]
required_ruby_version[RW]
required_rubygems_version[RW]
runtime_dependencies[RW]
source[RW]
version[R]

### Public Class Methods

from_spec(s) click to toggle source

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

new(name, version, platform, source = nil) click to toggle source

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

### Public Instance Methods

==(other) click to toggle source

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

__materialize__(candidates, fallback_to_non_installable: Bundler.frozen_bundle?) click to toggle source

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.

    # File bundler/lazy_specification.rb, line 168
    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) click to toggle source

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

force_ruby_platform!() click to toggle source

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

full_name() click to toggle source

    # File 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() click to toggle source

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

hash() click to toggle source

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

incomplete?() click to toggle source

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

inspect() click to toggle source

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

lock_name() click to toggle source

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

materialize_for_installation() click to toggle source

    # File bundler/lazy_specification.rb, line 139
    def materialize_for_installation
      source.local!

      if use_exact_resolved_specifications?
        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() click to toggle source

    # File bundler/lazy_specification.rb, line 124
    def materialize_strictly
      source.local!

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

      __materialize__(matching_specs)
    end

materialized_for_installation() click to toggle source

    # File bundler/lazy_specification.rb, line 133
    def materialized_for_installation
      @materialization = materialize_for_installation

      self unless incomplete?
    end

missing?() click to toggle source

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

name_tuple() click to toggle source

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

satisfies?(dependency) click to toggle source

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.

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

source_changed?() click to toggle source

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

to_lock() click to toggle source

    # File 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() click to toggle source

    # File bundler/lazy_specification.rb, line 196
    def to_s
      lock_name
    end

### Private Instance Methods

ruby_platform_materializes_to_ruby_platform?() click to toggle source

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

use_exact_resolved_specifications?() click to toggle source

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