grape-swagger 0.33.0 → 0.34.2

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module GrapeSwagger
+  module DocMethods
+    class FormatData
+      class << self
+        def to_format(parameters)
+          parameters.reject { |parameter| parameter[:in] == 'body' }.each do |b|
+            related_parameters = parameters.select do |p|
+              p[:name] != b[:name] && p[:name].to_s.include?(b[:name].to_s.gsub(/\[\]\z/, '') + '[')
+            end
+            parameters.reject! { |p| p[:name] == b[:name] } if move_down(b, related_parameters)
+          end
+          parameters
+        end
+
+        def move_down(parameter, related_parameters)
+          case parameter[:type]
+          when 'array'
+            add_array(parameter, related_parameters)
+            unless related_parameters.blank?
+              add_braces(parameter, related_parameters) if parameter[:name].match?(/\A.*\[\]\z/)
+              return true
+            end
+          when 'object'
+            return true
+          end
+          false
+        end
+
+        def add_braces(parameter, related_parameters)
+          param_name = parameter[:name].gsub(/\A(.*)\[\]\z/, '\1')
+          related_parameters.each { |p| p[:name] = p[:name].gsub(param_name, param_name + '[]') }
+        end
+
+        def add_array(parameter, related_parameters)
+          related_parameters.each do |p|
+            p_type = p[:type] == 'array' ? 'string' : p[:type]
+            p[:items] = { type: p_type, format: p[:format], enum: p[:enum], is_array: p[:is_array] }
+            p[:items].delete_if { |_k, v| v.nil? }
+            p[:type] = 'array'
+            p[:is_array] = parameter[:is_array]
+            p.delete(:format)
+            p.delete(:enum)
+            p.delete_if { |_k, v| v.nil? }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,7 +8,7 @@ module GrapeSwagger
       class << self
         attr_accessor :definitions
 
-        def can_be_moved?(params, http_verb)
+        def can_be_moved?(http_verb, params)
           move_methods.include?(http_verb) && includes_body_param?(params)
         end
 
@@ -51,22 +51,33 @@ module GrapeSwagger
 
         def move_params_to_new(definition, params)
           params, nested_params = params.partition { |x| !x[:name].to_s.include?('[') }
-
-          unless params.blank?
-            properties, required = build_properties(params)
-            add_properties_to_definition(definition, properties, required)
+          params.each do |param|
+            property = param[:name]
+            param_properties, param_required = build_properties([param])
+            add_properties_to_definition(definition, param_properties, param_required)
+            related_nested_params, nested_params = nested_params.partition { |x| x[:name].start_with?("#{property}[") }
+            prepare_nested_names(property, related_nested_params)
+
+            next if related_nested_params.blank?
+
+            nested_definition = if should_expose_as_array?([param])
+                                  move_params_to_new(array_type, related_nested_params)
+                                else
+                                  move_params_to_new(object_type, related_nested_params)
+                                end
+            if definition.key?(:items)
+              definition[:items][:properties][property.to_sym].deep_merge!(nested_definition)
+            else
+              definition[:properties][property.to_sym].deep_merge!(nested_definition)
+            end
           end
-
-          nested_properties = build_nested_properties(nested_params) unless nested_params.blank?
-          add_properties_to_definition(definition, nested_properties, []) unless nested_params.blank?
+          definition
         end
 
         def build_properties(params)
           properties = {}
           required = []
 
-          prepare_nested_types(params) if should_expose_as_array?(params)
-
           params.each do |param|
             name = param[:name].to_sym
 
@@ -103,28 +114,6 @@ module GrapeSwagger
           end
         end
 
-        def build_nested_properties(params, properties = {})
-          property = params.bsearch { |x| x[:name].include?('[') }[:name].split('[').first
-
-          nested_params, params = params.partition { |x| x[:name].start_with?("#{property}[") }
-          prepare_nested_names(property, nested_params)
-
-          recursive_call(properties, property, nested_params) unless nested_params.empty?
-          build_nested_properties(params, properties) unless params.empty?
-
-          properties
-        end
-
-        def recursive_call(properties, property, nested_params)
-          if should_expose_as_array?(nested_params)
-            properties[property.to_sym] = array_type
-            move_params_to_new(properties[property.to_sym][:items], nested_params)
-          else
-            properties[property.to_sym] = object_type
-            move_params_to_new(properties[property.to_sym], nested_params)
-          end
-        end
-
         def movable_params(params)
           to_delete = params.each_with_object([]) { |x, memo| memo << x if deletable?(x) }
           delete_from(params, to_delete)
