grape-swagger 0.33.0 → 0.34.0

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/version.rb

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

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

data/spec/lib/extensions_spec.rb

@@ -3,6 +3,16 @@
 require 'spec_helper'
 
 describe GrapeSwagger::DocMethods::Extensions do
+  context 'it should not break method introspection' do
+    describe '.method' do
+      describe 'method introspection' do
+        specify do
+          expect(described_class.method(described_class.methods.first)).to be_a(Method)
+        end
+      end
+    end
+  end
+
   describe '#find_definition' do
     subject { described_class }
 

data/spec/lib/format_data_spec.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe GrapeSwagger::DocMethods::FormatData do
+  let(:subject) { GrapeSwagger::DocMethods::FormatData }
+
+  [true, false].each do |array_use_braces|
+    context 'when param is nested in a param of array type' do
+      let(:braces) { array_use_braces ? '[]' : '' }
+      let(:params) do
+        [
+          { in: 'formData', name: "param1#{braces}", type: 'array', items: { type: 'string' } },
+          { in: 'formData', name: 'param1[param2]', type: 'string' }
+        ]
+      end
+
+      it 'skips root parameter' do
+        expect(subject.to_format(params).first).not_to have_key "param1#{braces}"
+      end
+
+      it 'Move array type to param2' do
+        expect(subject.to_format(params).first).to include(name: "param1#{braces}[param2]", type: 'array')
+      end
+    end
+  end
+
+  context 'when param is nested in a param of hash type' do
+    let(:params) { [{ in: 'formData', type: 'object', name: 'param1' }, { in: 'formData', name: 'param1[param2]', type: 'string' }] }
+
+    it 'skips root parameter' do
+      expect(subject.to_format(params).first).not_to have_key 'param1'
+    end
+
+    it 'Move array type to param2' do
+      expect(subject.to_format(params).first).to include(name: 'param1[param2]', type: 'string')
+    end
+  end
+
+  context 'when params contain a complex array' do
+    let(:params) do
+      [
+        { name: 'id', required: true, type: 'string' },
+        { name: 'description', required: false, type: 'string' },
+        { name: 'stuffs', required: true, type: 'array' },
+        { name: 'stuffs[id]', required: true, type: 'string' }
+      ]
+    end
+
+    let(:expected_params) do
+      [
+        { name: 'id', required: true, type: 'string' },
+        { name: 'description', required: false, type: 'string' },
+        { name: 'stuffs[id]', required: true, type: 'array', items: { type: 'string' } }
+      ]
+    end
+
+    it 'parses params correctly and adds array type all concerned elements' do
+      expect(subject.to_format(params)).to eq expected_params
+    end
+
+    context 'when array params are not contiguous with parent array' do
+      let(:params) do
+        [
+          { name: 'id', required: true, type: 'string' },
+          { name: 'description', required: false, type: 'string' },
+          { name: 'stuffs', required: true, type: 'array' },
+          { name: 'stuffs[owners]', required: true, type: 'array' },
+          { name: 'stuffs[creators]', required: true, type: 'array' },
+          { name: 'stuffs[owners][id]', required: true, type: 'string' },
+          { name: 'stuffs[creators][id]', required: true, type: 'string' },
+          { name: 'stuffs_and_things', required: true, type: 'string' }
+        ]
+      end
+
+      let(:expected_params) do
+        [
+          { name: 'id', required: true, type: 'string' },
+          { name: 'description', required: false, type: 'string' },
+          { name: 'stuffs[owners][id]', required: true, type: 'array', items: { type: 'string' } },
+          { name: 'stuffs[creators][id]', required: true, type: 'array', items: { type: 'string' } },
+          { name: 'stuffs_and_things', required: true, type: 'string' }
+        ]
+      end
+
+      it 'parses params correctly and adds array type all concerned elements' do
+        expect(subject.to_format(params)).to eq expected_params
+      end
+    end
+  end
+end