bundler-multilock 1.0.10 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f71e197447bdcd02b427ac7bc3a21a7e41e20a3d67edda69ed3821dea293e3ac
-  data.tar.gz: bf11ee91ace5dff77af3bc2b56ec283d2d227513e8d9397ce00e199ab73e3d83
+  metadata.gz: 12e431ea7783f9bc36d1efae8aaeda88434936f587c954c34ad4163b3338dc44
+  data.tar.gz: 8eda2e0bc8f785b0ceefb312d4d34c6fd754dab58c835ec7b818c551af903bdf
 SHA512:
-  metadata.gz: 4cad381cf2fbb7d441f98d39322d54a0496570ceb3e564669a39429072224b7cbbca1af2f68205bc1149e05dc7535ca75e3f51631795732c019354d92ce17952
-  data.tar.gz: 3ddb854fc272683a96711403a8f65fc4d588260c46e7753f71ca790192be19f8f9e7b9b7612457d99ea4596ab6830b8cf8eda5c0385621f0769949f41cb95c87
+  metadata.gz: 3fea018e198880d1c2a7dcaa635faa1ccff9b65d46bbb72c15cb153dd20acf34dfb833189bd1c4f3dd04f3053b23e2220ca769b101806e2b99a3ddc92097675c
+  data.tar.gz: 80095ec510ebefa11c457ef13c45bc0af40b6961b1ffff54c0724f5010cd72b6fa512f3de11155a6883db71dd6dc87322c6fbef314d5b7c61e99572e4fe77b43

data/lib/bundler/multilock/check.rb

@@ -5,6 +5,8 @@ require "set"
 module Bundler
   module Multilock
     class Check
+      attr_reader :lockfiles, :lockfile_contents, :lockfile_specs
+
       class << self
         def run
           new.run
@@ -12,23 +14,32 @@ module Bundler
       end
 
       def initialize
-        default_lockfile_contents = Bundler.default_lockfile.read
-        @default_lockfile = LockfileParser.new(default_lockfile_contents)
-        @default_specs = @default_lockfile.specs.to_h do |spec|
+        @lockfiles = {}
+        @lockfile_contents = {}
+        @lockfile_specs = {}
+      end
+
+      def load_lockfile(lockfile)
+        return if lockfile_contents.key?(lockfile)
+
+        contents = lockfile_contents[lockfile] = lockfile.read.freeze
+        parser = lockfiles[lockfile] = LockfileParser.new(contents)
+        lockfile_specs[lockfile] = parser.specs.to_h do |spec|
           [[spec.name, spec.platform], spec]
         end
       end
 
       def run(skip_base_checks: false)
-        return true unless Bundler.default_lockfile.exist?
+        return true unless Bundler.default_lockfile(force_original: true).exist?
 
         success = true
         unless skip_base_checks
-          missing_specs = base_check({ gemfile: Bundler.default_gemfile, lockfile: Bundler.default_lockfile },
+          missing_specs = base_check({ gemfile: Bundler.default_gemfile,
+                                       lockfile: Bundler.default_lockfile(force_original: true) },
                                      return_missing: true).to_set
         end
         Multilock.lockfile_definitions.each do |lockfile_definition|
-          next if lockfile_definition[:lockfile] == Bundler.default_lockfile
+          next if lockfile_definition[:lockfile] == Bundler.default_lockfile(force_original: true)
 
           unless lockfile_definition[:lockfile].exist?
             Bundler.ui.error("Lockfile #{lockfile_definition[:lockfile]} does not exist.")
@@ -77,7 +88,7 @@ module Bundler
         Multilock.prepare_block = nil
       end
 
-      # this checks for mismatches between the default lockfile and the given lockfile,
+      # this checks for mismatches between the parent lockfile and the given lockfile,
       # and for pinned dependencies in lockfiles requiring them
       def check(lockfile_definition, allow_mismatched_dependencies: true)
         success = true
@@ -85,13 +96,16 @@ module Bundler
         needs_pin_check = []
         lockfile = LockfileParser.new(lockfile_definition[:lockfile].read)
         lockfile_path = lockfile_definition[:lockfile].relative_path_from(Dir.pwd)
-        unless lockfile.platforms == @default_lockfile.platforms
-          Bundler.ui.error("The platforms in #{lockfile_path} do not match the default lockfile.")
+        parent = lockfile_definition[:parent]
+        load_lockfile(parent)
+        parent_lockfile = lockfiles[parent]
+        unless lockfile.platforms == parent_lockfile.platforms
+          Bundler.ui.error("The platforms in #{lockfile_path} do not match the parent lockfile.")
           success = false
         end
-        unless lockfile.bundler_version == @default_lockfile.bundler_version
+        unless lockfile.bundler_version == parent_lockfile.bundler_version
           Bundler.ui.error("bundler (#{lockfile.bundler_version}) in #{lockfile_path} " \
-                           "does not match the default lockfile's version (@#{@default_lockfile.bundler_version}).")
+                           "does not match the parent lockfile's version (@#{parent_lockfile.bundler_version}).")
           success = false
         end
 
