duck_typer 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb7a9d41a358d3238e054a878eca9968910ee1b7917a4379022cbcc7587d0bdd
-  data.tar.gz: 17724ad54c3caee0ad1ae7dd46a43f431cd064a00f4f1b53995875095b8d52a9
+  metadata.gz: 24207ce1f63f8b0871e06127e2644497f4c60314bbb5fab55f0e8a9f2b30349b
+  data.tar.gz: 8dbebe87508eb66d745af1ce8a0fd6d30865b5929b2de47e092cba9122bcab29
 SHA512:
-  metadata.gz: ef5827a7b0adb92cc6e79c8e152435df3acd66d2905fb075c8535a5af58450a1055121be58f246bcdd8d62fc79124a931bc2904d1c7061a1224b7f19b1c26676
-  data.tar.gz: bd6f3660f2db388d41de049e90ab0dc3d8715aa83878555dd6faec700079f6fe1acae98887d19800de505c8756962868ba5b431b8ded4e61c6533df8b5a203b5
+  metadata.gz: d97a298dd8aaa903f2a9e2ae451f530a79aa433d9734ae220f89573f88d3ea9288dd1c9feb61c981eda95b272f2fea4b0763f67374bba972cb678ab52692a03b
+  data.tar.gz: 75b66d83757541fdd0cc1ead317aa3e15a7fe9878e1fb57a9b348b3a6c63bce5da2e5fe8091296914ea3bf2e637446af0031806baaed208f5ba01497a479c41c

data/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## [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,56 @@
+# 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.
+
+## 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/lib/duck_typer/interface_checker.rb

@@ -1,19 +1,14 @@
 # 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"
+require_relative "null_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
-
       @type = type
       @partial_interface_methods = partial_interface_methods
       @inspectors = Hash.new { |h, k| h[k] = MethodInspector.for(k, @type) }
@@ -36,18 +31,11 @@ module DuckTyper
       (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_processor)
+      methods = @partial_interface_methods || @inspectors[object].public_methods
 
       methods.map do |method_name|
-        params = method_params(inspector, method_name, object)
+        params = method_params(method_name, object)
         args = params_processor.call(params).map do |type, name|
           case type
           when :key then "#{name}: :opt"
@@ -65,10 +53,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, NullParamsNormalizer)
+      right_params = params_for_comparison(right, NullParamsNormalizer)
 
       methods.map do |method_name|
         <<~DIFF
@@ -78,12 +72,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/null_params_normalizer.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module DuckTyper
+  # A no-op params processor that returns params unchanged. Used when
+  # interface comparison should preserve original parameter names rather
+  # than normalizing them.
+  class NullParamsNormalizer # :nodoc:
+    def self.call(params)
+      params
+    end
+  end
+end

data/lib/duck_typer/params_normalizer.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module DuckTyper
+  # Normalizes method parameters to enable interface comparison.
+  # Keyword argument order is irrelevant — m(a:, b:) and m(b:, a:)
+  # are equivalent — so keywords are sorted alphabetically. Positional
+  # argument names are also replaced with sequential placeholders,
+  # focusing the comparison on parameter structure rather than naming.
+  class ParamsNormalizer # :nodoc:
+    KEYWORD_TYPES = %i[key keyreq].freeze
+    SEQUENTIAL_TYPES = %i[req opt rest keyrest block].freeze
+
+    class << self
+      def call(params)
+        sort_keyword_params(params).then { sequentialize_params(_1) }
+      end
+
+      private
+
+      def sort_keyword_params(params)
+        keywords, sequentials = params.partition do |type, _|
+          KEYWORD_TYPES.include?(type)
+        end
+
+        sequentials + keywords.sort_by { |_, name| name }
+      end
+
+      def sequentialize_params(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
+
+      def next_sequential_param(enumerator)
+        enumerator.next.to_sym
+      rescue StopIteration
+        raise TooManyParametersError, "too many positional parameters, maximum supported is 26"
+      end
+    end
+  end
+end

data/lib/duck_typer/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: duck_typer
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Thiago A. Silva
@@ -19,6 +19,7 @@ extra_rdoc_files: []
 files:
 - ".standard.yml"
 - CHANGELOG.md
+- CLAUDE.md
 - CONTRIBUTING.md
 - LICENSE
 - README.md
@@ -26,10 +27,11 @@ 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/null_params_normalizer.rb
+- lib/duck_typer/params_normalizer.rb
 - lib/duck_typer/rspec.rb
 - lib/duck_typer/version.rb
 homepage: https://github.com/thoughtbot/duck_typer

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