grape-swagger 2.1.2 → 2.1.4

data/lib/grape-swagger/request_param_parsers/headers.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module GrapeSwagger
+  module RequestParamParsers
+    class Headers
+      attr_reader :route
+
+      def self.parse(route, params, settings, endpoint)
+        new(route, params, settings, endpoint).parse
+      end
+
+      def initialize(route, _params, _settings, _endpoint)
+        @route = route
+      end
+
+      def parse
+        return {} unless route.headers
+
+        route.headers.each_with_object({}) do |(name, definition), accum|
+          # Extract the description from any key type (string or symbol)
+          description = definition[:description] || definition['description']
+          doc = { desc: description, in: 'header' }
+
+          header_attrs = definition.symbolize_keys.except(:description, 'description')
+          header_attrs[:type] = definition[:type].titleize if definition[:type]
+          header_attrs[:documentation] = doc
+
+          accum[name] = header_attrs
+        end
+      end
+    end
+  end
+end

data/lib/grape-swagger/request_param_parsers/route.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module GrapeSwagger
+  module RequestParamParsers
+    class Route
+      DEFAULT_PARAM_TYPE = { required: true, type: 'Integer' }.freeze
+
+      attr_reader :route
+
+      def self.parse(route, params, settings, endpoint)
+        new(route, params, settings, endpoint).parse
+      end
+
+      def initialize(route, _params, _settings, _endpoint)
+        @route = route
+      end
+
+      def parse
+        stackable_values = route.app&.inheritable_setting&.namespace_stackable
+
+        path_params = build_path_params(stackable_values)
+
+        fulfill_params(path_params)
+      end
+
+      private
+
+      def build_path_params(stackable_values)
+        params = {}
+
+        while stackable_values.is_a?(Grape::Util::StackableValues)
+          params.merge!(fetch_inherited_params(stackable_values))
+          stackable_values = stackable_values.inherited_values
+        end
+
+        params
+      end
+
+      def fetch_inherited_params(stackable_values)
+        return {} unless stackable_values.new_values
+
+        namespaces = stackable_values.new_values[:namespace] || []
+
+        namespaces.each_with_object({}) do |namespace, params|
+          space = namespace.space.to_s.gsub(':', '')
+          params[space] = namespace.options || {}
+        end
+      end
+
+      def fulfill_params(path_params)
+        # Merge path params options into route params
+        route.params.each_with_object({}) do |(param, definition), accum|
+          # The route.params hash includes both parametrized params (with a string as a key)
+          # and well-defined params from body/query (with a symbol as a key).
+          # We avoid overriding well-defined params with parametrized ones.
+          key = param.is_a?(String) ? param.to_sym : param
+          next if param.is_a?(String) && accum.key?(key)
+
+          defined_options = definition.is_a?(Hash) ? definition : {}
+          value = (path_params[param] || {}).merge(defined_options)
+          accum[key] = value.empty? ? DEFAULT_PARAM_TYPE : value
+        end
+      end
+    end
+  end
+end

data/lib/grape-swagger/token_owner_resolver.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+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
+        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)
+
+        raise Errors::TokenOwnerNotFound, "undefined method `#{method_name}` for #{endpoint.class}"
+      end
+
+      def evaluate_proc(callable, token_owner)
+        return callable.call unless accepts_argument?(callable)
+
+        callable.call(token_owner)
+      end
+
+      private
+
+      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?
+
+        stackable_helpers = fetch_stackable_helpers(endpoint)
+        normalize_helpers(stackable_helpers)
+      end
+
+      def fetch_stackable_helpers(endpoint)
+        return unless endpoint.respond_to?(:inheritable_setting)
+
+        setting = endpoint.inheritable_setting
+        return unless setting.respond_to?(:namespace_stackable)
+
+        namespace_stackable = setting.namespace_stackable
+        return unless namespace_stackable.respond_to?(:[])
+
+        namespace_stackable[:helpers]
+      rescue NameError
+        nil
+      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 resolve_from_helper(endpoint, helper, method_name)
+        return UNRESOLVED unless helper_method_defined?(helper, method_name)
+
+        helper.instance_method(method_name).bind(endpoint).call
+      rescue NameError
+        UNRESOLVED
+      end
+
+      def helper_method_defined?(helper, method_name)
+        helper.method_defined?(method_name) || helper.private_method_defined?(method_name)
+      end
+
+      def accepts_argument?(callable)
+        return false unless callable.respond_to?(:parameters)
+
+        callable.parameters.any? { |type, _| SUPPORTED_ARITY_TYPES.include?(type) }
+      end
+    end
+  end
+end

data/lib/grape-swagger/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GrapeSwagger
-  VERSION = '2.1.2'
+  VERSION = '2.1.4'
 end

data/lib/grape-swagger.rb

