Resolve for specific platforms

lib/bundler.rb

@@ -91,7 +91,7 @@ def setup(*groups)
       # Return if all groups are already loaded
       return @setup if defined?(@setup) && @setup
 
-      definition.validate_ruby!
+      definition.validate_runtime!
 
       SharedHelpers.print_major_deprecations!
 

lib/bundler/cli/binstubs.rb

@@ -10,7 +10,7 @@ def initialize(options, gems)
     end
 
     def run
-      Bundler.definition.validate_ruby!
+      Bundler.definition.validate_runtime!
       Bundler.settings[:bin] = options["path"] if options["path"]
       Bundler.settings[:bin] = nil if options["path"] && options["path"].empty?
       installer = Installer.new(Bundler.root, Bundler.definition)

lib/bundler/cli/cache.rb

@@ -7,7 +7,7 @@ def initialize(options)
     end
 
     def run
-      Bundler.definition.validate_ruby!
+      Bundler.definition.validate_runtime!
       Bundler.definition.resolve_with_cache!
       setup_cache_all
       Bundler.settings[:cache_all_platforms] = options["all-platforms"] if options.key?("all-platforms")

lib/bundler/cli/check.rb

@@ -15,7 +15,7 @@ def run
 
       begin
         definition = Bundler.definition
-        definition.validate_ruby!
+        definition.validate_runtime!
         not_installed = definition.missing_specs
       rescue GemNotFound, VersionConflict
         Bundler.ui.error "Bundler can't satisfy your Gemfile's dependencies."

lib/bundler/cli/install.rb

@@ -66,7 +66,7 @@ def run
       Plugin.gemfile_install(Bundler.default_gemfile) if Bundler.feature_flag.plugins?
 
       definition = Bundler.definition
-      definition.validate_ruby!
+      definition.validate_runtime!
 
       installer = Installer.install(Bundler.root, definition, options)
       Bundler.load.cache if Bundler.app_cache.exist? && !options["no-cache"] && !Bundler.settings[:frozen]

lib/bundler/cli/outdated.rb

@@ -18,7 +18,7 @@ def run
         Bundler::CLI::Common.select_spec(gem_name)
       end
 
-      Bundler.definition.validate_ruby!
+      Bundler.definition.validate_runtime!
       current_specs = Bundler.ui.silence { Bundler.load.specs }
       current_dependencies = {}
       Bundler.ui.silence { Bundler.load.dependencies.each {|dep| current_dependencies[dep.name] = dep } }

lib/bundler/cli/platform.rb

@@ -29,7 +29,7 @@ def run
           output << "Your Gemfile specifies a Ruby version requirement:\n* #{ruby_version}"
 
           begin
-            Bundler.definition.validate_ruby!
+            Bundler.definition.validate_runtime!
             output << "Your current platform satisfies the Ruby version requirement."
           rescue RubyVersionMismatch => e
             output << e.message

lib/bundler/cli/show.rb

@@ -13,7 +13,7 @@ def initialize(options, gem_name)
 
     def run
       Bundler.ui.silence do
-        Bundler.definition.validate_ruby!
+        Bundler.definition.validate_runtime!
         Bundler.load.lock
       end
 

lib/bundler/cli/update.rb

@@ -57,7 +57,7 @@ def run
       # rubygems plugins sometimes hook into the gem install process
       Gem.load_env_plugins if Gem.respond_to?(:load_env_plugins)
 
-      Bundler.definition.validate_ruby!
+      Bundler.definition.validate_runtime!
       Installer.install Bundler.root, Bundler.definition, opts
       Bundler.load.cache if Bundler.app_cache.exist?
 

lib/bundler/definition.rb

