bundler-multilock 1.0.2 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad2556137eeec88cc813f9ac79cbb7062a4a16b067bf88a61cfacb03d1ae9add
-  data.tar.gz: 58c7c976aa0e57f426b80152f213d069ee7f24ea5b9da1ee0c1ef115a8208e64
+  metadata.gz: 514c6dd3f4961f833ea20dee15047941b649cdbe787f94808d9547e310ac7ff0
+  data.tar.gz: 79b046545b14b3b29c33a629e528cf9bf60712337052b0381fc1b6bf240228c1
 SHA512:
-  metadata.gz: 84e3cd4a4b12513f2a5ea4d0d214abb9e1a061bf96d041d1bea16c833131941ce8da7f9109018dd2bc5b2ddc4afc363e68caae7948707ec7d3a68ac8dea745f3
-  data.tar.gz: cb8d45a52af7437ab6192809711531df051f7da2343b91087d4522f520441ab90476c822499d6e0c13d015923bf0701a75c9cead68f52bc49026de439cd0fbbe
+  metadata.gz: d071c456f788219cfb144b70cfb3161f1b53d9add8d9a2d5395be1bceb56f1681abd787047ec1e6f109c2937944756cf9b7f4cd85ff6ad9483666d46f3acfa2d
+  data.tar.gz: 887dbb68890c5f643fdfb925eade83055afd262115a3a8970dd900955d1793ba4109569a56f9d4f273229023a051b63aec86c05fce2c6bf7ecc6bfe59f00e95b

data/lib/bundler/multilock/check.rb

@@ -23,9 +23,20 @@ module Bundler
         return true unless Bundler.default_lockfile.exist?
 
         success = true
+        missing_specs = base_check({ gemfile: Bundler.default_gemfile, lockfile: Bundler.default_lockfile },
+                                   return_missing: true).to_set
+
         Multilock.lockfile_definitions.each do |lockfile_definition|
-          next unless lockfile_definition[:lockfile].exist?
+          next if lockfile_definition[:lockfile] == Bundler.default_lockfile
+
+          unless lockfile_definition[:lockfile].exist?
+            Bundler.ui.error("Lockfile #{lockfile_definition[:lockfile]} does not exist.")
+            success = false
+          end
 
+          new_missing = base_check(lockfile_definition, log_missing: missing_specs, return_missing: true)
+          success = false unless new_missing.empty?
+          missing_specs.merge(new_missing)
           success = false unless check(lockfile_definition)
         end
         success
@@ -33,21 +44,32 @@ module Bundler
 
       # this is mostly equivalent to the built in checks in `bundle check`, but even
       # more conservative, and returns false instead of exiting on failure
-      def base_check(lockfile_definition)
-        return false unless lockfile_definition[:lockfile].file?
+      def base_check(lockfile_definition, log_missing: false, return_missing: false)
+        return return_missing ? [] : false unless lockfile_definition[:lockfile].file?
 
         Multilock.prepare_block = lockfile_definition[:prepare]
         definition = Definition.build(lockfile_definition[:gemfile], lockfile_definition[:lockfile], false)
-        return false unless definition.send(:current_platform_locked?)
+        return return_missing ? [] : false unless definition.send(:current_platform_locked?)
 
         begin
           definition.validate_runtime!
           definition.resolve_only_locally!
           not_installed = definition.missing_specs
         rescue RubyVersionMismatch, GemNotFound, SolveFailure
-          return false
+          return return_missing ? [] : false
+        end
+
+        if log_missing
+          not_installed.each do |spec|
+            next if log_missing.include?(spec)
+
+            Bundler.ui.error "The following gems are missing" if log_missing.empty?
+            Bundler.ui.error(" * #{spec.name} (#{spec.version})")
+          end
         end
 
+        return not_installed if return_missing
+
         not_installed.empty? && definition.no_resolve_needed?
       ensure
         Multilock.prepare_block = nil

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

@@ -15,6 +15,12 @@ module Bundler
           end
           super
         end