@@ -100,13 +114,13 @@ module Bundler
           allow_mismatched_dependencies = lockfile_definition[:allow_mismatched_dependencies]
         end
 
-        # build list of top-level dependencies that differ from the default lockfile,
+        # build list of top-level dependencies that differ from the parent lockfile,
         # and all _their_ transitive dependencies
         if allow_mismatched_dependencies
           transitive_dependencies = Set.new
-          # only dependencies that differ from the default lockfile
+          # only dependencies that differ from the parent lockfile
           pending_transitive_dependencies = lockfile.dependencies.reject do |name, dep|
-            @default_lockfile.dependencies[name] == dep
+            parent_lockfile.dependencies[name] == dep
           end.map(&:first)
 
           until pending_transitive_dependencies.empty?
@@ -133,40 +147,40 @@ module Bundler
 
         # check for conflicting requirements (and build list of pins, in the same loop)
         specs.values.flatten.each do |spec|
-          default_spec = @default_specs[[spec.name, spec.platform]]
+          parent_spec = lockfile_specs[parent][[spec.name, spec.platform]]
 
           if lockfile_definition[:enforce_pinned_additional_dependencies]
             # look through what this spec depends on, and keep track of all pinned requirements
             find_pinned_dependencies(proven_pinned, spec.dependencies)
 
-            needs_pin_check << spec unless default_spec
+            needs_pin_check << spec unless parent_spec
           end
 
-          next unless default_spec
+          next unless parent_spec
 
           # have to ensure Path sources are relative to their lockfile before comparing
-          same_source = if [default_spec.source, spec.source].grep(Source::Path).length == 2
+          same_source = if [parent_spec.source, spec.source].grep(Source::Path).length == 2
                           lockfile_definition[:lockfile]
                             .dirname
                             .join(spec.source.path)
                             .ascend
-                            .any?(Bundler.default_lockfile.dirname.join(default_spec.source.path))
+                            .any?(parent.dirname.join(parent_spec.source.path))
                         else
-                          default_spec.source == spec.source
+                          parent_spec.source == spec.source
                         end
 
-          next if default_spec.version == spec.version && same_source
+          next if parent_spec.version == spec.version && same_source
           next if allow_mismatched_dependencies && transitive_dependencies.include?(spec.name)
 
           Bundler.ui.error("#{spec}#{spec.git_version} in #{lockfile_path} " \
-                           "does not match the default lockfile's version " \
-                           "(@#{default_spec.version}#{default_spec.git_version}); " \
+                           "does not match the parent lockfile's version " \
+                           "(@#{parent_spec.version}#{parent_spec.git_version}); " \
                            "this may be due to a conflicting requirement, which would require manual resolution.")
           success = false
         end
 
         # now that we have built a list of every gem that is pinned, go through
-        # the gems that were in this lockfile, but not the default lockfile, and
+        # the gems that were in this lockfile, but not the parent lockfile, and
         # ensure it's pinned _somehow_
         needs_pin_check.each do |spec|
           pinned = case spec.source
@@ -183,7 +197,7 @@ module Bundler
           next if pinned
 
           Bundler.ui.error("#{spec} in #{lockfile_path} has not been pinned to a specific version,  " \
-                           "which is required since it is not part of the default lockfile.")
+                           "which is required since it is not part of the parent lockfile.")
           success = false
         end
 