@@ -10,22 +10,28 @@ require 'grape-swagger/errors'
 
 require 'grape-swagger/doc_methods'
 require 'grape-swagger/model_parsers'
+require 'grape-swagger/request_param_parser_registry'
+require 'grape-swagger/token_owner_resolver'
 
 module GrapeSwagger
   class << self
     def model_parsers
       @model_parsers ||= GrapeSwagger::ModelParsers.new
     end
+
+    def request_param_parsers
+      @request_param_parsers ||= GrapeSwagger::RequestParamParserRegistry.new
+    end
   end
   autoload :Rake, 'grape-swagger/rake/oapi_tasks'
 
   # Copied from https://github.com/ruby-grape/grape/blob/v2.2.0/lib/grape/formatter.rb
   FORMATTER_DEFAULTS = {
+    xml: Grape::Formatter::Xml,
+    serializable_hash: Grape::Formatter::SerializableHash,
     json: Grape::Formatter::Json,
     jsonapi: Grape::Formatter::Json,
-    serializable_hash: Grape::Formatter::SerializableHash,
-    txt: Grape::Formatter::Txt,
-    xml: Grape::Formatter::Xml
+    txt: Grape::Formatter::Txt
   }.freeze
 
   # Copied from https://github.com/ruby-grape/grape/blob/v2.2.0/lib/grape/content_types.rb
@@ -179,12 +185,13 @@ module SwaggerDocumentationAdder
       endpoint = endpoints.shift
 
       endpoints.push(*endpoint.options[:app].endpoints) if endpoint.options[:app]
-      ns = endpoint.namespace_stackable(:namespace).last
+      namespace_stackable = endpoint.inheritable_setting.namespace_stackable
+      ns = (namespace_stackable[:namespace] || []).last
       next unless ns
 
       # use the full namespace here (not the latest level only)
       # and strip leading slash
-      mount_path = (endpoint.namespace_stackable(:mount_path) || []).join('/')
+      mount_path = (namespace_stackable[:mount_path] || []).join('/')
       full_namespace = (mount_path + endpoint.namespace).sub(/\/{2,}/, '/').sub(/^\//, '')
       combined_namespaces[full_namespace] = ns
     end

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: grape-swagger
 version: !ruby/object:Gem::Version
-  version: 2.1.2
+  version: 2.1.4
 platform: ruby
 authors:
 - LeFnord
 - Tim Vandecasteele
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-07 00:00:00.000000000 Z
+date: 2026-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: grape
@@ -19,7 +20,7 @@ dependencies:
         version: '1.7'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,21 +30,8 @@ dependencies:
         version: '1.7'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: rack-test
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2'
+        version: '4.0'
+description:
 email:
 - pscholz.le@gmail.com
 - tim.vandecasteele@gmail.com
@@ -52,6 +40,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
+- CLAUDE.md
 - CONTRIBUTING.md
 - LICENSE.txt
 - README.md
@@ -64,7 +53,6 @@ files:
 - lib/grape-swagger/doc_methods/data_type.rb
 - lib/grape-swagger/doc_methods/extensions.rb
 - lib/grape-swagger/doc_methods/format_data.rb
-- lib/grape-swagger/doc_methods/headers.rb
 - lib/grape-swagger/doc_methods/move_params.rb
 - lib/grape-swagger/doc_methods/operation_id.rb
 - lib/grape-swagger/doc_methods/optional_object.rb
@@ -75,17 +63,22 @@ files:
 - lib/grape-swagger/doc_methods/tag_name_description.rb
 - lib/grape-swagger/doc_methods/version.rb
 - lib/grape-swagger/endpoint.rb
-- lib/grape-swagger/endpoint/params_parser.rb
 - lib/grape-swagger/errors.rb
 - lib/grape-swagger/instance.rb
 - lib/grape-swagger/model_parsers.rb
 - lib/grape-swagger/rake/oapi_tasks.rb
+- lib/grape-swagger/request_param_parser_registry.rb
+- lib/grape-swagger/request_param_parsers/body.rb
+- lib/grape-swagger/request_param_parsers/headers.rb
+- lib/grape-swagger/request_param_parsers/route.rb
+- lib/grape-swagger/token_owner_resolver.rb
 - lib/grape-swagger/version.rb
 homepage: https://github.com/ruby-grape/grape-swagger
 licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -100,7 +93,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: Add auto generated documentation to your Grape API that can be displayed
   with Swagger.

data/lib/grape-swagger/doc_methods/headers.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module GrapeSwagger
-  module DocMethods
-    class Headers
-      class << self
-        def parse(route)
-          route.headers.to_a.map do |route_header|
-            route_header.tap do |header|
-              hash = header[1]
-              description = hash.delete('description')
-              hash[:documentation] = { desc: description, in: 'header' }
-              hash[:type] = hash['type'].titleize if hash['type']
-            end
-          end
-        end
-      end
-    end
-  end
-end