autoload :FeatureFlag, File.expand_path("bundler/feature_flag", __dir__)

autoload :FREEBSD, File.expand_path("bundler/constants", __dir__)

autoload :GemHelper, File.expand_path("bundler/gem_helper", __dir__)

autoload :GemVersionPromoter, File.expand_path("bundler/gem_version_promoter", __dir__)

autoload :Graph, File.expand_path("bundler/graph", __dir__)

autoload :Index, File.expand_path("bundler/index", __dir__)

Gem::Platform.local

end

def default_gemfile

SharedHelpers.default_gemfile

end

return active_spec if strict

if !current_spec.version.prerelease? && !options[:pre] && active_specs.size > 1

active_specs.delete_if {|b| b.respond_to?(:version) && b.version.prerelease? }

end

locked_spec = locked_info[:spec]

new_spec = Bundler.definition.specs[name].first

unless new_spec

Bundler.ui.warn "Bundler attempted to update #{name} but it was not considered because it is for a different platform from the current one"

end

end.freeze

def ruby?

!windows? && (RUBY_ENGINE == "ruby" || RUBY_ENGINE == "rbx" || RUBY_ENGINE == "maglev" || RUBY_ENGINE == "truffleruby")

end

module Bundler

class Definition

class << self

# Do not create or modify a lockfile (Makes #lock a noop)

attr_accessor :no_lock

end

def filter_relevant(dependencies)

dependencies.select do |d|

d.should_include? && !d.gem_platforms(platforms_array).empty?

end

return if current_platform_locked? || @platforms.include?(Gem::Platform::RUBY)

raise ProductionError, "Your bundle only supports platforms #{@platforms.map(&:to_s)} " \

end

def normalize_platforms

end

def should_add_extra_platforms?

end

def lockfile_exists?

@resolution_base ||= begin

last_resolve = converge_locked_specs

remove_invalid_platforms!

base = Resolver::Base.new(source_requirements, expanded_dependencies, last_resolve, @platforms, locked_specs: @originally_locked_specs, unlock: @unlocking_all || @gems_to_unlock, prerelease: gem_version_promoter.pre?, prefer_local: @prefer_local, new_platforms: new_resolution_platforms)

base = additional_base_requirements_to_prevent_downgrades(base)

base = additional_base_requirements_to_force_updates(base)

end

def start_resolution

add_platform(Gem::Platform::RUBY) if RUBY_ENGINE == "truffleruby"

result = SpecSet.new(resolver.start)

if result.incomplete_for_platform?(current_dependencies, @most_specific_non_local_locked_platform)

@platforms.delete(@most_specific_non_local_locked_platform)

elsif local_platform_needed_for_resolvability

end

end

def current_platform_locked?

@platforms.any? do |bundle_platform|

end

end

def add_current_platform

@most_specific_non_local_locked_platform = find_most_specific_locked_platform

return if @most_specific_non_local_locked_platform

true

end

def remove_invalid_platforms!

return if Bundler.frozen_bundle?

# We should probably avoid removing non-ruby platforms, since that means

# lockfile will no longer install on those platforms, so a error to give

return RUBY_PLATFORM_ARRAY if force_ruby_platform

return valid_platforms if platforms.empty?

end

def expanded_platforms

case specs_by_name_and_version.size

when 1

specs = specs_by_name_and_version.values.first

@gemspecs << spec

end

else

materialize([name, version]) do |matching_specs|

specification = choose_compatible(installable_candidates, fallback_to_non_installable: false)

return specification unless specification.nil?

if target_platform != platform

end

choose_compatible(installable_candidates)

end

def ruby_platform_materializes_to_ruby_platform?

(most_specific_locked_platform != generic_platform) || force_ruby_platform || Bundler.settings[:force_ruby_platform]

end

module Bundler

class LockfileParser

class Position

attr_reader :line, :column

def initialize(line, column)

end

@most_specific_locked_platform = @platforms.min_by do |bundle_platform|

end

@specs = @specs.values.sort_by!(&:full_name).each do |spec|

spec.most_specific_locked_platform = @most_specific_locked_platform

# frozen_string_literal: true

module Bundler

module MatchPlatform

end

end

end

end

@specs ||= if @candidates.nil?

[]

elsif platform

else

end

end

require_relative "resolver/root"

require_relative "resolver/strategy"

def initialize(base, gem_version_promoter, most_specific_locked_platform = nil)

@source_requirements = base.source_requirements

@base = base

next groups if platform_specs.all?(&:empty?)

end

ruby_group = Resolver::SpecGroup.new(ruby_specs)

unless ruby_group.empty?

def platform_specs(specs)

platforms.map do |platform|

prefer_locked = @new_platforms.include?(platform) ? false : !unlock?

end

end

require "rubygems/platform"

class Platform

end

require "rubygems/specification"

require_relative "match_platform"

include ::Bundler::MatchMetadata

attr_accessor :remote, :relative_loaded_from

@ignored = missing_extensions?

end

end

end

require "rubygems/name_tuple"

new_platforms = all_platforms.select do |platform|

next if platforms.include?(platform)

complete_platform(platform)

end

end

def find_by_name_and_platform(name, platform)

end

def specs_with_additional_variants_from(other)

valid_platform = lookup.all? do |_, specs|

spec = specs.first

matching_specs = spec.source.specs.search([spec.name, spec.version])

valid?(s)

end

raise NotImplementedError

end

def raw_require_paths # :nodoc:

raise NotImplementedError

end

# This will be replaced with Gem::Platform::local.

CURRENT = "current"

end