Use parameters over arity, add curated error for required kwargs

Switches from Method#arity math to Method#parameters inspection for more
precise required-arg detection. Required keyword arguments now produce a
curated ArgumentError instead of falling through to Ruby's native error.
Adds a spec for the required-kwargs case and sharpens the delegation and
method_missing NOTE comments.

Author: numbata

CHANGELOG.md

@@ -8,7 +8,7 @@
 
 * Your contribution here.
 * [#404](https://github.com/ruby-grape/grape-entity/pull/404): Drop `MultiJson` dependency, use `Hash#to_json` for ActiveSupport-aware serialization - [@numbata](https://github.com/numbata).
-* [#406](https://github.com/ruby-grape/grape-entity/pull/406): Handle symbol-to-proc wrappers (`&:method_name`) where the method uses `delegate` or `method_missing` - [@marcrohloff](https://github.com/marcrohloff).
+* [#406](https://github.com/ruby-grape/grape-entity/pull/406): Handle symbol-to-proc wrappers (`&:method_name`) where the method uses `delegate` or `method_missing`, and let unknown methods raise a native `NoMethodError` - [@marcrohloff](https://github.com/marcrohloff).
 
 ### 1.0.4 (2026-04-17)
 

lib/grape_entity/entity.rb

@@ -539,32 +539,48 @@ def ensure_block_arity!(block)
       return unless match # Unrecognized format -> bail safe rather than misidentify
 
       origin_method_name = match[:name].to_sym
-      required_positional_arg_count, variadic = positional_arity_for(origin_method_name)
+      required_positional_arg_count, required_keyword_arg_count, variadic_positional =
+        arity_requirement_for(origin_method_name)
       return unless required_positional_arg_count
 
-      expected_suffix = required_positional_arg_count == 1 ? 'argument' : 'arguments'
-      expected_suffix += ' or more' if variadic
+      required_arguments =
+        required_arguments_summary(required_positional_arg_count, required_keyword_arg_count, variadic_positional)
 
       raise ArgumentError, <<~MSG
-        Cannot use `&:#{origin_method_name}` because that method expects #{required_positional_arg_count} #{expected_suffix}.
+        Cannot use `&:#{origin_method_name}` because that method expects #{required_arguments}.
         Symbol-to-proc shorthand only works for methods that can be called with no arguments.
       MSG
     end
 
-    def positional_arity_for(method_name)
+    def arity_requirement_for(method_name)
       origin_method = object.method(method_name)
-      return nil if origin_method.parameters.any? { |type, _| type == :keyreq }
+      parameters = origin_method.parameters
 
-      arity = origin_method.arity
-      required_positional_arg_count = arity >= 0 ? arity : -arity - 1
-      return nil if required_positional_arg_count.zero?
+      required_positional_arg_count = parameters.count { |type, _| type == :req }
+      required_keyword_arg_count = parameters.count { |type, _| type == :keyreq }
+      return nil if required_positional_arg_count.zero? && required_keyword_arg_count.zero?
 
-      [required_positional_arg_count, arity.negative?]
+      [required_positional_arg_count, required_keyword_arg_count, parameters.any? { |type, _| type == :rest }]
     rescue NameError
       # Delegation wrappers and method_missing proxies may not expose a Method; let Ruby raise natively at call time.
       nil
     end
 
+    def required_arguments_summary(required_positional_arg_count, required_keyword_arg_count, variadic_positional)
+      parts = []
+      unless required_positional_arg_count.zero?
+        suffix = required_positional_arg_count == 1 ? 'argument' : 'arguments'
+        suffix += ' or more' if variadic_positional
+        parts << "#{required_positional_arg_count} #{suffix}"
+      end
+      unless required_keyword_arg_count.zero?
+        suffix = required_keyword_arg_count == 1 ? 'keyword argument' : 'keyword arguments'
+        parts << "#{required_keyword_arg_count} #{suffix}"
+      end
+
+      parts.join(' and ')
+    end
+
     def symbol_to_proc_wrapper?(block)
       params = block.parameters
 

spec/grape_entity/entity_spec.rb

@@ -424,6 +424,10 @@ def method_with_optional_kwargs_as_a_splat(**_kwargs)
               'result'
             end
 
+            def method_with_required_kwargs(_required:)
+              'result'
+            end
+
             def method_with_optional_args_and_kwargs_as_a_splat(*_args, **_kwargs)
               'result'
             end
@@ -570,7 +574,7 @@ def block.to_s
           end
 
           context 'with block passed in via & that references a method with optional args' do
-            it 'succeeds if there no required arguments' do
+            it 'succeeds if there are no required arguments' do
               subject.expose :that_method_with_only_optional_args, &:method_with_only_optional_args
               subject.expose :method_with_only_optional_args, as: :that_method_with_only_optional_args_again
 
@@ -590,7 +594,7 @@ def block.to_s
 
               expect do
                 subject.represent(object).value_for(:that_method_with_required_and_optional_args)
-              end.to raise_error ArgumentError, include('method expects 1 argument or more.')
+              end.to raise_error ArgumentError, include('method expects 1 argument.')
 
               expect do
                 subject.represent(object).value_for(:that_method_with_required_and_optional_args_again)
@@ -641,6 +645,18 @@ def block.to_s
             end
           end
 
+          context 'with block passed in via & that references a method with required kwargs' do
+            it 'raises an `ArgumentError` if there are required keyword arguments' do
+              subject.expose :that_method_with_required_kwargs, &:method_with_required_kwargs
+
+              object = SomeObject.new
+
+              expect do
+                subject.represent(object).value_for(:that_method_with_required_kwargs)
+              end.to raise_error ArgumentError, include('method expects 1 keyword argument.')
+            end
+          end
+
           context 'with block passed in via & that references a method with optional args and kwargs as a splat' do
             specify do
               subject.expose :that_method_with_optional_args_and_kwargs_as_a_splat, &:method_with_optional_args_and_kwargs_as_a_splat
@@ -674,8 +690,8 @@ def block.to_s
 
               object = SomeObjectWithMethodMissing.new
 
-              # NOTE: ensure_block_arity! cannot pierce delegation wrappers (arity -1);
-              # Ruby raises a native error at call time instead of the curated grape-entity message.
+              # NOTE: object.method(:method_with_args) is not available for this method_missing proxy,
+              # so Ruby raises a native error at call time instead of the curated grape-entity message.
               expect do
                 subject.represent(object).value_for(:that_method_with_args)
               end.to raise_error ArgumentError, /given 0, expected 1/
@@ -705,8 +721,8 @@ def block.to_s
 
               object = SomeObjectWithDelegation.new
 
-              # NOTE: ensure_block_arity! cannot pierce delegation wrappers (arity -1);
-              # Ruby raises a native error at call time instead of the curated grape-entity message.
+              # NOTE: delegation wrappers expose variable arity, so Ruby raises a native error
+              # at call time instead of the curated grape-entity message.
               expect do
                 subject.represent(object).value_for(:that_method_with_args)
               end.to raise_error ArgumentError, /given 0, expected 1/