Merge pull request #5700 from rubygems/linux-by-default

Make lockfiles generated on macOS include a lock for Linux by default

Author: deivid-rodriguez

bundler/lib/bundler/current_ruby.rb

@@ -43,7 +43,7 @@ class CurrentRuby
     ].freeze
 
     def ruby?
-      return true if Bundler::GemHelpers.generic_local_platform == Gem::Platform::RUBY
+      return true if Bundler::GemHelpers.generic_local_platform_is_ruby?
 
       !windows? && (RUBY_ENGINE == "ruby" || RUBY_ENGINE == "rbx" || RUBY_ENGINE == "maglev" || RUBY_ENGINE == "truffleruby")
     end

bundler/lib/bundler/definition.rb

@@ -84,7 +84,7 @@ def initialize(lockfile, dependencies, sources, unlock, ruby_version = nil, opti
       @new_platform = nil
       @removed_platform = nil
 
-      if lockfile && File.exist?(lockfile)
+      if lockfile_exists?
         @lockfile_contents = Bundler.read_file(lockfile)
         @locked_gems = LockfileParser.new(@lockfile_contents)
         @locked_platforms = @locked_gems.platforms
@@ -302,6 +302,10 @@ def resolve
       end
     end
 
+    def should_complete_platforms?
+      !lockfile_exists? && generic_local_platform_is_ruby? && !Bundler.settings[:force_ruby_platform]
+    end
+
     def spec_git_paths
       sources.git_sources.map {|s| File.realpath(s.path) if File.exist?(s.path) }.compact
     end
@@ -491,6 +495,10 @@ def unlocking?
 
     private
 
+    def lockfile_exists?
+      lockfile && File.exist?(lockfile)
+    end
+
     def resolver
       @resolver ||= Resolver.new(resolution_packages, gem_version_promoter)
     end
@@ -567,11 +575,12 @@ def materialize(dependencies)
     end
 
     def start_resolution
-      result = resolver.start
+      result = SpecSet.new(resolver.start)
 
       @resolved_bundler_version = result.find {|spec| spec.name == "bundler" }&.version
+      @platforms = result.complete_platforms!(platforms) if should_complete_platforms?
 
-      SpecSet.new(SpecSet.new(result).for(dependencies, false, @platforms))
+      SpecSet.new(result.for(dependencies, false, @platforms))
     end
 
     def precompute_source_requirements_for_indirect_dependencies?
@@ -592,7 +601,7 @@ def pin_locally_available_names(source_requirements)
     end
 
     def current_ruby_platform_locked?
-      return false unless generic_local_platform == Gem::Platform::RUBY
+      return false unless generic_local_platform_is_ruby?
       return false if Bundler.settings[:force_ruby_platform] && !@platforms.include?(Gem::Platform::RUBY)
 
       current_platform_locked?

bundler/lib/bundler/gem_helpers.rb

@@ -34,6 +34,11 @@ def local_platform
     end
     module_function :local_platform
 
+    def generic_local_platform_is_ruby?
+      generic_local_platform == Gem::Platform::RUBY
+    end
+    module_function :generic_local_platform_is_ruby?
+
     def platform_specificity_match(spec_platform, user_platform)
       spec_platform = Gem::Platform.new(spec_platform)
 
@@ -114,8 +119,6 @@ def same_specificity(platform, spec, exemplary_spec)
 
     def same_deps(spec, exemplary_spec)
       same_runtime_deps = spec.dependencies.sort == exemplary_spec.dependencies.sort
-      return same_runtime_deps unless spec.is_a?(Gem::Specification) && exemplary_spec.is_a?(Gem::Specification)
-
       same_metadata_deps = spec.required_ruby_version == exemplary_spec.required_ruby_version && spec.required_rubygems_version == exemplary_spec.required_rubygems_version
       same_runtime_deps && same_metadata_deps
     end

bundler/lib/bundler/lazy_specification.rb

@@ -7,13 +7,23 @@ class LazySpecification
     include MatchPlatform
     include ForcePlatform
 
-    attr_reader :name, :version, :dependencies, :platform
-    attr_accessor :source, :remote, :force_ruby_platform
+    attr_reader :name, :version, :platform
+    attr_accessor :source, :remote, :force_ruby_platform, :dependencies, :required_ruby_version, :required_rubygems_version
+
+    def self.from_spec(s)
+      lazy_spec = new(s.name, s.version, s.platform, s.source)
+      lazy_spec.dependencies = s.dependencies
+      lazy_spec.required_ruby_version = s.required_ruby_version
+      lazy_spec.required_rubygems_version = s.required_rubygems_version
+      lazy_spec
+    end
 
     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
       @source        = source
       @force_ruby_platform = default_force_ruby_platform

bundler/lib/bundler/lockfile_parser.rb

@@ -251,8 +251,7 @@ def parse_spec(line)
 
         version = Gem::Version.new(version)
         platform = platform ? Gem::Platform.new(platform) : Gem::Platform::RUBY
-        @current_spec = LazySpecification.new(name, version, platform)
-        @current_spec.source = @current_source
+        @current_spec = LazySpecification.new(name, version, platform, @current_source)
         @current_source.add_dependency_names(name)
 
         @specs[@current_spec.full_name] = @current_spec

bundler/lib/bundler/resolver/spec_group.rb

@@ -25,9 +25,8 @@ def source
 
       def to_specs(force_ruby_platform)
         @specs.map do |s|
-          lazy_spec = LazySpecification.new(name, version, s.platform, source)
+          lazy_spec = LazySpecification.from_spec(s)
           lazy_spec.force_ruby_platform = force_ruby_platform
-          lazy_spec.dependencies.replace s.dependencies
           lazy_spec
         end
       end
@@ -64,8 +63,6 @@ def __dependencies(spec)
       end
 
       def metadata_dependencies(spec)
-        return [] if spec.is_a?(LazySpecification)
-
         [
           metadata_dependency("Ruby", spec.required_ruby_version),
           metadata_dependency("RubyGems", spec.required_rubygems_version),

bundler/lib/bundler/spec_set.rb

@@ -52,6 +52,44 @@ def for(dependencies, check = false, platforms = [nil])
       specs.uniq
     end
 
+    def complete_platforms!(platforms)
+      return platforms.concat([Gem::Platform::RUBY]).uniq if @specs.empty?
+
+      new_platforms = @specs.flat_map {|spec| spec.source.specs.search([spec.name, spec.version]).map(&:platform) }.uniq.select do |platform|
+        next if platforms.include?(platform)
+        next unless GemHelpers.generic(platform) == Gem::Platform::RUBY
+
+        new_specs = []
+
+        valid_platform = lookup.all? do |_, specs|
+          spec = specs.first
+          matching_specs = spec.source.specs.search([spec.name, spec.version])
+          platform_spec = GemHelpers.select_best_platform_match(matching_specs, platform).first
+
+          if platform_spec
+            new_specs << LazySpecification.from_spec(platform_spec)
+            true
+          else
+            false
+          end
+        end
+        next unless valid_platform
+
+        @specs.concat(new_specs.uniq)
+      end
+      return platforms if new_platforms.empty?
+
+      platforms.concat(new_platforms)
+
+      less_specific_platform = new_platforms.find {|platform| platform != Gem::Platform::RUBY && platform === Bundler.local_platform }
+      platforms.delete(Bundler.local_platform) if less_specific_platform
+
+      @sorted = nil
+      @lookup = nil
+
+      platforms
+    end
+
     def [](key)
       key = key.name if key.respond_to?(:name)
       lookup[key].reverse
@@ -114,16 +152,6 @@ def missing_specs
       @specs.select {|s| s.is_a?(LazySpecification) }
     end
 
-    def merge(set)
-      arr = sorted.dup
-      set.each do |set_spec|
-        full_name = set_spec.full_name
-        next if arr.any? {|spec| spec.full_name == full_name }
-        arr << set_spec
-      end
-      SpecSet.new(arr)
-    end
-
     def -(other)
       SpecSet.new(to_a - other.to_a)
     end

bundler/spec/bundler/spec_set_spec.rb

@@ -45,24 +45,6 @@
     end
   end
 
-  describe "#merge" do
-    let(:other_specs) do
-      [
-        build_spec("f", "1.0"),
-        build_spec("g", "2.0"),
-      ].flatten
-    end
-
-    let(:other_spec_set) { described_class.new(other_specs) }
-
-    it "merges the items in each gemspec" do
-      new_spec_set = subject.merge(other_spec_set)
-      specs = new_spec_set.to_a.map(&:full_name)
-      expect(specs).to include("a-1.0")
-      expect(specs).to include("f-1.0")
-    end
-  end
-
   describe "#to_a" do
     it "returns the specs in order" do
       expect(subject.to_a.map(&:full_name)).to eq %w[

bundler/spec/commands/lock_spec.rb

@@ -449,7 +449,7 @@
 
     allow(Bundler::SharedHelpers).to receive(:find_gemfile).and_return(bundled_app_gemfile)
     lockfile = Bundler::LockfileParser.new(read_lockfile)
-    expect(lockfile.platforms).to match_array([java, x86_mingw32, local_platform].uniq)
+    expect(lockfile.platforms).to match_array(default_platform_list(java, x86_mingw32))
   end
 
   it "supports adding new platforms with force_ruby_platform = true" do
@@ -481,7 +481,7 @@
 
     allow(Bundler::SharedHelpers).to receive(:find_gemfile).and_return(bundled_app_gemfile)
     lockfile = Bundler::LockfileParser.new(read_lockfile)
-    expect(lockfile.platforms).to match_array(["ruby", local_platform].uniq)
+    expect(lockfile.platforms).to match_array(default_platform_list("ruby"))
   end
 
   it "warns when adding an unknown platform" do
@@ -494,12 +494,12 @@
 
     allow(Bundler::SharedHelpers).to receive(:find_gemfile).and_return(bundled_app_gemfile)
     lockfile = Bundler::LockfileParser.new(read_lockfile)
-    expect(lockfile.platforms).to match_array([java, x86_mingw32, local_platform].uniq)
+    expect(lockfile.platforms).to match_array(default_platform_list(java, x86_mingw32))
 
     bundle "lock --remove-platform java"
 
     lockfile = Bundler::LockfileParser.new(read_lockfile)
-    expect(lockfile.platforms).to match_array([x86_mingw32, local_platform].uniq)
+    expect(lockfile.platforms).to match_array(default_platform_list(x86_mingw32))
   end
 
   it "also cleans up redundant platform gems when removing platforms" do
@@ -733,7 +733,7 @@
       gem "libv8"
     G
 
-    simulate_platform(Gem::Platform.new("x86_64-darwin")) { bundle "lock" }
+    simulate_platform(Gem::Platform.new("x86_64-darwin-19")) { bundle "lock" }
 
     expect(lockfile).to eq <<~G
       GEM
@@ -743,7 +743,8 @@
           libv8 (8.4.255.0-x86_64-darwin-20)
 
       PLATFORMS
-        x86_64-darwin
+        x86_64-darwin-19
+        x86_64-darwin-20
 
       DEPENDENCIES
         libv8
@@ -1237,7 +1238,7 @@
             activemodel (>= 6.0.4)
 
       PLATFORMS
-        #{lockfile_platforms}
+        #{local_platform}
 
       DEPENDENCIES
         activeadmin (= 2.13.1)
@@ -1273,7 +1274,7 @@
             version solving has failed.
     ERR
 
-    lockfile lockfile.gsub(/PLATFORMS\n  #{lockfile_platforms}/m, "PLATFORMS\n  #{lockfile_platforms("ruby")}")
+    lockfile lockfile.gsub(/PLATFORMS\n  #{local_platform}/m, "PLATFORMS\n  #{lockfile_platforms("ruby")}")
 
     bundle "lock", :raise_on_error => false
 
@@ -1438,7 +1439,7 @@
             nokogiri (1.14.2)
 
         PLATFORMS
-          x86_64-linux
+          #{lockfile_platforms}
 
         DEPENDENCIES
           foo!

bundler/spec/commands/update_spec.rb

@@ -559,12 +559,36 @@
     before do
       build_repo2
 
-      install_gemfile <<-G
+      gemfile <<-G
         source "#{file_uri_for(gem_repo2)}"
         gem "activesupport"
         gem "rack-obama"
         gem "platform_specific"
       G
+
+      lockfile <<~L
+        GEM
+          remote: #{file_uri_for(gem_repo2)}/
+          specs:
+            activesupport (2.3.5)
+            platform_specific (1.0-#{local_platform})
+            rack (1.0.0)
+            rack-obama (1.0)
+              rack
+
+        PLATFORMS
+          #{local_platform}
+
+        DEPENDENCIES
+          activesupport
+          platform_specific
+          rack-obama
+
+        BUNDLED WITH
+           #{Bundler::VERSION}
+      L
+
+      bundle "install"
     end
 
     it "doesn't hit repo2" do