@@ -177,22 +166,6 @@ module GrapeSwagger
           { type: 'object', properties: {} }
         end
 
-        def prepare_nested_types(params)
-          params.each do |param|
-            next unless param[:items]
-
-            param[:type] = if param[:items][:type] == 'array'
-                             'string'
-                           elsif param[:items].key?('$ref')
-                             param[:type] = 'object'
-                           else
-                             param[:items][:type]
-                           end
-            param[:format] = param[:items][:format] if param[:items][:format]
-            param.delete(:items) if param[:type] != 'object'
-          end
-        end
-
         def prepare_nested_names(property, params)
           params.each { |x| x[:name] = x[:name].sub(property, '').sub('[', '').sub(']', '') }
         end
@@ -208,7 +181,7 @@ module GrapeSwagger
         end
 
         def property_keys
-          %i[type format description minimum maximum items enum default]
+          %i[type format description minimum maximum items enum default additionalProperties]
         end
 
         def deletable?(param)

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

@@ -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_additional_properties(settings)
 
           @parsed_param
         end
@@ -91,6 +92,11 @@ module GrapeSwagger
           @parsed_param[:collectionFormat] = collection_format if DataType.collections.include?(collection_format)
         end
 
+        def document_additional_properties(settings)
+          additional_properties = settings[:additionalProperties]
+          @parsed_param[:additionalProperties] = additional_properties if additional_properties
+        end
+
         def param_type(value_type)
           param_type = value_type[:param_type] || value_type[:in]
           if value_type[:path].include?("{#{value_type[:param_name]}}")

data/lib/grape-swagger/doc_methods.rb

@@ -4,6 +4,7 @@ require 'grape-swagger/doc_methods/status_codes'
 require 'grape-swagger/doc_methods/produces_consumes'
 require 'grape-swagger/doc_methods/data_type'
 require 'grape-swagger/doc_methods/extensions'
+require 'grape-swagger/doc_methods/format_data'
 require 'grape-swagger/doc_methods/operation_id'
 require 'grape-swagger/doc_methods/optional_object'
 require 'grape-swagger/doc_methods/path_string'
@@ -102,6 +103,7 @@ module GrapeSwagger
         base_path: nil,
         add_base_path: false,
         add_version: true,
+        add_root: false,
         hide_documentation_path: true,
         format: :json,
         authorizations: nil,

data/lib/grape-swagger/endpoint/params_parser.rb

@@ -15,37 +15,24 @@ module GrapeSwagger
       end
 
       def parse_request_params
-        array_keys = []
         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?
 
           if param_type_is_array?(param_type)
-            array_keys << name
             options[:is_array] = true
-
-            name += '[]' if array_use_braces?(options)
-          else
-            keys = array_keys.find_all { |key| name.start_with? "#{key}[" }
-            if keys.any?
-              options[:is_array] = true
-              if array_use_braces?(options)
-                keys.sort.reverse_each do |key|
-                  name = name.sub(key, "#{key}[]")
-                end
-              end
-            end
+            name += '[]' if array_use_braces?
           end
 
-          memo[name] = options unless %w[Hash Array].include?(param_type) && !options.key?(:documentation)
+          memo[name] = options
         end
       end
 
       private
 
-      def array_use_braces?(options)
-        settings[:array_use_braces] && !(options[:documentation] && options[:documentation][:param_type] == 'body')
+      def array_use_braces?
+        @array_use_braces ||= settings[:array_use_braces] && !includes_body_param?
       end
 
       def param_type_is_array?(param_type)
@@ -71,6 +58,12 @@ module GrapeSwagger
         param_hidden = param_hidden.call if param_hidden.is_a?(Proc)
         !param_hidden
       end
+
+      def includes_body_param?
+        params.any? do |_, options|
+          options.dig(:documentation, :param_type) == 'body' || options.dig(:documentation, :in) == 'body'
+        end
+      end
     end
   end
 end

data/lib/grape-swagger/endpoint.rb

@@ -78,8 +78,7 @@ module Grape
     def path_and_definition_objects(namespace_routes, options)
       @paths = {}
       @definitions = {}
-      namespace_routes.each_key do |key|
-        routes = namespace_routes[key]
+      namespace_routes.each_value do |routes|
         path_item(routes, options)
       end
 
@@ -121,7 +120,7 @@ module Grape
       method[:consumes]    = consumes_object(route, options[:format])
       method[:parameters]  = params_object(route, options, path)
       method[:security]    = security_object(route)
