Fix specs, and ensure they're up to date

Author: ccutrer

bundler/lib/bundler/definition.rb

@@ -296,9 +296,15 @@ def dependencies_for(groups)
 
     def plugins_for(groups)
       groups.map!(&:to_sym)
-      current_plugins.reject do |d|
-        (d.groups & groups).empty?
+      plugins = current_plugins # always returns a new array
+      plugins.select! do |d|
+        if RUBY_VERSION >= "3.1"
+          d.groups.intersect?(groups)
+        else
+          !(d.groups & groups).empty?
+        end
       end
+      plugins
     end
 
     # Resolve all the dependencies specified in Gemfile. It ensures that

bundler/lib/bundler/dsl.rb

@@ -277,20 +277,33 @@ def plugin(name, *args)
       version = args || [">= 0"]
 
       # We don't care to add sources for plugins in this pass over the gemfile
-      # since we're not actually installing plugins here (they should already
-      # be installed), just keeping track of them so that we can verify they
-      # are actually installed. This is important because otherwise sources
+      # since we're not installing plugins here (they should already be
+      # installed), only keeping track of them so that we can verify they
+      # are currently installed. This is important because otherwise sources
       # unique to the plugin (like a git source) would end up in the lockfile,
       # which we don't want.
       normalize_options(name, version, false, options)
 
       dep = Dependency.new(name, version, options)
 
-      # if there's already a dependency with this name we try to prefer one
+      # if there's already a plugin with this name we try to prefer one
       if current = @plugins.find {|d| d.name == dep.name }
-        Bundler.ui.warn "Your Gemfile lists the plugin #{current.name} (#{current.requirement}) more than once.\n" \
-                        "You should keep only one of them.\n" \
-                        "Remove any duplicate entries and specify the plugin only once."
+        if current.requirement != dep.requirement
+          raise GemfileError, "You cannot specify the same plugin twice with different version requirements.\n" \
+                           "You specified: #{current.name} (#{current.requirement}) and #{dep.name} (#{dep.requirement})" \
+                           "#{update_prompt}"
+        end
+
+        if current.source != dep.source
+          raise GemfileError, "You cannot specify the same plugin twice coming from different sources.\n" \
+                          "You specified that #{dep.name} (#{dep.requirement}) should come from " \
+                          "#{current.source || "an unspecified source"} and #{dep.source}\n"
+        else
+          Bundler.ui.warn "Your Gemfile lists the plugin #{current.name} (#{current.requirement}) more than once.\n" \
+                          "You should keep only one of them.\n" \
+                          "Remove any duplicate entries and specify the plugin only once." \
+                          "While it's not a problem now, it could cause errors if you change the version of one of them later."
+        end
       end
 
       @plugins << dep

bundler/lib/bundler/plugin.rb

@@ -103,6 +103,7 @@ def list
     # @param [Pathname] gemfile path
     # @param [Proc] block that can be evaluated for (inline) Gemfile
     def gemfile_install(gemfile = nil, unlock: false, &inline)
+      was_deployment = Bundler.settings[:deployment]
       Bundler.settings.temporary(frozen: false, deployment: false) do
         builder = DSL.new
         if block_given?
@@ -113,11 +114,17 @@ def gemfile_install(gemfile = nil, unlock: false, &inline)
 
         return if builder.dependencies.empty?
 
+        Bundler.configure_gem_home_and_path
+
         lockfile_contents = index.generate_lockfile(builder.instance_variable_get(:@sources), builder.dependencies)
         definition = builder.to_definition(nil, unlock || {}, lockfile_contents: lockfile_contents)
         unless definition.no_resolve_needed?
           Installer.new.install_definition(definition)
         end
+        # we may have cached the non-deployment gem path, so paths need to be
+        # reset in preparation for the regular gem installation phase that
+        # needs to use the deployment gem path
+        Bundler.reset_paths! if was_deployment
 
         plugins = definition.requested_dependencies.select(&:should_include?).map(&:name)
         installed_specs = plugins.to_h {|p| [p, definition.specs[p].first] }

bundler/lib/bundler/plugin/index_definition.rb

@@ -8,6 +8,7 @@ def platforms
         [Bundler.local_platform]
       end
 
+      def locked_checksums; end
       def locked_ruby_version; end
 
       def bundler_version_to_lock

bundler/spec/bundler/plugin_spec.rb

@@ -123,7 +123,7 @@
     end
 
     it "doesn't calls installer without any plugins" do
-      allow(definition).to receive(:dependencies) { [] }
+      allow(builder).to receive(:dependencies) { [] }
       allow(installer).to receive(:install_definition).never
 
       subject.gemfile_install(gemfile)
@@ -139,8 +139,13 @@
 
       before do
         allow(index).to receive(:installed?) { nil }
-        allow(definition).to receive(:dependencies) { [Bundler::Dependency.new("new-plugin", ">=0"), Bundler::Dependency.new("another-plugin", ">=0")] }
+        allow(index).to receive(:generate_lockfile) { nil }
+        allow(builder).to receive(:dependencies) { [Bundler::Dependency.new("new-plugin", ">=0"), Bundler::Dependency.new("another-plugin", ">=0")] }
+        allow(definition).to receive(:no_resolve_needed?) { false }
+        allow(definition).to receive(:requested_dependencies) { builder.dependencies }
+        allow(definition).to receive(:specs) { plugin_specs.to_h {|p, s| [p, [s]] } }
         allow(installer).to receive(:install_definition) { plugin_specs }
+        allow(Bundler).to receive(:configure_gem_home_and_path) {}
       end
 
       it "should validate and register the plugins" do

bundler/spec/plugins/uninstall_spec.rb

@@ -50,6 +50,7 @@
 
     bundle "plugin uninstall path_plugin"
     expect(out).to include("Uninstalled plugin path_plugin")
+    Bundler::Plugin.reset!
     plugin_should_not_be_installed("path_plugin")
     # the actual gem still exists though
     expect(path).to be_a_directory