bundler 1.17.3 → 2.6.3

data/lib/bundler/resolver/package.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Bundler
+  class Resolver
+    #
+    # Represents a gem being resolved, in a format PubGrub likes.
+    #
+    # The class holds the following information:
+    #
+    # * Platforms this gem will be resolved on.
+    # * The locked version of this gem resolution should favor (if any).
+    # * Whether the gem should be unlocked to its latest version.
+    # * The dependency explicit set in the Gemfile for this gem (if any).
+    #
+    class Package
+      attr_reader :name, :platforms, :dependency, :locked_version
+
+      def initialize(name, platforms, locked_specs:, unlock:, prerelease: false, prefer_local: false, dependency: nil)
+        @name = name
+        @platforms = platforms
+        @locked_version = locked_specs.version_for(name)
+        @unlock = unlock
+        @dependency = dependency || Dependency.new(name, @locked_version)
+        @top_level = !dependency.nil?
+        @prerelease = @dependency.prerelease? || @locked_version&.prerelease? || prerelease ? :consider_first : :ignore
+        @prefer_local = prefer_local
+      end
+
+      def platform_specs(specs)
+        platforms.map {|platform| GemHelpers.select_best_platform_match(specs, platform, prefer_locked: !unlock?) }
+      end
+
+      def to_s
+        @name.delete("\0")
+      end
+
+      def root?
+        false
+      end
+
+      def top_level?
+        @top_level
+      end
+
+      def meta?
+        @name.end_with?("\0")
+      end
+
+      def ==(other)
+        self.class == other.class && @name == other.name
+      end
+
+      def hash
+        @name.hash
+      end
+
+      def unlock?
+        @unlock.empty? || @unlock.include?(name)
+      end
+
+      def ignores_prereleases?
+        @prerelease == :ignore
+      end
+
+      def prerelease_specified?
+        @prerelease == :consider_first
+      end
+
+      def consider_prereleases!
+        @prerelease = :consider_last
+      end
+
+      def prefer_local?
+        @prefer_local
+      end
+
+      def consider_remote_versions!
+        @prefer_local = false
+      end
+
+      def force_ruby_platform?
+        @dependency.force_ruby_platform
+      end
+
+      def current_platform?
+        @dependency.current_platform?
+      end
+    end
+  end
+end

data/lib/bundler/resolver/root.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "package"
+
+module Bundler
+  class Resolver
+    #
+    # Represents the Gemfile from the resolver's perspective. It's the root
+    # package and Gemfile entries depend on it.
+    #
+    class Root < Package
+      def initialize(name)
+        @name = name
+      end
+
+      def meta?
+        true
+      end
+
+      def root?
+        true
+      end
+    end
+  end
+end

data/lib/bundler/resolver/spec_group.rb

@@ -3,104 +3,96 @@
 module Bundler
   class Resolver
     class SpecGroup
-      include GemHelpers
+      attr_reader :specs
 
-      attr_accessor :name, :version, :source
-      attr_accessor :ignores_bundler_dependencies
+      def initialize(specs)
+        @specs = specs
+      end
 
-      def initialize(all_specs)
-        raise ArgumentError, "cannot initialize with an empty value" unless exemplary_spec = all_specs.first
-        @name = exemplary_spec.name
-        @version = exemplary_spec.version
-        @source = exemplary_spec.source
+      def empty?
+        @specs.empty?
+      end
 
-        @activated_platforms = []
-        @dependencies = nil
-        @specs        = Hash.new do |specs, platform|
-          specs[platform] = select_best_platform_match(all_specs, platform)
-        end
-        @ignores_bundler_dependencies = true
+      def name
+        @name ||= exemplary_spec.name
       end
 
-      def to_specs
-        @activated_platforms.map do |p|
-          next unless s = @specs[p]
-          lazy_spec = LazySpecification.new(name, version, s.platform, source)
-          lazy_spec.dependencies.replace s.dependencies
-          lazy_spec
-        end.compact
+      def version
+        @version ||= exemplary_spec.version
       end
 