data/lib/bundler/multilock/ext/shared_helpers.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Bundler
+  module Multilock
+    module Ext
+      module SharedHeleprs
+        module ClassMethods
+          ::Bundler::SharedHelpers.singleton_class.prepend(self)
+          ::Bundler::SharedHelpers.instance_variable_set(:@filesystem_accesses, nil)
+
+          def capture_filesystem_access
+            @filesystem_accesses = []
+            yield
+            @filesystem_accesses
+          ensure
+            @filesystem_accesses = nil
+          end
+
+          def filesystem_access(path, action = :write)
+            @filesystem_accesses << [path, action] if @filesystem_accesses
+
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bundler/multilock/ext/source.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Bundler
+  module Multilock
+    module Ext
+      module Source
+        ::Bundler::Source.prepend(self)
+
+        def print_using_message(...)
+          return if Bundler.settings[:suppress_install_using_messages]
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/bundler/multilock/version.rb

@@ -2,6 +2,6 @@
 
 module Bundler
   module Multilock
-    VERSION = "1.0.10"
+    VERSION = "1.1.0"
   end
 end

data/lib/bundler/multilock.rb

@@ -5,6 +5,8 @@ require_relative "multilock/ext/definition"
 require_relative "multilock/ext/dsl"
 require_relative "multilock/ext/plugin"
 require_relative "multilock/ext/plugin/dsl"
+require_relative "multilock/ext/shared_helpers"
+require_relative "multilock/ext/source"
 require_relative "multilock/ext/source_list"
 require_relative "multilock/version"
 
@@ -20,8 +22,11 @@ module Bundler
       # @param builder [Dsl] The Bundler DSL
       # @param gemfile [String, nil]
       #   The Gemfile for this lockfile (defaults to Gemfile)
-      # @param default [Boolean]
+      # @param active [Boolean]
       #   If this lockfile should be the default (instead of Gemfile.lock)
+      #   BUNDLE_LOCKFILE will still override a lockfile tagged as active
+      # @param parent [String] The parent lockfile to sync dependencies from.
+      #   Also used for comparing enforce_pinned_additional_dependencies against.
       # @param allow_mismatched_dependencies [true, false]
       #   Allows version differences in dependencies between this lockfile and
       #   the default lockfile. Note that even with this option, only top-level
@@ -32,34 +37,30 @@ module Bundler
       #   default lockfile, enforce that they are pinned.
       # @yield
       #   Block executed only when this lockfile is active.
-      # @return [true, false] if the lockfile is the current lockfile
+      # @return [true, false] if the lockfile is the active lockfile
       def add_lockfile(lockfile = nil,
                        builder:,
                        gemfile: nil,
+                       active: nil,
                        default: nil,
+                       parent: nil,
                        allow_mismatched_dependencies: true,
                        enforce_pinned_additional_dependencies: false,
                        &block)
-        # terminology gets confusing here. The "default" param means
-        # "use this lockfile when not overridden by BUNDLE_LOCKFILE"
-        # but Bundler.defaul_lockfile (usually) means "Gemfile.lock"
-        # so refer to the former as "current" internally
-        current = default
-        current = true if current.nil? && lockfile_definitions.empty? && lockfile.nil? && gemfile.nil?
+        # backcompat
+        active = default if active.nil?
+        Bundler.ui.warn("lockfile(default:) is deprecated. Use lockfile(active:) instead.") if default
+
+        active = true if active.nil? && lockfile_definitions.empty? && lockfile.nil? && gemfile.nil?
 
-        # allow short-form lockfile names
-        if lockfile.is_a?(String) && !(lockfile.include?("/") || lockfile.end_with?(".lock"))
-          lockfile = "Gemfile.#{lockfile}.lock"
-        end
         # if a gemfile was provided, but not a lockfile, infer the default lockfile for that gemfile
         lockfile ||= "#{gemfile}.lock" if gemfile
-        # use absolute paths
-        lockfile = Bundler.root.join(lockfile).expand_path if lockfile
-        # use the default lockfile (Gemfile.lock) if none was given
-        lockfile ||= Bundler.default_lockfile(force_original: true)
-        raise ArgumentError, "Lockfile #{lockfile} is already defined" if lockfile_definitions.any? do |definition|
-                                                                            definition[:lockfile] == lockfile
-                                                                          end
+        # allow short-form lockfile names
+        lockfile = expand_lockfile(lockfile)
+
+        if lockfile_definitions.find { |definition|  definition[:lockfile] == lockfile }
+          raise ArgumentError, "Lockfile #{lockfile} is already defined"
+        end
 
         env_lockfile = ENV["BUNDLE_LOCKFILE"]
         if env_lockfile
