grape-swagger 2.1.1 → 2.1.3

data/lib/grape-swagger/{endpoint/params_parser.rb → request_param_parsers/body.rb}

@@ -1,27 +1,26 @@
 # frozen_string_literal: true
 
 module GrapeSwagger
-  module Endpoint
-    class ParamsParser
-      attr_reader :params, :settings, :endpoint
+  module RequestParamParsers
+    class Body
+      attr_reader :route, :params, :settings, :endpoint
 
-      def self.parse_request_params(params, settings, endpoint)
-        new(params, settings, endpoint).parse_request_params
+      def self.parse(route, params, settings, endpoint)
+        new(route, params, settings, endpoint).parse
       end
 
-      def initialize(params, settings, endpoint)
+      def initialize(_route, params, settings, endpoint)
         @params = params
         @settings = settings
         @endpoint = endpoint
       end
 
-      def parse_request_params
+      def parse
         public_params.each_with_object({}) do |(name, options), memo|
           name = name.to_s
-          param_type = options[:type]
-          param_type = param_type.to_s unless param_type.nil?
+          param_type = options[:type]&.to_s
 
-          if param_type_is_array?(param_type)
+          if array_param?(param_type)
             options[:is_array] = true
             name += '[]' if array_use_braces?
           end
@@ -36,8 +35,8 @@ module GrapeSwagger
         @array_use_braces ||= settings[:array_use_braces] && !includes_body_param?
       end
 
-      def param_type_is_array?(param_type)
-        return false unless param_type
+      def array_param?(param_type)
+        return false if param_type.nil?
         return true if param_type == 'Array'
 
         param_types = param_type.match(/\[(.*)\]$/)
@@ -48,21 +47,14 @@ module GrapeSwagger
       end
 
       def public_params
-        params.select { |param| public_parameter?(param) }
+        params.select { |_key, param| public_parameter?(param) }
       end
 
-      def public_parameter?(param)
-        param_options = param.last
+      def public_parameter?(param_options)
         return true unless param_options.key?(:documentation) && !param_options[:required]
 
         param_hidden = param_options[:documentation].fetch(:hidden, false)
-        if param_hidden.is_a?(Proc)
-          param_hidden = if settings[:token_owner]
-                           param_hidden.call(endpoint.send(settings[:token_owner].to_sym))
-                         else
-                           param_hidden.call
-                         end
-        end
+        param_hidden = evaluate_hidden_proc(param_hidden) if param_hidden.is_a?(Proc)
         !param_hidden
       end
 
@@ -71,6 +63,13 @@ module GrapeSwagger
           options.dig(:documentation, :param_type) == 'body' || options.dig(:documentation, :in) == 'body'
         end
       end
+
+      def evaluate_hidden_proc(hidden_proc)
+        return hidden_proc.call unless settings[:token_owner]
+
+        token_owner = GrapeSwagger::TokenOwnerResolver.resolve(endpoint, settings[:token_owner])
+        GrapeSwagger::TokenOwnerResolver.evaluate_proc(hidden_proc, token_owner)
+      end
     end
   end
 end

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.1'
+  VERSION = '2.1.3'
 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,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: grape-swagger
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 2.1.3
 platform: ruby
 authors:
 - LeFnord
 - Tim Vandecasteele
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-21 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: grape
@@ -20,7 +19,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
@@ -30,22 +29,7 @@ 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'
-description:
+        version: '4.0'
 email:
 - pscholz.le@gmail.com
 - tim.vandecasteele@gmail.com
@@ -66,7 +50,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
@@ -77,18 +60,21 @@ 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
@@ -96,15 +82,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.0'
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
-signing_key:
+rubygems_version: 3.6.8
 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