duck_typer 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb7a9d41a358d3238e054a878eca9968910ee1b7917a4379022cbcc7587d0bdd
-  data.tar.gz: 17724ad54c3caee0ad1ae7dd46a43f431cd064a00f4f1b53995875095b8d52a9
+  metadata.gz: 881833f4db9f3c47049ad45e41c804a74a97db030438f43f933a388dc0f41cba
+  data.tar.gz: ad0b846adb0389c1db0cd49d9d245cb6c006c136e76ea0e7b3980a8d1fb4d3ce
 SHA512:
-  metadata.gz: ef5827a7b0adb92cc6e79c8e152435df3acd66d2905fb075c8535a5af58450a1055121be58f246bcdd8d62fc79124a931bc2904d1c7061a1224b7f19b1c26676
-  data.tar.gz: bd6f3660f2db388d41de049e90ab0dc3d8715aa83878555dd6faec700079f6fe1acae98887d19800de505c8756962868ba5b431b8ded4e61c6533df8b5a203b5
+  metadata.gz: be49c0476b7afe2c3df16fcede0480f242cfab68c0d1d0a637bba8ac4aa6070bada1c9bbd0350c556193340d62cc2a5665b9949b1c838840127574c2761ff57a
+  data.tar.gz: e9f4543f7117f6e7e3709a153cb316ce90974a984fc302bec71dc84c78fff89a706585cffc9581a24b6f9fa679df3dd0f971a0a82b44c1b78644ff1a8948ba1e

data/.ruby-version

@@ -0,0 +1 @@
+3.1.0

data/.tool-versions

@@ -0,0 +1 @@
+ruby 3.1.0

data/CHANGELOG.md

@@ -1,5 +1,51 @@
 # Changelog
 
+## [0.4.0] - 2026-03-09
+
+### Added
+- Strict mode (`strict: true`) for interface comparison: positional
+  argument names must match exactly. Available on
+  `assert_interfaces_match`, `have_matching_interfaces`, and the
+  RSpec shared example. Keyword argument names always matter
+  regardless of this setting.
+- `assert_duck_types_match` as an alias for `assert_interfaces_match`
+- `have_matching_duck_types` as an alias for `have_matching_interfaces`
+- `BulkInterfaceChecker` now raises `ArgumentError` when fewer than
+  two classes are given
+
+### Fixed
+- RSpec shared example was broken on Ruby 3.1 due to proc argument
+  destructuring differences between Ruby versions
+
+### Changed
+- `ParamsNormalizer` refactored into a factory (`ParamsNormalizer.for(strict:)`)
+  with extracted modules: `KeywordNormalizer`, `SequentialNormalizer`,
+  `DefaultParamsNormalizer`, `StrictParamsNormalizer`, and
+  `NullParamsNormalizer` — all consolidated in a single file
+- CI now runs against Ruby 3.1 (minimum) and 3.4 (latest)
+
+## [0.3.2] - 2026-03-07
+
+### Changed
+- Move type validation and `TYPES` constant to `MethodInspector`
+- Refactor `ParamsNormalizer`: extract `SEQUENTIAL_TYPES` constant
+  and `sequentialize_params`, reorder methods for natural reading order
+- Introduce `NullParamsNormalizer` as an explicit null object,
+  replacing an implicit identity lambda
+- Move `MethodInspector`, `ParamsNormalizer`, and `NullParamsNormalizer`
+  to the `DuckTyper` namespace; nest `ClassMethodInspector` and
+  `InstanceMethodInspector` inside `MethodInspector`
+- Use `assoc` to look up method params in `join_signature`
+- Inline `inspector` locals throughout `InterfaceChecker`
+- Mark `ParamsNormalizer`, `NullParamsNormalizer`, and `MethodInspector`
+  as internal (`:nodoc:`)
+
+### Added
+- `ParamsNormalizer` test suite
+- Test that each differing method appears only once in `failure_message`
+- Test that `assert_interfaces_match` passes for matching pairs even
+  when another class in the list mismatches
+
 ## [0.3.1] - 2026-03-07
 
 ### Added

data/CLAUDE.md