@@ -67,18 +68,25 @@ module Bundler
             env_lockfile = "Gemfile.#{env_lockfile}.lock"
           end
           env_lockfile = Bundler.root.join(env_lockfile).expand_path
-          current = env_lockfile == lockfile
+          active = env_lockfile == lockfile
+        end
+
+        if active && (old_active = lockfile_definitions.find { |definition| definition[:active] })
+          raise ArgumentError, "Only one lockfile (#{old_active[:lockfile]}) can be flagged as the default"
         end
 
-        if current && (old_current = lockfile_definitions.find { |definition| definition[:current] })
-          raise ArgumentError, "Only one lockfile (#{old_current[:lockfile]}) can be flagged as the default"
+        parent = expand_lockfile(parent)
+        if parent != Bundler.default_lockfile(force_original: true) &&
+           !lockfile_definitions.find { |definition| definition[:lockfile] == parent }
+          raise ArgumentError, "Parent lockfile #{parent} is not defined"
         end
 
         lockfile_definitions << (lockfile_def = {
           gemfile: (gemfile && Bundler.root.join(gemfile).expand_path) || Bundler.default_gemfile,
           lockfile: lockfile,
-          current: current,
+          active: active,
           prepare: block,
+          parent: parent,
           allow_mismatched_dependencies: allow_mismatched_dependencies,
           enforce_pinned_additional_dependencies: enforce_pinned_additional_dependencies
         })
@@ -94,10 +102,10 @@ module Bundler
           # If they're using BUNDLE_LOCKFILE, then they really do want to
           # use a particular lockfile, and it overrides whatever they
           # dynamically set in their gemfile
-          current = lockfile == Bundler.default_lockfile(force_original: true)
+          active = lockfile == Bundler.default_lockfile(force_original: true)
         end
 
-        if current
+        if active
           block&.call
           Bundler.default_lockfile = lockfile
 
@@ -146,16 +154,13 @@ module Bundler
         require "tempfile"
         require_relative "multilock/lockfile_generator"
 
+        Bundler.ui.debug("Syncing to alternate lockfiles")
         Bundler.ui.info ""
 
-        default_lockfile_contents = Bundler.default_lockfile.read.freeze
-        default_specs = LockfileParser.new(default_lockfile_contents).specs.to_h do |spec|
-          [[spec.name, spec.platform], spec]
-        end
-        default_root = Bundler.root
-
         attempts = 1
 
+        default_root = Bundler.root
+
         checker = Check.new
         synced_any = false
         Bundler.settings.temporary(cache_all_platforms: true, suppress_install_using_messages: true) do
@@ -196,21 +201,26 @@ module Bundler
               Bundler.ui.info("Syncing to #{relative_lockfile}...") if attempts == 1
               synced_any = true
 
-              # adjust locked paths from the default lockfile to be relative to _this_ gemfile
-              adjusted_default_lockfile_contents =
-                default_lockfile_contents.gsub(/PATH\n  remote: ([^\n]+)\n/) do |remote|
+              parent = lockfile_definition[:parent]
+              parent_root = parent.dirname
+              checker.load_lockfile(parent)
+              parent_specs = checker.lockfile_specs[parent]
+
+              # adjust locked paths from the parent lockfile to be relative to _this_ gemfile
+              adjusted_parent_lockfile_contents =
+                checker.lockfile_contents[parent].gsub(/PATH\n  remote: ([^\n]+)\n/) do |remote|
                   remote_path = Pathname.new($1)
                   next remote if remote_path.absolute?
 
-                  relative_remote_path = remote_path.expand_path(default_root).relative_path_from(Bundler.root).to_s
+                  relative_remote_path = remote_path.expand_path(parent_root).relative_path_from(Bundler.root).to_s
                   remote.sub($1, relative_remote_path)
                 end
 
               # add a source for the current gem
-              gem_spec = default_specs[[File.basename(Bundler.root), "ruby"]]
+              gem_spec = parent_specs[[File.basename(Bundler.root), "ruby"]]
 
               if gem_spec
-                adjusted_default_lockfile_contents += <<~TEXT
+                adjusted_parent_lockfile_contents += <<~TEXT
                   PATH
                     remote: .
                     specs:
@@ -220,36 +230,39 @@ module Bundler
 
               if lockfile_definition[:lockfile].exist?
                 # if the lockfile already exists, "merge" it together
