Enhance TokenOwnerResolver for Grape 3.0 compatibility

  - Implement robust token owner resolution from endpoint methods, helper
    modules, and stackable helpers
  - Add support for detecting and properly evaluating Proc arguments via
    parameter inspection
  - Add comprehensive test coverage for resolver behavior including:
    * Direct method resolution on endpoints
    * Helper module resolution via namespace stack
    * Proc evaluation with and without arguments
    * Error handling for undefined methods

Author: numbata

lib/grape-swagger/token_owner_resolver.rb

@@ -4,16 +4,19 @@ module GrapeSwagger
   class TokenOwnerResolver
     class << self
       SUPPORTED_ARITY_TYPES = %i[req opt rest keyreq key keyrest].freeze
+      UNRESOLVED = Object.new.freeze
+      private_constant :UNRESOLVED
 
       def resolve(endpoint, method_name)
         return if method_name.nil?
 
         method_name = method_name.to_sym
-        unless endpoint.respond_to?(method_name, true)
-          raise NoMethodError, "undefined method `#{method_name}` for #{endpoint.inspect}"
-        end
+        return endpoint.public_send(method_name) if endpoint.respond_to?(method_name, true)
+
+        helper_value = resolve_from_helpers(endpoint, method_name)
+        return helper_value unless helper_value.equal?(UNRESOLVED)
 
-        endpoint.public_send(method_name)
+        raise NoMethodError, "undefined method `#{method_name}` for #{endpoint.inspect}"
       end
 
       def evaluate_proc(callable, token_owner)
@@ -29,6 +32,88 @@ def accepts_argument?(callable)
 
         callable.parameters.any? { |type, _| SUPPORTED_ARITY_TYPES.include?(type) }
       end
+
+      def resolve_from_helpers(endpoint, method_name)
+        helpers = gather_helpers(endpoint)
+        return UNRESOLVED if helpers.empty?
+
+        helpers.each do |helper|
+          resolved = resolve_from_helper(endpoint, helper, method_name)
+          return resolved unless resolved.equal?(UNRESOLVED)
+        end
+
+        UNRESOLVED
+      end
+
+      def gather_helpers(endpoint)
+        return [] if endpoint.nil?
+
+        helpers = []
+        endpoint_helpers = fetch_endpoint_helpers(endpoint)
+        helpers.concat(normalize_helpers(endpoint_helpers)) if endpoint_helpers
+
+        stackable_helpers = fetch_stackable_helpers(endpoint)
+        helpers.concat(normalize_helpers(stackable_helpers)) if stackable_helpers
+
+        helpers.compact.uniq
+      end
+
+      def resolve_from_helper(endpoint, helper, method_name)
+        if helper.is_a?(Module)
+          return UNRESOLVED unless helper_method_defined?(helper, method_name)
+
+          return helper.instance_method(method_name).bind(endpoint).call
+        end
+
+        helper.respond_to?(method_name, true) ? helper.public_send(method_name) : UNRESOLVED
+      rescue NameError
+        UNRESOLVED
+      end
+
+      def helper_method_defined?(helper, method_name)
+        helper.method_defined?(method_name) || helper.private_method_defined?(method_name)
+      end
+
+      def normalize_helpers(helpers)
+        case helpers
+        when nil, false
+          []
+        when Module
+          [helpers]
+        when Array
+          helpers.compact
+        else
+          if helpers.respond_to?(:key?) && helpers.respond_to?(:[]) && helpers.key?(:helpers)
+            normalize_helpers(helpers[:helpers])
+          elsif helpers.respond_to?(:to_a)
+            Array(helpers.to_a).flatten.compact
+          else
+            Array(helpers).compact
+          end
+        end
+      end
+
+      def fetch_endpoint_helpers(endpoint)
+        return unless endpoint.respond_to?(:helpers, true)
+
+        endpoint.__send__(:helpers)
+      rescue StandardError
+        nil
+      end
+
+      def fetch_stackable_helpers(endpoint)
+        return unless endpoint.respond_to?(:inheritable_setting, true)
+
+        setting = endpoint.__send__(:inheritable_setting)
+        return unless setting.respond_to?(:namespace_stackable)
+
+        namespace_stackable = setting.namespace_stackable
+        return unless namespace_stackable.respond_to?(:[])
+
+        namespace_stackable[:helpers]
+      rescue StandardError
+        nil
+      end
     end
   end
 end

spec/lib/token_owner_resolver_spec.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe GrapeSwagger::TokenOwnerResolver do
+  describe '.resolve' do
+    let(:helper_module) do
+      Module.new do
+        def current_user_id
+          'user-123'
+        end
+      end
+    end
+
+    let(:api_class) do
+      mod = helper_module
+      Class.new(Grape::API) do
+        helpers mod
+
+        helpers do
+          def token_owner
+            { id: 7, email: '[email protected]' }
+          end
+        end
+
+        get('/status') { { status: 'ok' } }
+      end
+    end
+
+    before { api_class.compile! }
+
+    let(:endpoint) { api_class.endpoints.first }
+
+    it 'returns nil when no method name is provided' do
+      expect(described_class.resolve(endpoint, nil)).to be_nil
+    end
+
+    it 'returns the resolved value when method exists' do
+      expect(described_class.resolve(endpoint, :token_owner)).to eq(id: 7, email: '[email protected]')
+    end
+
+    it 'raises when the endpoint does not respond to the method' do
+      expect do
+        expect(described_class.resolve(endpoint, :unknown))
+      end.to raise_error(NoMethodError, /undefined method `unknown`/)
+    end
+
+    context 'when helpers are included from a module' do
+      it 'resolves the owner using the helper module from the namespace stack' do
+        expect(described_class.resolve(endpoint, :current_user_id)).to eq('user-123')
+      end
+    end
+  end
+
+  describe '.evaluate_proc' do
+    let(:token_owner) { double(:token_owner) }
+
+    it 'executes callables without arguments directly' do
+      callable = -> { :owner }
+
+      expect(callable).to receive(:call).with(no_args).and_call_original
+      expect(described_class.evaluate_proc(callable, token_owner)).to eq(:owner)
+    end
+
+    it 'passes the token owner when the callable accepts an argument' do
+      callable = ->(owner) { owner }
+
+      allow(callable).to receive(:call).with(token_owner).and_call_original
+      expect(described_class.evaluate_proc(callable, token_owner)).to eq(token_owner)
+      expect(callable).to have_received(:call).with(token_owner)
+    end
+
+    it 'defaults to calling without arguments when arity cannot be detected' do
+      callable = Class.new do
+        def call(owner = :undetected)
+          owner
+        end
+      end.new
+
+      expect(described_class.evaluate_proc(callable, token_owner)).to eq(:undetected)
+    end
+  end
+end