@@ -0,0 +1,79 @@
+# CLAUDE.md
+
+## Release
+
+- Before writing to `CHANGELOG.md`, pull from `main` and do a
+  detailed analysis of all commits since the last tag (e.g.
+  `git log <last-tag>..HEAD`).
+- Based on the analysis, determine the next version number: bump
+  the patch version for internal changes or bug fixes, the minor
+  version for new features, and the major version for breaking
+  changes. Confirm the version number with the programmer before
+  proceeding.
+- Update `CHANGELOG.md` with the new version and a summary of
+  changes.
+- After releasing, delete the generated `.gem` files from the root
+  directory — they are not committed and should not linger.
+
+## Ruby version
+
+For now, use the minimum required Ruby version for development —
+this ensures the gem works for everyone who meets that requirement.
+
+When updating the minimum required Ruby version, update it in all
+of these places:
+
+- `.ruby-version`
+- `.tool-versions`
+- `duck_typer.gemspec` (`spec.required_ruby_version`)
+- `.github/workflows/ci.yml` (`ruby-version`)
+
+## Git
+
+- Before staging specific files, always run `git status` to check
+  whether the staging area already has changes that would be
+  unintentionally included in the commit.
+- After staging, double-check the staged changes match what was
+  asked before committing.
+- Always run `bundle exec rake ci` before pushing.
+- Always ask for confirmation before pushing.
+
+## Commands
+
+- `bundle exec rake test` — run Minitest and RSpec suites
+- `bundle exec rake minitest` — run Minitest suite only
+- `bundle exec rake ci` — run tests, linting, and lockfile drift check
+  (always run before pushing)
+- `bundle exec standardrb` — lint
+
+## Tests
+
+- **Minitest is the default test suite.** Test files live in `test/`.
+- **RSpec is only for testing RSpec-specific functionality.**
+  Spec files live in `spec/`.
+- New tests belong in `test/` unless they exercise the RSpec
+  integration.
+- When two or more classes are interchangeably used (e.g. a class
+  and its null object), write an interface test using the gem's own
+  `assert_interfaces_match` (include `DuckTyper::Minitest`).
+- When testing a transformation (e.g. `ParamsNormalizer`), always
+  include a mixed test that exercises all cases together, in addition
+  to focused tests for each case.
+
+## Code style
+
+- Markdown files should be kept at 70 columns.
+- File paths must match the Ruby namespace: `DuckTyper::Foo` lives
+  in `lib/duck_typer/foo.rb`, not under a subdirectory of another
+  class.
+- Classes are only nested inside another class when they are
+  intrinsically part of it (e.g. `InterfaceChecker::Result`).
+  Otherwise they belong at the `DuckTyper` root level.
+- Methods are defined in natural reading order: callers before
+  callees.
+- Leave a blank line before the return value in multi-line methods.
+- Extract constants for inline literals used in conditionals.
+- Private methods mirror each other when they share a common role
+  (e.g. `sort_keyword_params` / `sequentialize_params`).
+- Use `params` instead of `parameters` in names (e.g. method names,
+  variable names).

data/CONTRIBUTING.md

@@ -34,11 +34,11 @@ Run the setup script.
 Make sure everything passes:
 
 ```
-bundle exec rake test
-bundle exec standardrb
+bundle exec rake ci
 ```
 
-Make your change, with new passing tests.
+Make your change, with new passing tests. Before pushing, run
+`bundle exec rake ci` again to make sure nothing is broken.
 
 Push to your fork. Write a [good commit message][commit]. Submit a
 pull request.

data/README.md