-                default_lockfile = LockfileParser.new(adjusted_default_lockfile_contents)
+                parent_lockfile = LockfileParser.new(adjusted_parent_lockfile_contents)
                 lockfile = LockfileParser.new(lockfile_definition[:lockfile].read)
 
                 dependency_changes = false
                 # replace any duplicate specs with what's in the default lockfile
                 lockfile.specs.map! do |spec|
-                  default_spec = default_specs[[spec.name, spec.platform]]
-                  next spec unless default_spec
+                  parent_spec = parent_specs[[spec.name, spec.platform]]
+                  next spec unless parent_spec
 
-                  dependency_changes ||= spec != default_spec
-                  default_spec
+                  dependency_changes ||= spec != parent_spec
+                  parent_spec
                 end
 
-                lockfile.specs.replace(default_lockfile.specs + lockfile.specs).uniq!
-                lockfile.sources.replace(default_lockfile.sources + lockfile.sources).uniq!
-                lockfile.platforms.replace(default_lockfile.platforms).uniq!
+                lockfile.specs.replace(parent_lockfile.specs + lockfile.specs).uniq!
+                lockfile.sources.replace(parent_lockfile.sources + lockfile.sources).uniq!
+                lockfile.platforms.replace(parent_lockfile.platforms).uniq!
                 # prune more specific platforms
                 lockfile.platforms.delete_if do |p1|
                   lockfile.platforms.any? do |p2|
                     p2 != "ruby" && p1 != p2 && MatchPlatform.platforms_match?(p2, p1)
                   end
                 end
-                lockfile.instance_variable_set(:@ruby_version, default_lockfile.ruby_version)
-                lockfile.instance_variable_set(:@bundler_version, default_lockfile.bundler_version)
+                lockfile.instance_variable_set(:@ruby_version, parent_lockfile.ruby_version)
+                unless lockfile.bundler_version == parent_lockfile.bundler_version
+                  unlocking_bundler = true
+                  lockfile.instance_variable_set(:@bundler_version, parent_lockfile.bundler_version)
+                end
 
                 new_contents = LockfileGenerator.generate(lockfile)
               else
-                # no lockfile? just start out with the default lockfile's contents to inherit its
+                # no lockfile? just start out with the parent lockfile's contents to inherit its
                 # locked gems
-                new_contents = adjusted_default_lockfile_contents
+                new_contents = adjusted_parent_lockfile_contents
               end
 
               had_changes = false
@@ -261,7 +274,8 @@ module Bundler
                 had_changes = write_lockfile(lockfile_definition,
                                              temp_lockfile.path,
                                              install: install,
-                                             dependency_changes: dependency_changes)
+                                             dependency_changes: dependency_changes,
+                                             unlocking_bundler: unlocking_bundler)
               end
 
               # if we had changes, bundler may have updated some common
@@ -269,8 +283,9 @@ module Bundler
               # once to reset them back to the default lockfile's version.
               # if it's already good, the `check` check at the beginning of
               # the loop will skip the second sync anyway.
-              if had_changes && attempts < 3
+              if had_changes && attempts < 2
                 attempts += 1
+                Bundler.ui.debug("Re-running sync to #{relative_lockfile} to reset common dependencies")
                 redo
               else
                 attempts = 1
@@ -293,9 +308,9 @@ module Bundler
         @loaded = true
         return if lockfile_definitions.empty?
 
-        return unless lockfile_definitions.none? { |definition| definition[:current] }
+        return unless lockfile_definitions.none? { |definition| definition[:active] }
 
-        # Gemfile.lock isn't explicitly specified, otherwise it would be current
+        # Gemfile.lock isn't explicitly specified, otherwise it would be active
         default_lockfile_definition = lockfile_definitions.find do |definition|
           definition[:lockfile] == Bundler.default_lockfile(force_original: true)
         end
@@ -305,7 +320,7 @@ module Bundler
 
         raise GemfileNotFound, "Could not locate lockfile #{ENV["BUNDLE_LOCKFILE"].inspect}" if ENV["BUNDLE_LOCKFILE"]
 
-        return unless default_lockfile_definition && default_lockfile_definition[:current] == false
+        return unless default_lockfile_definition && default_lockfile_definition[:active] == false
 
         raise GemfileEvalError, "No lockfiles marked as default"
       end
@@ -317,8 +332,10 @@ module Bundler
 
       # @!visibility private
       def inject_preamble