@@ -70,7 +70,8 @@ def initialize(lockfile, dependencies, sources, unlock, ruby_version = nil, opti
       if lockfile && File.exist?(lockfile)
         @lockfile_contents = Bundler.read_file(lockfile)
         @locked_gems = LockfileParser.new(@lockfile_contents)
-        @platforms = @locked_gems.platforms
+        @locked_platforms = @locked_gems.platforms
+        @platforms = @locked_platforms.dup
         @locked_bundler_version = @locked_gems.bundler_version
         @locked_ruby_version = @locked_gems.ruby_version
 
@@ -91,6 +92,7 @@ def initialize(lockfile, dependencies, sources, unlock, ruby_version = nil, opti
         @locked_deps    = []
         @locked_specs   = SpecSet.new([])
         @locked_sources = []
+        @locked_platforms = []
       end
 
       @unlock[:gems] ||= []
@@ -102,8 +104,7 @@ def initialize(lockfile, dependencies, sources, unlock, ruby_version = nil, opti
 
       @gem_version_promoter = create_gem_version_promoter
 
-      current_platform = Bundler.rubygems.platforms.map {|p| generic(p) }.compact.last
-      add_platform(current_platform)
+      add_current_platform unless Bundler.settings[:frozen]
 
       @path_changes = converge_paths
       eager_unlock = expand_dependencies(@unlock[:gems])
@@ -414,6 +415,11 @@ def ensure_equivalent_gemfile_and_lockfile(explicit_flag = false)
       deleted = []
       changed = []
 
+      new_platforms = @platforms - @locked_platforms
+      deleted_platforms = @locked_platforms - @platforms
+      added.concat new_platforms.map {|p| "* platform: #{p}" }
+      deleted.concat deleted_platforms.map {|p| "* platform: #{p}" }
+
       gemfile_sources = sources.lock_sources
 
       new_sources = gemfile_sources - @locked_sources
@@ -462,6 +468,11 @@ def ensure_equivalent_gemfile_and_lockfile(explicit_flag = false)
       raise ProductionError, msg if added.any? || deleted.any? || changed.any?
     end
 
+    def validate_runtime!
+      validate_ruby!
+      validate_platforms!
+    end
+
     def validate_ruby!
       return unless ruby_version
 
@@ -487,6 +498,22 @@ def validate_ruby!
       end
     end
 
+    # TODO: refactor this so that `match_platform` can be called with two platforms
+    DummyPlatform = Struct.new(:platform)
+    class DummyPlatform; include MatchPlatform; end
+    def validate_platforms!
+      return if @platforms.any? do |bundle_platform|
+        bundle_platform = DummyPlatform.new(bundle_platform)
+        Bundler.rubygems.platforms.any? do |local_platform|
+          bundle_platform.match_platform(local_platform)
+        end
+      end
+
+      raise ProductionError, "Your bundle only supports platforms #{@platforms.map(&:to_s)} " \
+        "but your local platforms are #{Bundler.rubygems.platforms.map(&:to_s)}, and " \
+        "there's no compatible match between those two lists."
+    end
+
     def add_platform(platform)
       @new_platform ||= [email protected]?(platform)
       @platforms |= [platform]
@@ -497,6 +524,12 @@ def remove_platform(platform)
       raise InvalidOption, "Unable to remove the platform `#{platform}` since the only platforms are #{@platforms.join ", "}"
     end
 
+    def add_current_platform
+      current_platform = Bundler.rubygems.platforms.last
+      add_platform(current_platform) if Bundler.settings[:specific_platform]
+      add_platform(generic(current_platform))
+    end
+
     attr_reader :sources
     private :sources
 

lib/bundler/dependency.rb

@@ -52,7 +52,7 @@ class Dependency < Gem::Dependency
       :x64_mingw_20 => Gem::Platform::X64_MINGW,
       :x64_mingw_21 => Gem::Platform::X64_MINGW,
       :x64_mingw_22 => Gem::Platform::X64_MINGW,
-      :x64_mingw_23 => Gem::Platform::X64_MINGW
+      :x64_mingw_23 => Gem::Platform::X64_MINGW,
     }.freeze
 
     REVERSE_PLATFORM_MAP = {}.tap do |reverse_platform_map|

lib/bundler/gem_helpers.rb

@@ -28,5 +28,73 @@ def generic_local_platform
       generic(Gem::Platform.local)
     end
     module_function :generic_local_platform
+
+    def platform_specificity_match(spec_platform, user_platform)
+      spec_platform = Gem::Platform.new(spec_platform)
+      return PlatformMatch::EXACT_MATCH if spec_platform == user_platform
+      return PlatformMatch::WORST_MATCH if spec_platform.nil? || spec_platform == Gem::Platform::RUBY || user_platform == Gem::Platform::RUBY
+
+      PlatformMatch.new(
+        PlatformMatch.os_match(spec_platform, user_platform),
+        PlatformMatch.cpu_match(spec_platform, user_platform),
+        PlatformMatch.platform_version_match(spec_platform, user_platform)
+      )
+    end
+    module_function :platform_specificity_match
+
+    def select_best_platform_match(specs, platform)
+      specs.select {|spec| spec.match_platform(platform) }.
+        min_by {|spec| platform_specificity_match(spec.platform, platform) }
+    end
+    module_function :select_best_platform_match
+
+    PlatformMatch = Struct.new(:os_match, :cpu_match, :platform_version_match)
+    class PlatformMatch
+      def <=>(other)
+        return nil unless other.is_a?(PlatformMatch)
+
+        m = os_match <=> other.os_match
+        return m unless m.zero?
+
+        m = cpu_match <=> other.cpu_match
+        return m unless m.zero?
+
+        m = platform_version_match <=> other.platform_version_match
+        m
+      end
+
+      EXACT_MATCH = new(-1, -1, -1).freeze
+      WORST_MATCH = new(1_000_000, 1_000_000, 1_000_000).freeze
+
+      def self.os_match(spec_platform, user_platform)
+        if spec_platform.os == user_platform.os
+          0
+        else
+          1
+        end
+      end
+
+      def self.cpu_match(spec_platform, user_platform)
+        if spec_platform.cpu == user_platform.cpu
+          0
+        elsif spec_platform.cpu == "arm" && user_platform.cpu.to_s.start_with?("arm")
+          0
+        elsif spec_platform.cpu.nil? || spec_platform.cpu == "universal"
+          1
+        else
+          2
+        end
+      end
+
+      def self.platform_version_match(spec_platform, user_platform)
+        if spec_platform.version == user_platform.version
+          0
+        elsif spec_platform.version.nil?
+          1
+        else
+          2
+        end
+      end
+    end
   end
 end

lib/bundler/inline.rb

@@ -47,7 +47,7 @@ def Bundler.root
 
   definition = builder.to_definition(nil, true)
   def definition.lock(*); end
-  definition.validate_ruby!
+  definition.validate_runtime!
 
   missing_specs = proc do
     begin

lib/bundler/lazy_specification.rb

@@ -6,6 +6,20 @@
 module Bundler
   class LazySpecification
     Identifier = Struct.new(:name, :version, :source, :platform, :dependencies)
+    class Identifier
+      include Comparable
+      def <=>(other)
+        return unless other.is_a?(Identifier)
+        [name, version, platform_string] <=> [other.name, other.version, other.platform_string]
+      end
+
+    protected
+
+      def platform_string
+        platform_string = platform.to_s
+        platform_string == Index::RUBY ? Index::NULL : platform_string
+      end
+    end
 
     include MatchPlatform
 
@@ -55,7 +69,8 @@ def to_lock
     end
 
     def __materialize__
-      @specification = source.specs.search(Gem::Dependency.new(name, version)).last
+      search_object = Bundler.settings[:specific_platform] ? self : Dependency.new(name, version)
+      @specification = source.specs.search(search_object).last
     end
 
     def respond_to?(*args)

lib/bundler/lockfile_parser.rb

@@ -92,7 +92,7 @@ def initialize(lockfile)
         end
       end
       @sources << @rubygems_aggregate
-      @specs = @specs.values
+      @specs = @specs.values.sort_by(&:identifier)
       warn_for_outdated_bundler_version
     rescue ArgumentError => e
       Bundler.ui.debug(e)

lib/bundler/match_platform.rb

@@ -8,7 +8,8 @@ module MatchPlatform
     def match_platform(p)
       Gem::Platform::RUBY == platform ||
         platform.nil? || p == platform ||
-        generic(Gem::Platform.new(platform)) === p
+        generic(Gem::Platform.new(platform)) === p ||
+        Gem::Platform.new(platform) === p
     end
   end
 end

lib/bundler/plugin.rb

@@ -62,7 +62,9 @@ def gemfile_install(gemfile = nil, &inline)
 
       save_plugins plugins, installed_specs, builder.inferred_plugins
     rescue => e
-      Bundler.ui.error "Failed to install plugin: #{e.message}\n  #{e.backtrace[0]}"
+      unless e.is_a?(GemfileError)
+        Bundler.ui.error "Failed to install plugin: #{e.message}\n  #{e.backtrace[0]}"
+      end
       raise
     end
 

lib/bundler/resolver.rb

@@ -66,44 +66,33 @@ def message
       end
     end
 
-    ALL = Bundler::Dependency::PLATFORM_MAP.values.uniq.freeze
-
     class SpecGroup < Array
       include GemHelpers
 
-      attr_reader :activated, :required_by
+      attr_reader :activated
 
       def initialize(a)
         super
         @required_by = []
         @activated_platforms = []
         @dependencies = nil
-        @specs        = {}
-
-        ALL.each do |p|
-          @specs[p] = reverse.find {|s| s.match_platform(p) }
+        @specs        = Hash.new do |specs, platform|
+          specs[platform] = select_best_platform_match(self, platform)
         end
       end
 
       def initialize_copy(o)
         super
-        @required_by = o.required_by.dup
         @activated_platforms = o.activated.dup
       end
 
       def to_specs
-        specs = {}
-
-        @activated_platforms.each do |p|
+        @activated_platforms.map do |p|
           next unless s = @specs[p]
-          platform = generic(Gem::Platform.new(s.platform))
-          next if specs[platform]
-
-          lazy_spec = LazySpecification.new(name, version, platform, source)
+          lazy_spec = LazySpecification.new(name, version, s.platform, source)
           lazy_spec.dependencies.replace s.dependencies
-          specs[platform] = lazy_spec
-        end
-        specs.values
+          lazy_spec
+        end.compact
       end
 
       def activate_platform!(platform)
@@ -148,17 +137,15 @@ def platforms_for_dependency_named(dependency)
     private
 
       def __dependencies
-        @dependencies ||= begin
-          dependencies = {}
-          ALL.each do |p|
-            next unless spec = @specs[p]
-            dependencies[p] = []
+        @dependencies = Hash.new do |dependencies, platform|
+          dependencies[platform] = []
+          if spec = @specs[platform]
             spec.dependencies.each do |dep|
               next if dep.type == :development
-              dependencies[p] << DepProxy.new(dep, p)
+              dependencies[platform] << DepProxy.new(dep, platform)
             end
           end
-          dependencies
+          dependencies[platform]
         end
       end