-      method[:responses]   = response_object(route)
+      method[:responses]   = response_object(route, options)
       method[:tags]        = route.options.fetch(:tags, tag_object(route, path))
       method[:operationId] = GrapeSwagger::DocMethods::OperationId.build(route, path)
       method[:deprecated] = deprecated_object(route)
@@ -179,22 +178,24 @@ module Grape
       parameters = partition_params(route, options).map do |param, value|
         value = { required: false }.merge(value) if value.is_a?(Hash)
         _, value = default_type([[param, value]]).first if value == ''
-        if value[:type]
-          expose_params(value[:type])
-        elsif value[:documentation]
+        if value.dig(:documentation, :type)
           expose_params(value[:documentation][:type])
+        elsif value[:type]
+          expose_params(value[:type])
         end
         GrapeSwagger::DocMethods::ParseParams.call(param, value, path, route, @definitions)
       end
 
-      if GrapeSwagger::DocMethods::MoveParams.can_be_moved?(parameters, route.request_method)
+      if GrapeSwagger::DocMethods::MoveParams.can_be_moved?(route.request_method, parameters)
         parameters = GrapeSwagger::DocMethods::MoveParams.to_definition(path, parameters, route, @definitions)
       end
 
+      GrapeSwagger::DocMethods::FormatData.to_format(parameters)
+
       parameters.presence
     end
 
-    def response_object(route)
+    def response_object(route, options)
       codes = http_codes_from_route(route)
       codes.map! { |x| x.is_a?(Array) ? { code: x[0], message: x[1], model: x[2], examples: x[3], headers: x[4] } : x }
 
@@ -219,7 +220,7 @@ module Grape
 
         @definitions[response_model][:description] = description_object(route)
 
-        memo[value[:code]][:schema] = build_reference(route, value, response_model)
+        memo[value[:code]][:schema] = build_reference(route, value, response_model, options)
         memo[value[:code]][:examples] = value[:examples] if value[:examples]
       end
     end
@@ -250,20 +251,38 @@ module Grape
     def tag_object(route, path)
       version = GrapeSwagger::DocMethods::Version.get(route)
       version = [version] unless version.is_a?(Array)
-
+      prefix = route.prefix.to_s.split('/').reject(&:empty?)
       Array(
         path.split('{')[0].split('/').reject(&:empty?).delete_if do |i|
-          i == route.prefix.to_s || version.map(&:to_s).include?(i)
+          prefix.include?(i) || version.map(&:to_s).include?(i)
         end.first
       ).presence
     end
 
     private
 
-    def build_reference(route, value, response_model)
+    def build_reference(route, value, response_model, settings)
       # TODO: proof that the definition exist, if model isn't specified
       reference = { '$ref' => "#/definitions/#{response_model}" }
-      route.options[:is_array] && value[:code] < 300 ? { type: 'array', items: reference } : reference
+      return reference unless value[:code] < 300
+
+      reference = { type: 'array', items: reference } if route.options[:is_array]
+      build_root(route, reference, response_model, settings)
+    end
+
+    def build_root(route, reference, response_model, settings)
+      default_root = response_model.underscore
+      default_root = default_root.pluralize if route.options[:is_array]
+      case route.settings.dig(:swagger, :root)
+      when true
+        { type: 'object', properties: { default_root => reference } }
+      when false
+        reference
+      when nil
+        settings[:add_root] ? { type: 'object', properties: { default_root => reference } } : reference
+      else
+        { type: 'object', properties: { route.settings.dig(:swagger, :root) => reference } }
+      end
     end
 
     def file_response?(value)

data/lib/grape-swagger/version.rb

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

data/lib/grape-swagger.rb

@@ -26,7 +26,7 @@ module SwaggerRouting
   def combine_routes(app, doc_klass)
     app.routes.each do |route|
       route_path = route.path
