grape-swagger 2.0.3 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c36235d1ec48b00075496c2d59151a87e42f2b7f34c876db913504a7706c1a70
-  data.tar.gz: 0d7aac2f325422f53218257e4cb8e2bef51e73e424a53d88b244c3073c614656
+  metadata.gz: d07c4678df57d48124ef1afed6e8d60c0cedc0d5f1ea198b4c1ce2e6b3e30f2d
+  data.tar.gz: 35e02858f204c33f403a6b583c1c2ced2c3d66caaa94613d30de4c227ed96266
 SHA512:
-  metadata.gz: 13d4c18cf80ce43aedde8a3347be17ebda40fd6e2b56496459226f350e273b31cd6c74d79d75b68e2461d47dd6f0aeaec3080709aebbcf5b6beb9b8162f949bb
-  data.tar.gz: 949ebd6da1fcdb3c398e6070a035f50a9e211ed27a93694b275f5e09a9d1266c675f04f7b1e9583329689fcc9a38fd50cdac8dd6c1de87c486016e63faacce57
+  metadata.gz: 35c4824daa66db7842b786b580981a18223c1cb7c199a4a8dd754b2cc310fc876d8b7bb8dad659f5a92f554d4c8e306e960e739a9764b6a6c6c8bb004a87d37c
+  data.tar.gz: 2b4c8c3e19b0d9ee56a66655598b8293470f18a3815f0cc8c6e5bf003647f8ba46774017bcc5a5b2db7e947aafd75f90e15ad2ef46d6ec683bfc8d868a9205b9

data/CHANGELOG.md