@@ -2,6 +2,12 @@
 
 [![CI](https://github.com/thoughtbot/duck_typer/actions/workflows/ci.yml/badge.svg)](https://github.com/thoughtbot/duck_typer/actions/workflows/ci.yml)
 
+<div align="center">
+  <img alt="DuckTyper mascot" src="assets/swan_mugshot.png" width="300">
+</div>
+
+> If it quacks like a duck, it's a duck... or is it?
+
 DuckTyper enforces duck-typed interfaces in Ruby by comparing the
 public method signatures of classes, surfacing mismatches through
 your test suite.
@@ -39,7 +45,7 @@ aligned as the design changes.
 Add to your Gemfile:
 
 ```ruby
-gem "duck_typer"
+gem "duck_typer", group: :test
 ```
 
 Then run:
@@ -103,10 +109,17 @@ classes share compatible interfaces:
 
 ```ruby
 def test_payment_processors_have_compatible_interfaces
-  assert_interfaces_match [StripeProcessor, PaypalProcessor, BraintreeProcessor]
+  assert_interfaces_match [
+    StripeProcessor,
+    PaypalProcessor,
+    BraintreeProcessor
+  ]
 end
 ```
 
+> If you prefer duck typing terminology, `assert_duck_types_match`
+> is available as an alias.
+
 By default, DuckTyper checks instance method interfaces. To check
 class-level interfaces instead, pass `type: :class_methods`:
 
@@ -125,6 +138,19 @@ assert_interfaces_match [StripeProcessor, PaypalProcessor],
 This is useful if your class implements multiple interfaces, in
 which case you can write an assertion for each.
 
+To enforce that positional argument names also match (strict
+mode), pass `strict: true`:
+
+```ruby
+assert_interfaces_match [StripeProcessor, PaypalProcessor],
+  strict: true
+```
+
+By default, positional argument names are ignored — only their
+count and kind (required, optional, rest) are compared. In strict
+mode, names must match exactly. Keyword argument names always
+matter regardless of this setting.
+
 ### RSpec
 
 Require the RSpec integration in your `spec_helper.rb`:
@@ -141,21 +167,35 @@ share compatible interfaces:
 ```ruby
 RSpec.describe "payment processors" do
   it "have compatible interfaces" do
-    expect([StripeProcessor, PaypalProcessor, BraintreeProcessor]).to have_matching_interfaces
+    expect([StripeProcessor, PaypalProcessor, BraintreeProcessor])
+      .to have_matching_interfaces
   end
 end
 ```
 
+> If you prefer duck typing terminology, `have_matching_duck_types`
+> is available as an alias.
+
 For class-level interfaces, pass `type: :class_methods`:
 
 ```ruby
-expect([StripeProcessor, PaypalProcessor]).to have_matching_interfaces(type: :class_methods)
+expect([StripeProcessor, PaypalProcessor])
+  .to have_matching_interfaces(type: :class_methods)
 ```
 
 To check only a subset of methods, use `methods:`:
 
 ```ruby
-expect([StripeProcessor, PaypalProcessor]).to have_matching_interfaces(methods: %i[charge refund])
+expect([StripeProcessor, PaypalProcessor])
+  .to have_matching_interfaces(methods: %i[charge refund])
+```
+
+To enforce that positional argument names also match, pass
+`strict: true`:
+
+```ruby
+expect([StripeProcessor, PaypalProcessor])
+  .to have_matching_interfaces(strict: true)
 ```
 
 #### Shared example
@@ -178,23 +218,30 @@ Then use it in your specs:
 
 ```ruby
 RSpec.describe "payment processors" do
-  it_behaves_like "an interface", [StripeProcessor, PaypalProcessor, BraintreeProcessor]
+  it_behaves_like "an interface", [
+    StripeProcessor,
+    PaypalProcessor,
+    BraintreeProcessor
+  ]
 end
 ```
 
-The same `type:` and `methods:` options are supported:
+The same `type:`, `methods:`, and `strict:` options are supported:
 
 ```ruby
 it_behaves_like "an interface", [StripeProcessor, PaypalProcessor],
   type: :class_methods,
-  methods: %i[charge refund]
+  methods: %i[charge refund],
+  strict: true
 ```
 
 ## Limitations
 
-DuckTyper checks the **structure** of public method signatures
-— the number of parameters, their kinds (required, optional,
-keyword, rest, block), and keyword argument names. It does not
+By default, DuckTyper checks the **structure** of public method
+signatures — the number of parameters, their kinds (required,
+optional, keyword, rest, block), and keyword argument names. In
+strict mode, positional argument names are also compared. It does
+not
 verify the following, which should be covered by your regular
 test suite:
 
@@ -217,6 +264,14 @@ Some things are intentionally out of scope:
   `initialize`: how an object is constructed is not an interface
   concern.
 
+## Stability
+
+DuckTyper is intentionally minimal. It reflects Ruby's own method
+introspection API, which rarely changes — so the gem rarely needs
+to either. When it does change, it will most likely be for additive reasons:
+new API options, better error messages, or broader test framework
+support. It is safe to depend on without worrying about churn.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install

data/lib/duck_typer/bulk_interface_checker.rb

@@ -3,9 +3,11 @@
 module DuckTyper
   # Runs interface checks across all consecutive pairs of classes in a list.
   class BulkInterfaceChecker
-    def initialize(objects, type: :instance_methods, partial_interface_methods: nil)
+    def initialize(objects, type: :instance_methods, partial_interface_methods: nil, strict: false)
+      raise ArgumentError, "more than one class is required" if objects.size < 2
+
       @objects = objects
-      @checker = InterfaceChecker.new(type:, partial_interface_methods:)
+      @checker = InterfaceChecker.new(type:, partial_interface_methods:, strict:)
     end
 
     def call(&block)

data/lib/duck_typer/interface_checker.rb

@@ -1,21 +1,16 @@
 # frozen_string_literal: true
 
 require_relative "interface_checker/result"
-require_relative "interface_checker/method_inspector"
-require_relative "interface_checker/params_normalizer"
+require_relative "method_inspector"
+require_relative "params_normalizer"
 
 module DuckTyper
   # Compares the public method signatures of two classes and reports mismatches.
   class InterfaceChecker
-    TYPES = %i[instance_methods class_methods].freeze
-
-    def initialize(type: :instance_methods, partial_interface_methods: nil)
-      unless TYPES.include?(type)
-        raise ArgumentError, "Invalid type #{type.inspect}, must be one of #{TYPES}"
-      end
-
+    def initialize(type: :instance_methods, partial_interface_methods: nil, strict: false)
       @type = type
       @partial_interface_methods = partial_interface_methods
+      @strict = strict
       @inspectors = Hash.new { |h, k| h[k] = MethodInspector.for(k, @type) }
     end
 
@@ -30,25 +25,19 @@ module DuckTyper
     private
 
     def calculate_diff(left, right)
-      left_params = params_for_comparison(left, ParamsNormalizer)
-      right_params = params_for_comparison(right, ParamsNormalizer)
+      normalizer = ParamsNormalizer.for(strict: @strict)
+      left_params = params_for_comparison(left, normalizer)
+      right_params = params_for_comparison(right, normalizer)
 
       (left_params - right_params) + (right_params - left_params)
     end
 
-    def method_params(inspector, method_name, object)
-      inspector.parameters_for(method_name)
-    rescue NameError
-      raise MethodNotFoundError, "undefined method `#{method_name}' for #{object}"
-    end
-
-    def params_for_comparison(object, params_processor = -> { _1 })
-      inspector = @inspectors[object]
-      methods = @partial_interface_methods || inspector.public_methods
+    def params_for_comparison(object, params_normalizer)
+      methods = @partial_interface_methods || @inspectors[object].public_methods
 
       methods.map do |method_name|
-        params = method_params(inspector, method_name, object)
-        args = params_processor.call(params).map do |type, name|
+        params = method_params(method_name, object)
+        args = params_normalizer.call(params).map do |type, name|
           case type
           when :key then "#{name}: :opt"
           when :keyreq then "#{name}:"
@@ -65,10 +54,16 @@ module DuckTyper
       end
     end
 
+    def method_params(method_name, object)
+      @inspectors[object].parameters_for(method_name)
+    rescue NameError
+      raise MethodNotFoundError, "undefined method `#{method_name}' for #{object}"
+    end
+
     def diff_message(left, right, diff)
       methods = diff.map(&:first).uniq
-      left_params = params_for_comparison(left).to_h.slice(*methods)
-      right_params = params_for_comparison(right).to_h.slice(*methods)
+      left_params = params_for_comparison(left, ParamsNormalizer::NullParamsNormalizer)
+      right_params = params_for_comparison(right, ParamsNormalizer::NullParamsNormalizer)
 
       methods.map do |method_name|
         <<~DIFF
@@ -78,12 +73,12 @@ module DuckTyper
       end.join("\n")
     end
 
-    def join_signature(object, method_name, params)
-      inspector = @inspectors[object]
-      display_name = inspector.display_name_for(method_name)
+    def join_signature(object, method_name, all_params)
+      display_name = @inspectors[object].display_name_for(method_name)
+      method_params = all_params.assoc(method_name)&.last
 
-      signature = if params[method_name]
-        "#{display_name}(#{params[method_name].join(", ")})"
+      signature = if method_params
+        "#{display_name}(#{method_params.join(", ")})"
       else
         "#{display_name} not defined"
       end

data/lib/duck_typer/{interface_checker/method_inspector.rb → method_inspector.rb}

@@ -1,15 +1,19 @@
 # frozen_string_literal: true
 
 module DuckTyper
-  class InterfaceChecker
-    class MethodInspector
-      def self.for(object, type)
-        if type == :class_methods
-          ClassMethodInspector
-        else
-          InstanceMethodInspector
-        end.new(object)
+  module MethodInspector # :nodoc:
+    TYPES = %i[instance_methods class_methods].freeze
+
+    def self.for(object, type)
+      unless TYPES.include?(type)
+        raise ArgumentError, "Invalid type #{type.inspect}, must be one of #{TYPES}"
       end
+
+      if type == :class_methods
+        ClassMethodInspector
+      else
+        InstanceMethodInspector
+      end.new(object)
     end
 
     class ClassMethodInspector

data/lib/duck_typer/minitest.rb

@@ -4,13 +4,15 @@ require_relative "../duck_typer"
 
 module DuckTyper
   module Minitest
-    def assert_interfaces_match(objects, type: :instance_methods, methods: nil)
+    def assert_interfaces_match(objects, type: :instance_methods, methods: nil, strict: false)
       checker = BulkInterfaceChecker
-        .new(objects, type:, partial_interface_methods: methods)
+        .new(objects, type:, partial_interface_methods: methods, strict:)
 
       checker.call do |result|
         assert result.match?, result.failure_message
       end
     end
+
+    alias_method :assert_duck_types_match, :assert_interfaces_match
   end
 end

data/lib/duck_typer/params_normalizer.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module DuckTyper
+  # Factory for parameter normalization. Use ParamsNormalizer.for(strict:)
+  # to get the right normalizer for the given comparison mode.
+  module ParamsNormalizer # :nodoc:
+    def self.for(strict:)
+      strict ? StrictParamsNormalizer : DefaultParamsNormalizer
+    end
+
+    # Normalizes method parameters for default interface comparison.
+    # Sorts keywords alphabetically and replaces positional argument
+    # names with sequential placeholders.
+    module DefaultParamsNormalizer # :nodoc:
+      def self.call(params)
+        KeywordNormalizer.call(params).then { |p| SequentialNormalizer.call(p) }
+      end
+    end
+
+    # Normalizes method parameters for strict interface comparison,
+    # where positional argument names are significant. Sorts keywords
+    # alphabetically but preserves positional argument names.
+    module StrictParamsNormalizer # :nodoc:
+      def self.call(params)
+        KeywordNormalizer.call(params)
+      end
+    end
+
+    # Sorts keyword argument parameters alphabetically, making keyword
+    # order irrelevant for interface comparison.
+    module KeywordNormalizer # :nodoc:
+      KEYWORD_TYPES = %i[key keyreq].freeze
+
+      def self.call(params)
+        keywords, sequentials = params.partition { |type, _| KEYWORD_TYPES.include?(type) }
+
+        sequentials + keywords.sort_by { |_, name| name }
+      end
+    end
+
+    # Replaces positional parameter names with sequential placeholders
+    # (a, b, c, ...), focusing comparison on structure rather than naming.
+    module SequentialNormalizer # :nodoc:
+      SEQUENTIAL_TYPES = %i[req opt rest keyrest block].freeze
+
+      class << self
+        def call(params)
+          sequential_name = ("a".."z").to_enum
+
+          params.map do |type, name|
+            if SEQUENTIAL_TYPES.include?(type)
+              name = next_sequential_param(sequential_name)
+            end
+
+            [type, name]
+          end
+        end
+
+        private
+
+        def next_sequential_param(enumerator)
+          enumerator.next.to_sym
+        rescue StopIteration
+          raise TooManyParametersError, "too many positional parameters, maximum supported is 26"
+        end
+      end
+    end
+
+    # A no-op params processor that returns params unchanged. Used when
+    # interface comparison should preserve original parameter names rather
+    # than normalizing them.
+    module NullParamsNormalizer # :nodoc:
+      def self.call(params)
+        params
+      end
+    end
+  end
+end

data/lib/duck_typer/rspec.rb

@@ -2,10 +2,10 @@
 
 require_relative "../duck_typer"
 
-RSpec::Matchers.define :have_matching_interfaces do |type: :instance_methods, methods: nil|
+RSpec::Matchers.define :have_matching_interfaces do |type: :instance_methods, methods: nil, strict: false|
   match do |objects|
     checker = DuckTyper::BulkInterfaceChecker
-      .new(objects, type:, partial_interface_methods: methods)
+      .new(objects, type:, partial_interface_methods: methods, strict:)
 
     @failures = checker.call.reject(&:match?)
     @failures.empty?
@@ -16,17 +16,20 @@ RSpec::Matchers.define :have_matching_interfaces do |type: :instance_methods, me
   end
 end
 
+RSpec::Matchers.alias_matcher :have_matching_duck_types, :have_matching_interfaces
+
 module DuckTyper
   module RSpec
     def self.define_shared_example(name = "an interface")
-      ::RSpec.shared_examples name do |objects, type: :instance_methods, methods: nil|
+      ::RSpec.shared_examples name do |*objects, type: :instance_methods, methods: nil, strict: false|
+        objects = objects.first
         # We intentionally avoid reusing the have_matching_interfaces matcher
         # here. Since this shared example is defined in gem code, RSpec filters
         # it from its backtrace, causing the Failure/Error: line to show an
         # internal RSpec constant instead of useful context.
         it "has compatible interfaces" do
           checker = DuckTyper::BulkInterfaceChecker
-            .new(objects, type:, partial_interface_methods: methods)
+            .new(objects, type:, partial_interface_methods: methods, strict:)
 
           failures = checker.call.reject(&:match?)
 

data/lib/duck_typer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DuckTyper
-  VERSION = "0.3.1"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: duck_typer
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Thiago A. Silva
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-03-07 00:00:00.000000000 Z
+date: 2026-03-09 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -17,8 +17,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".ruby-version"
 - ".standard.yml"
+- ".tool-versions"
 - CHANGELOG.md
+- CLAUDE.md
 - CONTRIBUTING.md
 - LICENSE
 - README.md
@@ -26,10 +29,10 @@ files:
 - lib/duck_typer.rb
 - lib/duck_typer/bulk_interface_checker.rb
 - lib/duck_typer/interface_checker.rb
-- lib/duck_typer/interface_checker/method_inspector.rb
-- lib/duck_typer/interface_checker/params_normalizer.rb
 - lib/duck_typer/interface_checker/result.rb
+- lib/duck_typer/method_inspector.rb
 - lib/duck_typer/minitest.rb
+- lib/duck_typer/params_normalizer.rb
 - lib/duck_typer/rspec.rb
 - lib/duck_typer/version.rb
 homepage: https://github.com/thoughtbot/duck_typer
@@ -55,7 +58,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
+rubygems_version: 3.3.3
 signing_key:
 specification_version: 4
 summary: Enforce duck-typed interfaces in Ruby through your test suite.

data/lib/duck_typer/interface_checker/params_normalizer.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module DuckTyper
-  class InterfaceChecker
-    # Normalizes method parameters to enable interface comparison. For
-    # example, two methods may use different names for positional
-    # arguments, but if the parameter types and order match, they should
-    # be considered equivalent. This class replaces argument names with
-    # sequential placeholders when appropriate, focusing the comparison on
-    # parameter structure rather than naming.
-    class ParamsNormalizer
-      KEYWORD_TYPES = %i[key keyreq].freeze
-
-      class << self
-        def call(params)
-          sequential_name = ("a".."z").to_enum
-
-          sort_keyword_params(params).map do |type, name|
-            if %i[req opt rest keyrest block].include?(type)
-              name = next_sequential_param(sequential_name)
-            end
-
-            [type, name]
-          end
-        end
-
-        private
-
-        # Keyword argument order is irrelevant to a method's interface —
-        # m(a:, b:) and m(b:, a:) are equivalent. Sort keyword params
-        # alphabetically so comparison is order-independent.
-        def sort_keyword_params(params)
-          keywords, non_keywords = params.partition do |type, _|
-            KEYWORD_TYPES.include?(type)
-          end
-
-          non_keywords + keywords.sort_by { |_, name| name }
-        end
-
-        def next_sequential_param(enumerator)
-          enumerator.next
-        rescue StopIteration
-          raise TooManyParametersError, "too many positional parameters, maximum supported is 26"
-        end
-      end
-    end
-  end
-end