-      route_match = route_path.split(/^.*?#{route.prefix.to_s}/).last
+      route_match = route_path.split(/^.*?#{route.prefix}/).last
       next unless route_match
 
       route_match = route_match.match('\/([\w|-]*?)[\.\/\(]') || route_match.match('\/([\w|-]*)$')

data/spec/issues/751_deeply_nested_objects_spec.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe '751 deeply nested objects' do
+  let(:app) do
+    Class.new(Grape::API) do
+      content_type :json, 'application/json; charset=UTF-8'
+      default_format :json
+      class Vrp < Grape::API
+        def self.vrp_request_timewindow(this)
+          this.optional(:start, types: [String, Float, Integer])
+          this.optional(:end, types: [String, Float, Integer])
+        end
+
+        def self.vrp_request_point(this)
+          this.requires(:id, type: String, allow_blank: false)
+          this.optional(:matrix_index, type: Integer)
+          this.optional(:location, type: Hash) do
+            requires(:lat, type: Float, allow_blank: false)
+            requires(:lon, type: Float, allow_blank: false)
+          end
+          this.at_least_one_of :matrix_index, :location
+        end
+
+        def self.vrp_request_activity(this)
+          this.optional(:duration, types: [String, Float, Integer])
+          this.requires(:point_id, type: String, allow_blank: false)
+          this.optional(:timewindows, type: Array) do
+            Vrp.vrp_request_timewindow(self)
+          end
+        end
+
+        def self.vrp_request_service(this)
+          this.requires(:id, type: String, allow_blank: false)
+          this.optional(:skills, type: Array[String])
+
+          this.optional(:activity, type: Hash) do
+            Vrp.vrp_request_activity(self)
+          end
+          this.optional(:activities, type: Array) do
+            Vrp.vrp_request_activity(self)
+          end
+          this.mutually_exclusive :activity, :activities
+        end
+      end
+
+      namespace :vrp do
+        resource :submit do
+          desc 'Submit Problems', nickname: 'vrp'
+          params do
+            optional(:vrp, type: Hash, documentation: { param_type: 'body' }) do
+              optional(:points, type: Array) do
+                Vrp.vrp_request_point(self)
+              end
+
+              optional(:services, type: Array) do
+                Vrp.vrp_request_service(self)
+              end
+            end
+          end
+          post do
+            { vrp: params[:vrp] }.to_json
+          end
+        end
+      end
+
+      add_swagger_documentation format: :json
+    end
+  end
+
+  subject do
+    get '/swagger_doc'
+    JSON.parse(last_response.body)
+  end
+
+  describe 'Correctness of vrp Points' do
+    let(:get_points_response) { subject['definitions']['postVrpSubmit']['properties']['vrp']['properties']['points'] }
+    specify do
+      expect(get_points_response).to eql(
+        'type' => 'array',
+        'items' => {
+          'type' => 'object',
+          'properties' => {
+            'id' => {
+              'type' => 'string'
+            },
+            'matrix_index' => {
+              'type' => 'integer',
+              'format' => 'int32'
+            },
+            'location' => {
+              'type' => 'object',
+              'properties' => {
+                'lat' => {
+                  'type' => 'number',
+                  'format' => 'float'
+                },
+                'lon' => {
+                  'type' => 'number',
+                  'format' => 'float'
+                }
+              },
+              'required' => %w[lat lon]
+            }
+          },
+          'required' => ['id']
+        }
+      )
+    end
+  end
+
+  describe 'Correctness of vrp Services' do
+    let(:get_service_response) { subject['definitions']['postVrpSubmit']['properties']['vrp']['properties']['services'] }
+    specify do
+      expect(get_service_response).to include(
+        'type' => 'array',
+        'items' => {
+          'type' => 'object',
+          'properties' => {
+            'id' => {
+              'type' => 'string'
+            },
+            'skills' => {
+              'type' => 'array',
+              'items' => {
+                'type' => 'string'
+              }
+            },
+            'activity' => {
+              'type' => 'object',
+              'properties' => {
+                'duration' => {
+                  'type' => 'string'
+                },
+                'point_id' => {
+                  'type' => 'string'
+                },
+                'timewindows' => {
+                  'type' => 'array',
+                  'items' => {
+                    'type' => 'object',
+                    'properties' => {
+                      'start' => {
+                        'type' => 'string'
+                      },
+                      'end' => {
+                        'type' => 'string'
+                      }
+                    }
+                  }
+                }
+              },
+              'required' => ['point_id']
+            }, 'activities' => {
+              'type' => 'array',
+              'items' => {
+                'type' => 'object',
+                'properties' => {
+                  'duration' => {
+                    'type' => 'string'
+                  },
+                  'point_id' => {
+                    'type' => 'string'
+                  },
+                  'timewindows' => {
+                    'type' => 'array',
+                    'items' => {
+                      'type' => 'object',
+                      'properties' => {
+                        'start' => {
+                          'type' => 'string'
+                        },
+                        'end' => {
+                          'type' => 'string'
+                        }
+                      }
+                    }
+                  }
+                },
+                'required' => ['point_id']
+              }
+            }
+          },
+          'required' => ['id']
+        }
+      )
+    end
+  end
+end

data/spec/lib/endpoint/params_parser_spec.rb

@@ -46,39 +46,63 @@ describe GrapeSwagger::Endpoint::ParamsParser do
     context 'when param is nested in a param of array type' do
       let(:params) { [['param_1', { type: 'Array' }], ['param_1[param_2]', { type: 'String' }]] }
 
-      it 'skips root parameter' do
-        is_expected.not_to have_key 'param_1'
-      end
-
-      it 'adds is_array option to the nested param' do
-        expect(parse_request_params['param_1[param_2]']).to eq(type: 'String', is_array: true)
-      end
-
       context 'and array_use_braces setting set to true' do
         let(:settings) { { array_use_braces: true } }
 
         it 'adds braces to the param key' do
-          expect(parse_request_params.keys.first).to eq 'param_1[][param_2]'
+          expect(parse_request_params.keys.last).to eq 'param_1[param_2]'
         end
       end
     end
 
     context 'when param is nested in a param of hash type' do
-      let(:params) { [['param_1', { type: 'Hash' }], ['param_1[param_2]', { type: 'String' }]] }
-
-      it 'skips root parameter' do
-        is_expected.not_to have_key 'param_1'
-      end
-
-      it 'does not change options to the nested param' do
-        expect(parse_request_params['param_1[param_2]']).to eq(type: 'String')
-      end
+      let(:params) { [param_1, param_2] }
+      let(:param_1) { ['param_1', { type: 'Hash' }] }
+      let(:param_2) { ['param_1[param_2]', { type: 'String' }] }
 
       context 'and array_use_braces setting set to true' do
         let(:settings) { { array_use_braces: true } }
 
-        it 'does not add braces to the param key' do
-          expect(parse_request_params.keys.first).to eq 'param_1[param_2]'
+        context 'and param is of simple type' do
+          it 'does not add braces to the param key' do
+            expect(parse_request_params.keys.last).to eq 'param_1[param_2]'
+          end
+        end
+
+        context 'and param is of array type' do
+          let(:param_2) { ['param_1[param_2]', { type: 'Array[String]' }] }
+
+          it 'adds braces to the param key' do
+            expect(parse_request_params.keys.last).to eq 'param_1[param_2][]'
+          end
+
+          context 'and `param_type` option is set to body' do
+            let(:param_2) do
+              ['param_1[param_2]', { type: 'Array[String]', documentation: { param_type: 'body' } }]
+            end
+
+            it 'does not add braces to the param key' do
+              expect(parse_request_params.keys.last).to eq 'param_1[param_2]'
+            end
+          end
+
+          context 'and `in` option is set to body' do
+            let(:param_2) do
+              ['param_1[param_2]', { type: 'Array[String]', documentation: { in: 'body' } }]
+            end
+
+            it 'does not add braces to the param key' do
+              expect(parse_request_params.keys.last).to eq 'param_1[param_2]'
+            end
+          end
+
+          context 'and hash `param_type` option is set to body' do
+            let(:param_1) { ['param_1', { type: 'Hash', documentation: { param_type: 'body' } }] }
+
+            it 'does not add braces to the param key' do
+              expect(parse_request_params.keys.last).to eq 'param_1[param_2]'
+            end
+          end
         end
       end
     end

data/spec/lib/endpoint_spec.rb

@@ -109,7 +109,7 @@ describe Grape::Endpoint do
           ['id', { required: true, type: 'String' }],
           ['description', { required: false, type: 'String' }],
           ['stuffs', { required: true, type: 'Array', is_array: true }],
-          ['stuffs[id]', { required: true, type: 'String', is_array: true }]
+          ['stuffs[id]', { required: true, type: 'String' }]
         ]
       end
 
@@ -138,8 +138,8 @@ describe Grape::Endpoint do
             ['stuffs', { required: true, type: 'Array', is_array: true }],
             ['stuffs[owners]', { required: true, type: 'Array', is_array: true }],
             ['stuffs[creators]', { required: true, type: 'Array', is_array: true }],
-            ['stuffs[owners][id]', { required: true, type: 'String', is_array: true }],
-            ['stuffs[creators][id]', { required: true, type: 'String', is_array: true }],
+            ['stuffs[owners][id]', { required: true, type: 'String' }],
+            ['stuffs[creators][id]', { required: true, type: 'String' }],
             ['stuffs_and_things', { required: true, type: 'String' }]
           ]
         end