+
+        def validate_runtime!
+          Multilock.loaded! unless Multilock.lockfile_definitions.empty?
+
+          super
+        end
       end
     end
   end

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

@@ -27,6 +27,7 @@ module Bundler
         def initialize
           super
           @gemfiles = Set.new
+          Multilock.loaded! unless Multilock.lockfile_definitions.empty?
         end
 
         # Significant changes:

data/lib/bundler/multilock/version.rb

@@ -2,6 +2,6 @@
 
 module Bundler
   module Multilock
-    VERSION = "1.0.2"
+    VERSION = "1.0.4"
   end
 end

data/lib/bundler/multilock.rb

@@ -283,14 +283,21 @@ module Bundler
 
         @loaded = true
         return if lockfile_definitions.empty?
+
         return unless lockfile_definitions.none? { |definition| definition[:current] }
+
         # Gemfile.lock isn't explicitly specified, otherwise it would be current
-        return if lockfile_definitions.none? do |definition|
-                    definition[:lockfile] == Bundler.default_lockfile(force_original: true)
-                  end
+        default_lockfile_definition = lockfile_definitions.find do |definition|
+          definition[:lockfile] == Bundler.default_lockfile(force_original: true)
+        end
+        if ENV["BUNDLE_LOCKFILE"] == Bundler.default_lockfile(force_original: true) && default_lockfile_definition
+          return
+        end
 
         raise GemfileNotFound, "Could not locate lockfile #{ENV["BUNDLE_LOCKFILE"].inspect}" if ENV["BUNDLE_LOCKFILE"]
 
+        return unless default_lockfile_definition && default_lockfile_definition[:current] == false
+
         raise GemfileEvalError, "No lockfiles marked as default"
       end
 
@@ -355,8 +362,36 @@ module Bundler
       end
 
       def write_lockfile(lockfile_definition, lockfile, install:, dependency_changes: false)
-        self.prepare_block = lockfile_definition[:prepare]
-        definition = build_definition(lockfile_definition, lockfile, dependency_changes: dependency_changes)
+        prepare_block = lockfile_definition[:prepare]
+
+        gemfile = lockfile_definition[:gemfile]
+        # use avoid Definition.build, so that we don't have to evaluate
+        # the gemfile multiple times, each time we need a separate definition
+        builder = Dsl.new
+        builder.eval_gemfile(gemfile, &prepare_block) if prepare_block
+        builder.eval_gemfile(gemfile)
+
+        definition = builder.to_definition(lockfile, {})
+        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
+            current_definition = builder.to_definition(current_lockfile, {})
+            begin
+              current_definition.resolve_only_locally!
+              if current_definition.missing_specs.any?
+                Bundler.with_default_lockfile(current_lockfile) do
+                  Installer.install(gemfile.dirname, current_definition, {})
+                end
+              end
+            rescue RubyVersionMismatch, GemNotFound, SolveFailure
+              # ignore
+            end
+          end
+        end
 
         resolved_remotely = false
         begin
@@ -365,7 +400,7 @@ module Bundler
           begin
             definition.resolve_with_cache!
           rescue GemNotFound, SolveFailure
-            definition = build_definition(lockfile_definition, lockfile, dependency_changes: dependency_changes)
+            definition = orig_definition
 
             definition.resolve_remotely!
             resolved_remotely = true
@@ -384,18 +419,6 @@ module Bundler
         end
 
         !definition.nothing_changed?
-      ensure
-        self.prepare_block = nil
-      end
-
-      def build_definition(lockfile_definition, lockfile, dependency_changes:)
-        definition = Definition.build(lockfile_definition[:gemfile], lockfile, false)
-        definition.instance_variable_set(:@dependency_changes, dependency_changes) if dependency_changes
-        if lockfile_definition[:lockfile].exist?
-          definition.instance_variable_set(:@lockfile_contents,
-                                           lockfile_definition[:lockfile].read)
-        end
-        definition
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bundler-multilock
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.4
 platform: ruby
 authors:
 - Instructure
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-09-12 00:00:00.000000000 Z
+date: 2023-09-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler