Block arity detection (#389)

* Fix the method Grape::Entity#exec_with_object to work with Ruby 3.

* Fix(Entity): Improve block arity detection for `Symbol#to_proc`

Addresses `ArgumentError`s when using `&:method_name` with `expose`,
a scenario particularly affected by Ruby 3.0's stricter argument handling
for procs. The previous arity check, including the condition
`block.parameters == [[:req], [:rest]]`, was not consistently reliable
for these cases.

This change introduces `determine_block_arity` which:
1. Attempts to parse the original method name from `Proc#to_s` for
   blocks likely created via `&:method_name`.
2. If the method name is found and the object responds to it, this
   logic uses the *actual arity of the original method* to correctly
   determine how `instance_exec` should be called.
3. If the original method name can't be determined, it falls back
   to using `block.parameters.size`.

This ensures methods exposed via `&:method_name` are called with the
correct arguments (i.e., with or without `options`), resolving the
`ArgumentError`s and removing the need for the previous `rescue` logic.

* Fix rubocop offense

* Fix(Entity): Enforce zero-arity for Symbol#to_proc in exec_with_object

Ruby 3.0’s stricter arity rules meant `&:method_name` blocks could be called with wrong args,
causing errors. The old check (`parameters == [[:req],[:rest]]` + `parameters.size`) was unreliable.

This update:

- Adds `symbol_to_proc_wrapper?` to detect pure `&:method_name` Procs (checks `lambda?`,
  `source_location.nil?`, and `parameters == [[:req],[:rest]]`).
- Introduces `determine_block_arity`, which parses the method name from `block.to_s`; if
  the object responds to it, it uses `object.method(name).arity`, otherwise falls back
  to `block.arity`.
- In `exec_with_object`, symbol-to-proc wrappers are required to have zero arity (raising
  `ArgumentError` otherwise), while regular Procs use `block.arity` to decide between
  `instance_exec(object)` and `instance_exec(object, options)`.

This removes rescue logic and ensures `&:method_name` is only used for zero-argument methods.

* Correct error message

* Fix(Entity): Validate `&:method_name` arity and method presence

Ensure symbol-to-proc exposures only work for zero-argument methods:
- Raise if the method is undefined on the object
- Raise if the method expects one or more arguments
- Fall back to `Proc#arity` for regular blocks

---------

Co-authored-by: Chau Hong Linh <[email protected]>

Author: numbata

lib/grape_entity/entity.rb

@@ -519,19 +519,47 @@ def serializable_hash(runtime_options = {})
     end
 
     def exec_with_object(options, &block)
-      if block.parameters.count == 1
+      arity = if symbol_to_proc_wrapper?(block)
+                ensure_block_arity!(block)
+              else
+                block.arity
+              end
+
+      if arity.zero?
         instance_exec(object, &block)
       else
         instance_exec(object, options, &block)
       end
-    rescue StandardError => e
-      # it handles: https://github.com/ruby/ruby/blob/v3_0_0_preview1/NEWS.md#language-changes point 3, Proc
-      # accounting for expose :foo, &:bar
-      if e.is_a?(ArgumentError) && block.parameters == [[:req], [:rest]]
-        raise Grape::Entity::Deprecated.new e.message, 'in ruby 3.0'
+    end
+
+    def ensure_block_arity!(block)
+      # MRI currently always includes "( &:foo )" for symbol-to-proc wrappers.
+      # If this format changes in a new Ruby version, this logic must be updated.
+      origin_method_name = block.to_s.scan(/(?<=\(&:)[^)]+(?=\))/).first&.to_sym
+      return 0 unless origin_method_name
+
+      unless object.respond_to?(origin_method_name, true)
+        raise ArgumentError, <<~MSG
+          Cannot use `&:#{origin_method_name}` because that method is not defined in the object.
+        MSG
       end
 
-      raise e
+      arity = object.method(origin_method_name).arity
+      return 0 if arity.zero?
+
+      raise ArgumentError, <<~MSG
+        Cannot use `&:#{origin_method_name}` because that method expects #{arity} argument#{'s' if arity != 1}.
+        Symbol‐to‐proc shorthand only works for zero‐argument methods.
+      MSG
+    end
+
+    def symbol_to_proc_wrapper?(block)
+      params = block.parameters
+
+      return false unless block.lambda? && block.source_location.nil?
+      return false unless params.size >= 2
+
+      params[0].first == :req && params[1].first == :rest
     end
 
     def exec_with_attribute(attribute, &block)

spec/grape_entity/entity_spec.rb

@@ -393,6 +393,14 @@ def method_without_args
               'result'
             end
 
+            def method_with_one_arg(_object)
+              'result'
+            end
+
+            def method_with_multiple_args(_object, _options)
+              'result'
+            end
+
             def raises_argument_error
               raise ArgumentError, 'something different'
             end
@@ -423,28 +431,49 @@ def raises_argument_error
           end
 
           context 'with block passed in via &' do
-            if RUBY_VERSION.start_with?('3')
-              specify do
-                subject.expose :that_method_without_args, &:method_without_args
-                subject.expose :method_without_args, as: :that_method_without_args_again
-
-                object = SomeObject.new
-                expect do
-                  subject.represent(object).value_for(:that_method_without_args)
-                end.to raise_error Grape::Entity::Deprecated
-
-                value2 = subject.represent(object).value_for(:that_method_without_args_again)
-                expect(value2).to eq('result')
-              end
-            else
-              specify do
-                subject.expose :that_method_without_args_again, &:method_without_args
+            specify do
+              subject.expose :that_method_without_args, &:method_without_args
+              subject.expose :method_without_args, as: :that_method_without_args_again
 
-                object = SomeObject.new
+              object = SomeObject.new
 
-                value2 = subject.represent(object).value_for(:that_method_without_args_again)
-                expect(value2).to eq('result')
-              end
+              value = subject.represent(object).value_for(:method_without_args)
+              expect(value).to be_nil
+
+              value = subject.represent(object).value_for(:that_method_without_args)
+              expect(value).to eq('result')
+
+              value = subject.represent(object).value_for(:that_method_without_args_again)
+              expect(value).to eq('result')
+            end
+          end
+
+          context 'with block passed in via &' do
+            specify do
+              subject.expose :that_method_with_one_arg, &:method_with_one_arg
+              subject.expose :that_method_with_multple_args, &:method_with_multiple_args
+
+              object = SomeObject.new
+
+              expect do
+                subject.represent(object).value_for(:that_method_with_one_arg)
+              end.to raise_error ArgumentError, match(/method expects 1 argument/)
+
+              expect do
+                subject.represent(object).value_for(:that_method_with_multple_args)
+              end.to raise_error ArgumentError, match(/method expects 2 arguments/)
+            end
+          end
+
+          context 'with symbol-to-proc passed in via &' do
+            specify do
+              subject.expose :that_undefined_method, &:unknown_method
+
+              object = SomeObject.new
+
+              expect do
+                subject.represent(object).value_for(:that_undefined_method)
+              end.to raise_error ArgumentError, match(/method is not defined in the object/)
             end
           end
         end