@@ -1,12 +1,19 @@
-### next
+### 2.1.1 (Sep 21, 2024)
+
+#### Fixes
+
+* [#940](https://github.com/ruby-grape/grape-swagger/pull/940): Grape 2.2.0 compatibility - [@padde](https://github.com/padde)
+
+### 2.1.0 (May 14, 2024)
 
 #### Features
 
-* Your contribution here.
+* [#927](https://github.com/ruby-grape/grape-swagger/pull/927): Set default parameter location based on consumes - [@spaceraccoon](https://github.com/spaceraccoon)
+* [#929](https://github.com/ruby-grape/grape-swagger/pull/929): Set query parameter for array of primitive types - [@spaceraccoon](https://github.com/spaceraccoon)
 
 #### Fixes
 
-* Your contribution here.
+* [#926](https://github.com/ruby-grape/grape-swagger/pull/926): Refactor route and namespace combination logic - [@numbata](https://github.com/numbata)
 
 
 ### 2.0.3 (April 26, 2024)

data/grape-swagger.gemspec

@@ -15,8 +15,8 @@ Gem::Specification.new do |s|
   s.metadata['rubygems_mfa_required'] = 'true'
 
   s.required_ruby_version = '>= 3.0'
-  s.add_runtime_dependency 'grape', '>= 1.7', '< 3.0'
-  s.add_runtime_dependency 'rack-test', '~> 2'
+  s.add_dependency 'grape', '>= 1.7', '< 3.0'
+  s.add_dependency 'rack-test', '~> 2'
 
   s.files = Dir['lib/**/*', '*.md', 'LICENSE.txt', 'grape-swagger.gemspec']
   s.require_paths = ['lib']

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

@@ -75,6 +75,14 @@ module GrapeSwagger
           PRIMITIVE_MAPPINGS.keys.map(&:downcase)
         end
 
+        def query_array_primitive?(type)
+          query_array_primitives.include?(type.to_s.downcase)
+        end
+
+        def query_array_primitives
+          primitives << 'string'
+        end
+
         def mapping(value)
           PRIMITIVE_MAPPINGS[value] || 'string'
         end

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

@@ -4,7 +4,7 @@ module GrapeSwagger
   module DocMethods
     class ParseParams
       class << self
-        def call(param, settings, path, route, definitions)
+        def call(param, settings, path, route, definitions, consumes) # rubocop:disable Metrics/ParameterLists
           method = route.request_method
           additional_documentation = settings.fetch(:documentation, {})
           settings.merge!(additional_documentation)
@@ -14,7 +14,7 @@ module GrapeSwagger
 
           # required properties
           @parsed_param = {
-            in: param_type(value_type),
+            in: param_type(value_type, consumes),
             name: settings[:full_name] || param
           }
 
@@ -25,6 +25,7 @@ module GrapeSwagger
           document_default_value(settings) unless value_type[:is_array]
           document_range_values(settings) unless value_type[:is_array]
           document_required(settings)
+          document_length_limits(value_type)
           document_additional_properties(definitions, settings) unless value_type[:is_array]
           document_add_extensions(settings)
           document_example(settings)
@@ -70,21 +71,17 @@ module GrapeSwagger
 
         def document_array_param(value_type, definitions)
           if value_type[:documentation].present?
-            param_type = value_type[:documentation][:param_type] || value_type[:documentation][:in]
             doc_type = value_type[:documentation][:type]
             type = DataType.mapping(doc_type) if doc_type && !DataType.request_primitive?(doc_type)
             collection_format = value_type[:documentation][:collectionFormat]
           end
 
-          param_type ||= value_type[:param_type]
-
           array_items = parse_array_item(
             definitions,
             type,
             value_type
           )
 
-          @parsed_param[:in] = param_type || 'formData'
           @parsed_param[:items] = array_items
           @parsed_param[:type] = 'array'
           @parsed_param[:collectionFormat] = collection_format if DataType.collections.include?(collection_format)
@@ -148,19 +145,35 @@ module GrapeSwagger
           @parsed_param[:example] = example if example
         end
 
-        def param_type(value_type)
+        def param_type(value_type, consumes)
           param_type = value_type[:param_type] || value_type[:in]
-          if value_type[:path].include?("{#{value_type[:param_name]}}")
+          if !value_type[:is_array] && value_type[:path].include?("{#{value_type[:param_name]}}")
             'path'
           elsif param_type
             param_type
           elsif %w[POST PUT PATCH].include?(value_type[:method])
-            DataType.request_primitive?(value_type[:data_type]) ? 'formData' : 'body'
+            if consumes.include?('application/x-www-form-urlencoded') || consumes.include?('multipart/form-data')
+              'formData'
+            else
+              'body'
+            end
+          elsif value_type[:is_array] && !DataType.query_array_primitive?(value_type[:data_type])
+            'formData'
           else
             'query'
           end
         end
 
+        def document_length_limits(value_type)
+          if value_type[:is_array]
+            @parsed_param[:minItems] = value_type[:min_length] if value_type.key?(:min_length)
+            @parsed_param[:maxItems] = value_type[:max_length] if value_type.key?(:max_length)
+          else
+            @parsed_param[:minLength] = value_type[:min_length] if value_type.key?(:min_length)
+            @parsed_param[:maxLength] = value_type[:max_length] if value_type.key?(:max_length)
+          end
+        end
+
         def parse_enum_or_range_values(values)
           case values
           when Proc

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

@@ -7,7 +7,7 @@ module GrapeSwagger
         def call(*args)
           return ['application/json'] unless args.flatten.present?
 
-          args.flatten.map { |x| Grape::ContentTypes::CONTENT_TYPES[x] || x }.uniq
+          args.flatten.map { |x| GrapeSwagger::CONTENT_TYPE_DEFAULTS[x] || x }.uniq
         end
       end
     end

data/lib/grape-swagger/endpoint.rb

@@ -11,8 +11,8 @@ module Grape
 
       if content_types.empty?
         formats       = [target_class.format, target_class.default_format].compact.uniq
-        formats       = Grape::Formatter.formatters(**{}).keys if formats.empty?
-        content_types = Grape::ContentTypes::CONTENT_TYPES.select do |content_type, _mime_type|
+        formats       = GrapeSwagger::FORMATTER_DEFAULTS.keys if formats.empty?
+        content_types = GrapeSwagger::CONTENT_TYPE_DEFAULTS.select do |content_type, _mime_type|
           formats.include? content_type
         end.values
       end
@@ -119,7 +119,7 @@ module Grape
       method[:description] = description_object(route)
       method[:produces]    = produces_object(route, options[:produces] || options[:format])
       method[:consumes]    = consumes_object(route, options[:consumes] || options[:format])
-      method[:parameters]  = params_object(route, options, path)
+      method[:parameters]  = params_object(route, options, path, method[:consumes])
       method[:security]    = security_object(route)
       method[:responses]   = response_object(route, options)
       method[:tags]        = route.options.fetch(:tags, tag_object(route, path))
@@ -175,7 +175,7 @@ module Grape
       GrapeSwagger::DocMethods::ProducesConsumes.call(route.settings.dig(:description, :consumes) || format)
     end
 
-    def params_object(route, options, path)
+    def params_object(route, options, path, consumes)
       parameters = build_request_params(route, options).each_with_object([]) do |(param, value), memo|
         next if hidden_parameter?(value)
 
@@ -187,7 +187,7 @@ module Grape
         elsif value[:type]
           expose_params(value[:type])
         end
-        memo << GrapeSwagger::DocMethods::ParseParams.call(param, value, path, route, @definitions)
+        memo << GrapeSwagger::DocMethods::ParseParams.call(param, value, path, route, @definitions, consumes)
       end
 
       if GrapeSwagger::DocMethods::MoveParams.can_be_moved?(route.request_method, parameters)

data/lib/grape-swagger/version.rb

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

data/lib/grape-swagger.rb

@@ -18,13 +18,31 @@ module GrapeSwagger
     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 = {
+    json: Grape::Formatter::Json,
+    jsonapi: Grape::Formatter::Json,
+    serializable_hash: Grape::Formatter::SerializableHash,
+    txt: Grape::Formatter::Txt,
+    xml: Grape::Formatter::Xml
+  }.freeze
+
+  # Copied from https://github.com/ruby-grape/grape/blob/v2.2.0/lib/grape/content_types.rb
+  CONTENT_TYPE_DEFAULTS = {
+    xml: 'application/xml',
+    serializable_hash: 'application/json',
+    json: 'application/json',
+    binary: 'application/octet-stream',
+    txt: 'text/plain'
+  }.freeze
 end
 
 module SwaggerRouting
   private
 
   def combine_routes(app, doc_klass)
-    app.routes.each do |route|
+    app.routes.each_with_object({}) do |route, combined_routes|
       route_path = route.path
       route_match = route_path.split(/^.*?#{route.prefix}/).last
       next unless route_match
@@ -37,31 +55,30 @@ module SwaggerRouting
 
       resource = route_match.captures.first
       resource = '/' if resource.empty?
-      @target_class.combined_routes[resource] ||= []
+      combined_routes[resource] ||= []
       next if doc_klass.hide_documentation_path && route.path.match(/#{doc_klass.mount_path}($|\/|\(\.)/)
 
-      @target_class.combined_routes[resource] << route
+      combined_routes[resource] << route
     end
   end
 
-  def determine_namespaced_routes(name, parent_route)
-    if parent_route.nil?
-      @target_class.combined_routes.values.flatten
-    else
-      parent_route.reject do |route|
-        !route_path_start_with?(route, name) || !route_instance_variable_equals?(route, name)
-      end
+  def determine_namespaced_routes(name, parent_route, routes)
+    return routes.values.flatten if parent_route.nil?
+
+    parent_route.select do |route|
+      route_path_start_with?(route, name) || route_namespace_equals?(route, name)
     end
   end
 
-  def combine_namespace_routes(namespaces)
+  def combine_namespace_routes(namespaces, routes)
+    combined_namespace_routes = {}
     # iterate over each single namespace
     namespaces.each_key do |name, _|
       # get the parent route for the namespace
       parent_route_name = extract_parent_route(name)
-      parent_route = @target_class.combined_routes[parent_route_name]
+      parent_route = routes[parent_route_name]
       # fetch all routes that are within the current namespace
-      namespace_routes = determine_namespaced_routes(name, parent_route)
+      namespace_routes = determine_namespaced_routes(name, parent_route, routes)
 
       # default case when not explicitly specified or nested == true
       standalone_namespaces = namespaces.reject do |_, ns|
@@ -76,12 +93,13 @@ module SwaggerRouting
       # rubocop:disable Style/Next
       if parent_standalone_namespaces.empty?
         # default option, append namespace methods to parent route
-        parent_route = @target_class.combined_namespace_routes.key?(parent_route_name)
-        @target_class.combined_namespace_routes[parent_route_name] = [] unless parent_route
-        @target_class.combined_namespace_routes[parent_route_name].push(*namespace_routes)
+        combined_namespace_routes[parent_route_name] ||= []
+        combined_namespace_routes[parent_route_name].push(*namespace_routes)
       end
       # rubocop:enable Style/Next
     end
+
+    combined_namespace_routes
   end
 
   def extract_parent_route(name)
@@ -92,25 +110,32 @@ module SwaggerRouting
     matches.nil? ? route_name : matches[0].delete('/')
   end
 
-  def route_instance_variable(route)
-    route.instance_variable_get(:@options)[:namespace]
-  end
+  def route_namespace_equals?(route, name)
+    patterns = Enumerator.new do |yielder|
+      yielder << "/#{name}"
+      yielder << "/:version/#{name}"
+    end
 
-  def route_instance_variable_equals?(route, name)
-    route_instance_variable(route) == "/#{name}" ||
-      route_instance_variable(route) == "/:version/#{name}"
+    patterns.any? { |p| route.namespace == p }
   end
 
   def route_path_start_with?(route, name)
-    route_prefix = route.prefix ? "/#{route.prefix}/#{name}" : "/#{name}"
-    route_versioned_prefix = route.prefix ? "/#{route.prefix}/:version/#{name}" : "/:version/#{name}"
+    patterns = Enumerator.new do |yielder|
+      if route.prefix
+        yielder << "/#{route.prefix}/#{name}"
+        yielder << "/#{route.prefix}/:version/#{name}"
+      else
+        yielder << "/#{name}"
+        yielder << "/:version/#{name}"
+      end
+    end
 
-    route.path.start_with?(route_prefix, route_versioned_prefix)
+    patterns.any? { |p| route.path.start_with?(p) }
   end
 end
 
 module SwaggerDocumentationAdder
-  attr_accessor :combined_namespaces, :combined_namespace_identifiers, :combined_routes, :combined_namespace_routes
+  attr_accessor :combined_namespaces, :combined_routes, :combined_namespace_routes
 
   include SwaggerRouting
 
@@ -127,20 +152,16 @@ module SwaggerDocumentationAdder
     documentation_class.setup(options)
     mount(documentation_class)
 
-    @target_class.combined_routes = {}
-    combine_routes(@target_class, documentation_class)
+    combined_routes = combine_routes(@target_class, documentation_class)
+    combined_namespaces = combine_namespaces(@target_class)
+    combined_namespace_routes = combine_namespace_routes(combined_namespaces, combined_routes)
+    exclusive_route_keys = combined_routes.keys - combined_namespaces.keys
+    @target_class.combined_namespace_routes = combined_namespace_routes.merge(
+      combined_routes.slice(*exclusive_route_keys)
+    )
+    @target_class.combined_routes = combined_routes
+    @target_class.combined_namespaces = combined_namespaces
 
-    @target_class.combined_namespaces = {}
-    combine_namespaces(@target_class)
-
-    @target_class.combined_namespace_routes = {}
-    @target_class.combined_namespace_identifiers = {}
-    combine_namespace_routes(@target_class.combined_namespaces)
-
-    exclusive_route_keys = @target_class.combined_routes.keys - @target_class.combined_namespaces.keys
-    exclusive_route_keys.each do |key|
-      @target_class.combined_namespace_routes[key] = @target_class.combined_routes[key]
-    end
     documentation_class
   end
 
@@ -151,17 +172,24 @@ module SwaggerDocumentationAdder
   end
 
   def combine_namespaces(app)
-    app.endpoints.each do |endpoint|
+    combined_namespaces = {}
+    endpoints = app.endpoints.clone
+
+    while endpoints.any?
+      endpoint = endpoints.shift
+
+      endpoints.push(*endpoint.options[:app].endpoints) if endpoint.options[:app]
       ns = endpoint.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('/')
       full_namespace = (mount_path + endpoint.namespace).sub(/\/{2,}/, '/').sub(/^\//, '')
-      @target_class.combined_namespaces[full_namespace] = ns if ns
-
-      combine_namespaces(endpoint.options[:app]) if endpoint.options[:app]
+      combined_namespaces[full_namespace] = ns
     end
+
+    combined_namespaces
   end
 
   def create_documentation_class

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: grape-swagger
 version: !ruby/object:Gem::Version
-  version: 2.0.3
+  version: 2.1.1
 platform: ruby
 authors:
 - LeFnord
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-26 00:00:00.000000000 Z
+date: 2024-09-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: grape
@@ -103,7 +103,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Add auto generated documentation to your Grape API that can be displayed