Add Bundler::Override value object

Introduce a value object that holds a target/field/operation triple
for the upcoming Gemfile `override` DSL. apply_to dispatches on the
operation: a version spec string replaces the requirement absolutely,
:ignore_upper strips < and <= while folding ~> into >=, and nil
collapses to Gem::Requirement.default. The :ignore_upper logic is
taken from Shopify/bundler-ignore-dependency.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: hsbt

Manifest.txt

@@ -156,6 +156,7 @@ bundler/lib/bundler/match_platform.rb
 bundler/lib/bundler/match_remote_metadata.rb
 bundler/lib/bundler/materialization.rb
 bundler/lib/bundler/mirror.rb
+bundler/lib/bundler/override.rb
 bundler/lib/bundler/plugin.rb
 bundler/lib/bundler/plugin/api.rb
 bundler/lib/bundler/plugin/api/source.rb

bundler/lib/bundler.rb

@@ -62,6 +62,7 @@ module Bundler
   autoload :MatchRemoteMetadata,    File.expand_path("bundler/match_remote_metadata", __dir__)
   autoload :Materialization,        File.expand_path("bundler/materialization", __dir__)
   autoload :NULL,                   File.expand_path("bundler/constants", __dir__)
+  autoload :Override,               File.expand_path("bundler/override", __dir__)
   autoload :ProcessLock,            File.expand_path("bundler/process_lock", __dir__)
   autoload :RemoteSpecification,    File.expand_path("bundler/remote_specification", __dir__)
   autoload :Resolver,               File.expand_path("bundler/resolver", __dir__)

bundler/lib/bundler/override.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Bundler
+  class Override
+    LOWER_BOUND_OPERATORS = [">=", ">", "="].freeze
+
+    attr_reader :target, :field, :operation
+
+    def initialize(target, field, operation)
+      @target = target
+      @field = field
+      @operation = operation
+    end
+
+    def apply_to(requirement)
+      case operation
+      when nil
+        Gem::Requirement.default
+      when :ignore_upper
+        remove_upper_bounds(requirement)
+      when String
+        Gem::Requirement.new(operation)
+      else
+        raise ArgumentError, "unsupported override operation: #{operation.inspect}"
+      end
+    end
+
+    private
+
+    def remove_upper_bounds(requirement)
+      return Gem::Requirement.default if requirement.nil? || requirement.none?
+
+      lower_bounds = requirement.requirements.filter_map do |op, version|
+        if LOWER_BOUND_OPERATORS.include?(op)
+          [op, version]
+        elsif op == "~>"
+          [">=", version]
+        end
+      end
+
+      return Gem::Requirement.default if lower_bounds.empty?
+
+      Gem::Requirement.new(lower_bounds.map {|op, v| "#{op} #{v}" })
+    end
+  end
+end

spec/bundler/override_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+RSpec.describe Bundler::Override do
+  describe "#apply_to" do
+    context "when operation is a version spec string" do
+      it "replaces the existing requirement entirely" do
+        override = described_class.new("rails", :version, ">= 8.0")
+        result = override.apply_to(Gem::Requirement.new(">= 1.0", "< 2.0"))
+        expect(result).to eq(Gem::Requirement.new(">= 8.0"))
+      end
+
+      it "ignores the existing requirement regardless of its content" do
+        override = described_class.new("rails", :version, "= 1.0")
+        result = override.apply_to(Gem::Requirement.new(">= 99.0"))
+        expect(result).to eq(Gem::Requirement.new("= 1.0"))
+      end
+    end
+
+    context "when operation is :ignore_upper" do
+      it "removes < and <= operators" do
+        override = described_class.new("rails", :version, :ignore_upper)
+        result = override.apply_to(Gem::Requirement.new(">= 1.0", "< 2.0"))
+        expect(result).to eq(Gem::Requirement.new(">= 1.0"))
+      end
+
+      it "keeps >, >=, = operators" do
+        override = described_class.new("rails", :version, :ignore_upper)
+        result = override.apply_to(Gem::Requirement.new("> 1.0", "<= 2.0"))
+        expect(result).to eq(Gem::Requirement.new("> 1.0"))
+      end
+
+      it "converts ~> to >= preserving the lower bound" do
+        override = described_class.new("rails", :version, :ignore_upper)
+        result = override.apply_to(Gem::Requirement.new("~> 1.5"))
+        expect(result).to eq(Gem::Requirement.new(">= 1.5"))
+      end
+
+      it "returns the default requirement when only upper bounds remain" do
+        override = described_class.new("rails", :version, :ignore_upper)
+        result = override.apply_to(Gem::Requirement.new("< 2.0"))
+        expect(result).to eq(Gem::Requirement.default)
+      end
+
+      it "returns the default requirement when the input is nil" do
+        override = described_class.new("rails", :version, :ignore_upper)
+        expect(override.apply_to(nil)).to eq(Gem::Requirement.default)
+      end
+
+      it "returns the default requirement when the input is already the default" do
+        override = described_class.new("rails", :version, :ignore_upper)
+        expect(override.apply_to(Gem::Requirement.default)).to eq(Gem::Requirement.default)
+      end
+    end
+
+    context "when operation is nil" do
+      it "returns the default requirement" do
+        override = described_class.new("rails", :version, nil)
+        result = override.apply_to(Gem::Requirement.new(">= 1.0", "< 2.0"))
+        expect(result).to eq(Gem::Requirement.default)
+      end
+    end
+
+    context "when operation is unsupported" do
+      it "raises ArgumentError" do
+        override = described_class.new("rails", :version, 42)
+        expect { override.apply_to(Gem::Requirement.default) }.to raise_error(ArgumentError, /unsupported override operation/)
+      end
+    end
+  end
+end

spec/support/windows_tag_group.rb

@@ -189,6 +189,7 @@ module WindowsTagGroup
         "spec/bundler/uri_normalizer_spec.rb",
         "spec/install/gems/no_build_extension_spec.rb",
         "spec/install/gems/no_install_plugin_spec.rb",
+        "spec/bundler/override_spec.rb",
       ],
     }.freeze
   end