refactor: Clean up and simplify TokenOwnerResolver implementation

Remove dead code and improve error handling:

- Remove fetch_endpoint_helpers: Endpoints don't have a public helpers method,
  making this code path unreachable
- Simplify resolve_from_helper: Remove non-Module branch since helpers from
  namespace_stackable are always Modules
- Simplify gather_helpers: Only one source of helpers (stackable), remove
  unnecessary array consolidation
- Remove __send__ usage: inheritable_setting is a public method, use direct call
- Improve exception handling: Replace broad rescue StandardError with specific
  NoMethodError and NameError catches in fetch_stackable_helpers

Error handling improvements:

- Add GrapeSwagger::Errors::TokenOwnerNotFound inheriting from NoMethodError
  for more semantic error hierarchy
- Update resolver to raise custom error instead of generic NoMethodError,
  allowing users to catch grape-swagger-specific issues

Author: numbata

lib/grape-swagger/errors.rb

@@ -13,5 +13,7 @@ def tell!(what)
         end
       end
     end
+
+    class TokenOwnerNotFound < NoMethodError; end
   end
 end

lib/grape-swagger/token_owner_resolver.rb

@@ -16,7 +16,7 @@ def resolve(endpoint, method_name)
         helper_value = resolve_from_helpers(endpoint, method_name)
         return helper_value unless helper_value.equal?(UNRESOLVED)
 
-        raise NoMethodError, "undefined method `#{method_name}` for #{endpoint.inspect}"
+        raise Errors::TokenOwnerNotFound, "undefined method `#{method_name}` for #{endpoint.inspect}"
       end
 
       def evaluate_proc(callable, token_owner)
@@ -27,12 +27,6 @@ def evaluate_proc(callable, token_owner)
 
       private
 
-      def accepts_argument?(callable)
-        return false unless callable.respond_to?(:parameters)
-
-        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?
@@ -48,30 +42,22 @@ def resolve_from_helpers(endpoint, method_name)
       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
+        normalize_helpers(stackable_helpers)
       end
 
-      def resolve_from_helper(endpoint, helper, method_name)
-        if helper.is_a?(Module)
-          return UNRESOLVED unless helper_method_defined?(helper, method_name)
+      def fetch_stackable_helpers(endpoint)
+        return unless endpoint.respond_to?(:inheritable_setting)
 
-          return helper.instance_method(method_name).bind(endpoint).call
-        end
+        setting = endpoint.inheritable_setting
+        return unless setting.respond_to?(:namespace_stackable)
 
-        helper.respond_to?(method_name, true) ? helper.public_send(method_name) : UNRESOLVED
-      rescue NameError
-        UNRESOLVED
-      end
+        namespace_stackable = setting.namespace_stackable
+        return unless namespace_stackable.respond_to?(:[])
 
-      def helper_method_defined?(helper, method_name)
-        helper.method_defined?(method_name) || helper.private_method_defined?(method_name)
+        namespace_stackable[:helpers]
+      rescue NameError
+        nil
       end
 
       def normalize_helpers(helpers)
@@ -93,26 +79,22 @@ def normalize_helpers(helpers)
         end
       end
 
-      def fetch_endpoint_helpers(endpoint)
-        return unless endpoint.respond_to?(:helpers, true)
+      def resolve_from_helper(endpoint, helper, method_name)
+        return UNRESOLVED unless helper_method_defined?(helper, method_name)
 
-        endpoint.__send__(:helpers)
-      rescue StandardError
-        nil
+        helper.instance_method(method_name).bind(endpoint).call
+      rescue NameError
+        UNRESOLVED
       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)
+      def helper_method_defined?(helper, method_name)
+        helper.method_defined?(method_name) || helper.private_method_defined?(method_name)
+      end
 
-        namespace_stackable = setting.namespace_stackable
-        return unless namespace_stackable.respond_to?(:[])
+      def accepts_argument?(callable)
+        return false unless callable.respond_to?(:parameters)
 
-        namespace_stackable[:helpers]
-      rescue StandardError
-        nil
+        callable.parameters.any? { |type, _| SUPPORTED_ARITY_TYPES.include?(type) }
       end
     end
   end

spec/lib/token_owner_resolver_spec.rb

@@ -42,7 +42,7 @@ def token_owner
     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.to raise_error(GrapeSwagger::Errors::TokenOwnerNotFound, /undefined method `unknown`/)
     end
 
     context 'when helpers are included from a module' do
@@ -80,4 +80,59 @@ def call(owner = :undetected)
       expect(described_class.evaluate_proc(callable, token_owner)).to eq(:undetected)
     end
   end
+
+  describe '.resolve_from_helper' do
+    let(:helper_module) do
+      Module.new do
+        def helper_method
+          'helper_result'
+        end
+      end
+    end
+
+    let(:endpoint) { instance_double(Grape::Endpoint) }
+
+    it 'resolves the method from the Module helper' do
+      result = described_class.send(:resolve_from_helper, endpoint, helper_module, :helper_method)
+      expect(result).to eq('helper_result')
+    end
+
+    it 'returns a frozen sentinel object when method does not exist on the Module' do
+      result = described_class.send(:resolve_from_helper, endpoint, helper_module, :nonexistent)
+      # UNRESOLVED is a private constant, so we check by type and behavior
+      expect(result).to be_a(Object)
+      expect(result).to be_frozen
+      # Verify it's the same object on repeated calls (singleton pattern)
+      result2 = described_class.send(:resolve_from_helper, endpoint, helper_module, :nonexistent)
+      expect(result).to equal(result2)
+    end
+  end
+
+  describe 'endpoint helpers access' do
+    let(:helper_module) do
+      Module.new do
+        def current_user
+          { id: 42, name: 'Test User' }
+        end
+      end
+    end
+
+    let(:api_class) do
+      mod = helper_module
+      Class.new(Grape::API) do
+        helpers mod
+
+        get('/test') { { ok: true } }
+      end
+    end
+
+    before { api_class.compile! }
+
+    let(:endpoint) { api_class.endpoints.first }
+
+    it 'resolves helper methods from namespace stack' do
+      resolved_value = described_class.resolve(endpoint, :current_user)
+      expect(resolved_value).to eq(id: 42, name: 'Test User')
+    end
+  end
 end