+        Bundler.ui.debug("Injecting multilock preamble")
+
         minor_version = Gem::Version.new(::Bundler::Multilock::VERSION).segments[0..1].join(".")
-        bundle_preamble1_match = %(plugin "bundler-multilock")
+        bundle_preamble1_match = /plugin ["']bundler-multilock["']/
         bundle_preamble1 = <<~RUBY
           plugin "bundler-multilock", "~> #{minor_version}"
         RUBY
@@ -342,7 +359,16 @@ module Bundler
         end
 
         builder = Bundler::Plugin::DSL.new
-        builder.eval_gemfile(Bundler.default_gemfile)
+        # this method is called as part of the plugin loading, but @loaded_plugin_names
+        # hasn't been set yet, so avoid re-entrancy issues
+        plugins = Bundler::Plugin.instance_variable_get(:@loaded_plugin_names)
+        original_plugins = plugins.dup
+        plugins << "bundler-multilock"
+        begin
+          builder.eval_gemfile(Bundler.default_gemfile)
+        ensure
+          plugins.replace(original_plugins)
+        end
         gemfiles = builder.instance_variable_get(:@gemfiles).map(&:read)
 
         modified = inject_specific_preamble(gemfile, gemfiles, injection_point, bundle_preamble2, add_newline: true)
@@ -364,8 +390,20 @@ module Bundler
 
       private
 
-      def inject_specific_preamble(gemfile, gemfiles, injection_point, preamble, add_newline:, match: preamble)
-        return false if gemfiles.any? { |g| g.include?(match) }
+      def expand_lockfile(lockfile)
+        if lockfile.is_a?(String) && !(lockfile.include?("/") || lockfile.end_with?(".lock"))
+          lockfile = "Gemfile.#{lockfile}.lock"
+        end
+        # use absolute paths
+        lockfile = Bundler.root.join(lockfile).expand_path if lockfile
+        # use the default lockfile (Gemfile.lock) if none was given
+        lockfile || Bundler.default_lockfile(force_original: true)
+      end
+
+      def inject_specific_preamble(gemfile, gemfiles, injection_point, preamble, add_newline:, match: nil)
+        # allow either type of quotes
+        match ||= Regexp.new(Regexp.escape(preamble).gsub('"', %(["'])))
+        return false if gemfiles.any? { |g| match.match?(g) }
 
         add_newline = false unless gemfile[injection_point - 1] == "\n"
 
@@ -375,7 +413,7 @@ module Bundler
         true
       end
 
-      def write_lockfile(lockfile_definition, lockfile, install:, dependency_changes: false)
+      def write_lockfile(lockfile_definition, lockfile, install:, dependency_changes: false, unlocking_bundler: false)
         prepare_block = lockfile_definition[:prepare]
 
         gemfile = lockfile_definition[:gemfile]
@@ -385,33 +423,45 @@ module Bundler
         builder.eval_gemfile(gemfile, &prepare_block) if prepare_block
         builder.eval_gemfile(gemfile)
 
-        definition = builder.to_definition(lockfile, {})
+        definition = builder.to_definition(lockfile, { bundler: unlocking_bundler })
         definition.instance_variable_set(:@dependency_changes, dependency_changes) if dependency_changes
-        orig_definition = definition.dup # we might need it twice
 
         current_lockfile = lockfile_definition[:lockfile]
-        if current_lockfile.exist?
-          definition.instance_variable_set(:@lockfile_contents, current_lockfile.read)
-          if install
+        definition.instance_variable_set(:@lockfile_contents, current_lockfile.read) if current_lockfile.exist?
+
+        orig_definition = definition.dup # we might need it twice
+
+        if current_lockfile.exist? && install
+          Bundler.settings.temporary(frozen: true) do
             current_definition = builder.to_definition(current_lockfile, {})
-            begin
-              current_definition.resolve_with_cache!
-              if current_definition.missing_specs.any?
-                Bundler.with_default_lockfile(current_lockfile) do
-                  Installer.install(gemfile.dirname, current_definition, {})
-                end
+            current_definition.resolve_with_cache!
+            if current_definition.missing_specs.any?
+              Bundler.with_default_lockfile(current_lockfile) do
+                Installer.install(gemfile.dirname, current_definition, {})
               end
-            rescue RubyVersionMismatch, GemNotFound, SolveFailure
-              # ignore
             end
+          rescue RubyVersionMismatch, GemNotFound, SolveFailure
+            # ignore
           end
         end
 
         resolved_remotely = false
-        begin
+        accesses = begin
           previous_ui_level = Bundler.ui.level
           Bundler.ui.level = "warn"
           begin
+            # this is a horrible hack, to fix what I consider to be a Bundler bug.
+            # basically, if you have multiple platform specific gems in your
+            # lockfile, and that gem gets unlocked, Bundler will only search
+            # locally to find them. But non-platform-local gems are _never_
+            # installed locally. So just find the non-platform-local gems
+            # in the lockfile (that we know are there from a prior remote
+            # resolution), and add them to the locally installed spec list.
+            definition.send(:source_map).locked_specs.each do |spec|
+              next if spec.match_platform(Bundler.local_platform)
+
+              spec.source.specs.add(spec)
+            end
             definition.resolve_with_cache!
           rescue GemNotFound, SolveFailure
             definition = orig_definition
@@ -419,7 +469,9 @@ module Bundler
             definition.resolve_remotely!
             resolved_remotely = true
           end
-          definition.lock(lockfile_definition[:lockfile], true)
+          SharedHelpers.capture_filesystem_access do
+            definition.lock(lockfile_definition[:lockfile], true)
+          end
         ensure
           Bundler.ui.level = previous_ui_level
         end
@@ -432,7 +484,7 @@ module Bundler
           end
         end
 
-        !definition.nothing_changed?
+        accesses && !accesses.empty?
       end
     end
 
@@ -444,3 +496,26 @@ module Bundler
 end
 
 Bundler::Multilock.inject_preamble unless Bundler::Multilock.loaded?
+
+# this is terrible, but we can't prepend into these modules because we only load
+# _inside_ of the CLI commands already running
+if defined?(Bundler::CLI::Check)
+  require_relative "multilock/check"
+  at_exit do
+    next unless $!.nil?
+    next if $!.is_a?(SystemExit) && !$!.success?
+
+    next if Bundler::Multilock::Check.run
+
+    Bundler.ui.warn("You can attempt to fix by running `bundle install`")
+    exit 1
+  end
+end
+if defined?(Bundler::CLI::Lock)
+  at_exit do
+    next unless $!.nil?
+    next if $!.is_a?(SystemExit) && !$!.success?
+
+    Bundler::Multilock.after_install_all(install: false)
+  end
+end

data/plugins.rb

@@ -20,29 +20,6 @@
 
 require_relative "lib/bundler/multilock"
 
-# this is terrible, but we can't prepend into these modules because we only load
-# _inside_ of the CLI commands already running
-if defined?(Bundler::CLI::Check)
-  require_relative "lib/bundler/multilock/check"
-  at_exit do
-    next unless $!.nil?
-    next if $!.is_a?(SystemExit) && !$!.success?
-
-    next if Bundler::Multilock::Check.run
-
-    Bundler.ui.warn("You can attempt to fix by running `bundle install`")
-    exit 1
-  end
-end
-if defined?(Bundler::CLI::Lock)
-  at_exit do
-    next unless $!.nil?
-    next if $!.is_a?(SystemExit) && !$!.success?
-
-    Bundler::Multilock.after_install_all(install: false)
-  end
-end
-
 Bundler::Plugin.add_hook(Bundler::Plugin::Events::GEM_AFTER_INSTALL_ALL) do |_|
   Bundler::Multilock.after_install_all
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bundler-multilock
 version: !ruby/object:Gem::Version
-  version: 1.0.10
+  version: 1.1.0
 platform: ruby
 authors:
 - Instructure
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-09-26 00:00:00.000000000 Z
+date: 2023-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -25,19 +25,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 2.4.19
 - !ruby/object:Gem::Dependency
-  name: byebug
+  name: debug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '11.1'
+        version: '1.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '11.1'
+        version: '1.8'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -121,6 +121,8 @@ files:
 - lib/bundler/multilock/ext/dsl.rb
 - lib/bundler/multilock/ext/plugin.rb
 - lib/bundler/multilock/ext/plugin/dsl.rb
+- lib/bundler/multilock/ext/shared_helpers.rb
+- lib/bundler/multilock/ext/source.rb
 - lib/bundler/multilock/ext/source_list.rb
 - lib/bundler/multilock/lockfile_generator.rb
 - lib/bundler/multilock/version.rb