-      def activate_platform!(platform)
-        return unless for?(platform)
-        return if @activated_platforms.include?(platform)
-        @activated_platforms << platform
+      def source
+        @source ||= exemplary_spec.source
       end
 
-      def for?(platform)
-        spec = @specs[platform]
-        !spec.nil?
+      def to_specs(force_ruby_platform, most_specific_locked_platform)
+        @specs.map do |s|
+          lazy_spec = LazySpecification.from_spec(s)
+          lazy_spec.force_ruby_platform = force_ruby_platform
+          lazy_spec.most_specific_locked_platform = most_specific_locked_platform
+          lazy_spec
+        end
       end
 
       def to_s
-        @to_s ||= "#{name} (#{version})"
+        sorted_spec_names.join(", ")
       end
 
-      def dependencies_for_activated_platforms
-        dependencies = @activated_platforms.map {|p| __dependencies[p] }
-        metadata_dependencies = @activated_platforms.map do |platform|
-          metadata_dependencies(@specs[platform], platform)
-        end
-        dependencies.concat(metadata_dependencies).flatten
+      def dependencies
+        @dependencies ||= @specs.flat_map do |spec|
+          __dependencies(spec) + metadata_dependencies(spec)
+        end.uniq.sort
       end
 
       def ==(other)
-        return unless other.is_a?(SpecGroup)
-        name == other.name &&
-          version == other.version &&
-          source == other.source
+        sorted_spec_names == other.sorted_spec_names
       end
 
-      def eql?(other)
-        name.eql?(other.name) &&
-          version.eql?(other.version) &&
-          source.eql?(other.source)
+      def merge(other)
+        return false unless equivalent?(other)
+
+        @specs |= other.specs
+
+        true
       end
 
-      def hash
-        to_s.hash ^ source.hash
+      protected
+
+      def sorted_spec_names
+        @specs.map(&:full_name).sort
       end
 
-    private
+      private
 
-      def __dependencies
-        @dependencies = Hash.new do |dependencies, platform|
-          dependencies[platform] = []
-          if spec = @specs[platform]
-            spec.dependencies.each do |dep|
-              next if dep.type == :development
-              next if @ignores_bundler_dependencies && dep.name == "bundler".freeze
-              dependencies[platform] << DepProxy.new(dep, platform)
-            end
-          end
-          dependencies[platform]
-        end
+      def equivalent?(other)
+        name == other.name && version == other.version && source == other.source && dependencies == other.dependencies
+      end
+
+      def exemplary_spec
+        @specs.first
       end
 
-      def metadata_dependencies(spec, platform)
-        return [] unless spec
-        # Only allow endpoint specifications since they won't hit the network to
-        # fetch the full gemspec when calling required_ruby_version
-        return [] if !spec.is_a?(EndpointSpecification) && !spec.is_a?(Gem::Specification)
+      def __dependencies(spec)
         dependencies = []
-        if !spec.required_ruby_version.nil? && !spec.required_ruby_version.none?
-          dependencies << DepProxy.new(Gem::Dependency.new("ruby\0", spec.required_ruby_version), platform)
-        end
-        if !spec.required_rubygems_version.nil? && !spec.required_rubygems_version.none?
-          dependencies << DepProxy.new(Gem::Dependency.new("rubygems\0", spec.required_rubygems_version), platform)
+        spec.dependencies.each do |dep|
+          next if dep.type == :development
+          dependencies << Dependency.new(dep.name, dep.requirement)
         end
         dependencies
       end
+
+      def metadata_dependencies(spec)
+        [
+          metadata_dependency("Ruby", spec.required_ruby_version),
+          metadata_dependency("RubyGems", spec.required_rubygems_version),
+        ].compact
+      end
+
+      def metadata_dependency(name, requirement)
+        return if requirement.nil? || requirement.none?
+
+        Dependency.new("#{name}\0", requirement)
+      end
     end
   end
 end