bundler 2.2.29 → 2.5.16

data/lib/bundler/resolver/spec_group.rb

@@ -3,107 +3,94 @@
 module Bundler
   class Resolver
     class SpecGroup
-      attr_accessor :name, :version, :source
-      attr_accessor :activated_platforms
+      attr_reader :specs
 
-      def self.create_for(specs, all_platforms, specific_platform)
-        specific_platform_specs = specs[specific_platform]
-        return unless specific_platform_specs.any?
-
-        platforms = all_platforms.select {|p| specs[p].any? }
+      def initialize(specs)
+        @specs = specs
+      end
 
-        new(specific_platform_specs.first, specs, platforms)
+      def empty?
+        @specs.empty?
       end
 
-      def initialize(exemplary_spec, specs, relevant_platforms)
-        @exemplary_spec = exemplary_spec
-        @name = exemplary_spec.name
-        @version = exemplary_spec.version
-        @source = exemplary_spec.source
+      def name
+        @name ||= exemplary_spec.name
+      end
 
-        @activated_platforms = relevant_platforms
-        @dependencies = Hash.new do |dependencies, platforms|
-          dependencies[platforms] = dependencies_for(platforms)
-        end
-        @specs = specs
+      def version
+        @version ||= exemplary_spec.version
       end
 
-      def to_specs
-        activated_platforms.map do |p|
-          specs = @specs[p]
-          next unless specs.any?
+      def source
+        @source ||= exemplary_spec.source
+      end
 
-          specs.map do |s|
-            lazy_spec = LazySpecification.new(name, version, s.platform, source)
-            lazy_spec.dependencies.replace s.dependencies
-            lazy_spec
-          end
-        end.flatten.compact.uniq
+      def to_specs(force_ruby_platform)
+        @specs.map do |s|
+          lazy_spec = LazySpecification.from_spec(s)
+          lazy_spec.force_ruby_platform = force_ruby_platform
+          lazy_spec
+        end
       end
 
       def to_s
-        activated_platforms_string = sorted_activated_platforms.join(", ")
-        "#{name} (#{version}) (#{activated_platforms_string})"
+        sorted_spec_names.join(", ")
       end
 
-      def dependencies_for_activated_platforms
-        @dependencies[activated_platforms]
+      def dependencies
+        @dependencies ||= @specs.map do |spec|
+          __dependencies(spec) + metadata_dependencies(spec)
+        end.flatten.uniq.sort
       end
 
       def ==(other)
-        return unless other.is_a?(SpecGroup)
-        name == other.name &&
-          version == other.version &&
-          sorted_activated_platforms == other.sorted_activated_platforms &&
-          source == other.source
+        sorted_spec_names == other.sorted_spec_names
       end
 
-      def eql?(other)
-        return unless other.is_a?(SpecGroup)
-        name.eql?(other.name) &&
-          version.eql?(other.version) &&
-          sorted_activated_platforms.eql?(other.sorted_activated_platforms) &&
-          source.eql?(other.source)
-      end
+      def merge(other)
+        return false unless equivalent?(other)
+
+        @specs |= other.specs
 
-      def hash
-        name.hash ^ version.hash ^ sorted_activated_platforms.hash ^ source.hash
+        true
       end
 
       protected
 
-      def sorted_activated_platforms
-        activated_platforms.sort_by(&:to_s)
+      def sorted_spec_names
+        @specs.map(&:full_name).sort
       end
 
       private
 
-      def dependencies_for(platforms)
-        platforms.map do |platform|
-          __dependencies(platform) + metadata_dependencies(platform)
-        end.flatten
+      def equivalent?(other)
+        name == other.name && version == other.version && source == other.source && dependencies == other.dependencies
       end
 
-      def __dependencies(platform)
+      def exemplary_spec
+        @specs.first
+      end
+
+      def __dependencies(spec)
         dependencies = []
-        @specs[platform].first.dependencies.each do |dep|
+        spec.dependencies.each do |dep|
           next if dep.type == :development
-          dependencies << DepProxy.get_proxy(dep, platform)
+          dependencies << Dependency.new(dep.name, dep.requirement)
         end
         dependencies
       end
 
-      def metadata_dependencies(platform)
-        spec = @specs[platform].first
-        return [] unless spec.is_a?(Gem::Specification)
-        dependencies = []
-        if !spec.required_ruby_version.nil? && !spec.required_ruby_version.none?
-          dependencies << DepProxy.get_proxy(Gem::Dependency.new("Ruby\0", spec.required_ruby_version), platform)
-        end
-        if !spec.required_rubygems_version.nil? && !spec.required_rubygems_version.none?
-          dependencies << DepProxy.get_proxy(Gem::Dependency.new("RubyGems\0", spec.required_rubygems_version), platform)
-        end
-        dependencies
+      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