grape-swagger 0.21.0 → 0.22.0

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

@@ -6,11 +6,9 @@ module GrapeSwagger
           path = route.path
           method = route.request_method
 
+          additional_documentation = settings.fetch(:documentation, {})
+          settings.merge!(additional_documentation)
           data_type = GrapeSwagger::DocMethods::DataType.call(settings)
-          additional_documentation = settings[:documentation]
-          if additional_documentation
-            settings = additional_documentation.merge(settings)
-          end
 
           value_type = settings.merge(data_type: data_type, path: path, param_name: param, method: method)
 
@@ -66,14 +64,18 @@ module GrapeSwagger
           if value_type[:is_array]
             if value_type[:documentation].present?
               param_type = value_type[:documentation][:param_type]
-              type = GrapeSwagger::DocMethods::DataType.mapping(value_type[:documentation][:type])
+              doc_type = value_type[:documentation][:type]
+              type = GrapeSwagger::DocMethods::DataType.mapping(doc_type) if doc_type && !DataType.request_primitive?(doc_type)
             end
-            array_items = { 'type' => type || value_type[:data_type] }
+
+            array_items = {
+              type: type || @parsed_param[:type],
+              format: @parsed_param.delete(:format)
+            }.delete_if { |_, value| value.blank? }
 
             @parsed_param[:in] = param_type || 'formData'
             @parsed_param[:items] = array_items
             @parsed_param[:type] = 'array'
-            @parsed_param.delete(:format)
           end
         end
 

data/lib/grape-swagger/endpoint.rb

@@ -24,6 +24,7 @@ module Grape
         swagger:        '2.0',
         produces:       content_types_for(target_class),
         authorizations: options[:authorizations],
+        securityDefinitions: options[:security_definitions],
         host:           GrapeSwagger::DocMethods::OptionalObject.build(:host, options, request),
         basePath:       GrapeSwagger::DocMethods::OptionalObject.build(:base_path, options, request),
         tags:           GrapeSwagger::DocMethods::TagNameDescription.build(options),
@@ -71,7 +72,6 @@ module Grape
       end
 
       add_definitions_from options[:models]
-      GrapeSwagger::DocMethods::MoveParams.to_definition(@paths, @definitions)
       [@paths, @definitions]
     end
 
@@ -109,7 +109,7 @@ module Grape
       method[:consumes]    = consumes_object(route, options[:format])
       method[:parameters]  = params_object(route)
       method[:responses]   = response_object(route, options[:markdown])
-      method[:tags]        = tag_object(route, options[:version].to_s)
+      method[:tags]        = tag_object(route)
       method[:operationId] = GrapeSwagger::DocMethods::OperationId.build(route, path)
       method.delete_if { |_, value| value.blank? }
 
@@ -154,11 +154,17 @@ module Grape
     end
 
     def params_object(route)
-      partition_params(route).map do |param, value|
+      parameters = partition_params(route).map do |param, value|
         value = { required: false }.merge(value) if value.is_a?(Hash)
         _, value = default_type([[param, value]]).first if value == ''
         GrapeSwagger::DocMethods::ParseParams.call(param, value, route)
       end
+
+      if GrapeSwagger::DocMethods::MoveParams.can_be_moved?(parameters, route.request_method)
+        parameters = GrapeSwagger::DocMethods::MoveParams.to_definition(parameters, route, @definitions)
+      end
+
+      parameters
     end
 
     def response_object(route, markdown)
@@ -194,8 +200,8 @@ module Grape
       end
     end
 
-    def tag_object(route, version)
-      Array(route.path.split('{')[0].split('/').reject(&:empty?).delete_if { |i| ((i == route.prefix.to_s) || (i == version)) }.first)
+    def tag_object(route)
+      Array(route.path.split('{')[0].split('/').reject(&:empty?).delete_if { |i| ((i == route.prefix.to_s) || (i == route.version)) }.first)
     end
 
     private
@@ -203,7 +209,7 @@ module Grape
     def partition_params(route)
       declared_params = route.settings[:declared_params] if route.settings[:declared_params].present?
       required, exposed = route.params.partition { |x| x.first.is_a? String }
-      required.concat GrapeSwagger::DocMethods::Headers.parse(route) unless route.headers.nil?
+      required = GrapeSwagger::DocMethods::Headers.parse(route) + required unless route.headers.nil?
       default_type(required)
       default_type(exposed)
 
@@ -221,20 +227,25 @@ module Grape
       end
     end
 
-    def parse_request_params(required)
-      required.each_with_object({}) do |param, memo|
-        @array_key = param.first.to_s.gsub('[', '[][') if param.last[:type] == 'Array'
-        possible_key = param.first.to_s.gsub('[', '[][')
-        if @array_key && possible_key.start_with?(@array_key)
-          key = possible_key
-          param.last[:is_array] = true
-        else
-          key = param.first
-        end
-        memo[key] = param.last unless param.last[:type] == 'Hash' || param.last[:type] == 'Array' && !param.last.key?(:documentation)
+    def parse_request_params(params)
+      array_key = nil
+      params.select { |param| public_parameter?(param) }.each_with_object({}) do |param, memo|
+        name, options = *param
+        array_key = name.to_s if param_type_is_array?(options[:type])
+        options[:is_array] = true if array_key && name.start_with?(array_key)
+        memo[param.first] = options unless (options[:type] == 'Hash' || options[:type] == 'Array') && !options.key?(:documentation)
       end
     end
 
+    def param_type_is_array?(param_type)
+      return false unless param_type
+      return true if param_type == 'Array'
+      param_types = param_type.match(/\[(.*)\]$/)
+      return false unless param_types
+      param_types = param_types[0].split(',') if param_types
+      param_types.size == 1
+    end
+
     def expose_params_from_model(model)
       model_name = model_name(model)
 
@@ -269,5 +280,13 @@ module Grape
       route_hidden = route_hidden.call if route_hidden.is_a?(Proc)
       route_hidden
     end
+
+    def public_parameter?(param)
+      param_options = param.last
+      return true unless param_options.key?(:documentation) && !param_options[:required]
+      param_hidden = param_options[:documentation].fetch(:hidden, false)
+      param_hidden = param_hidden.call if param_hidden.is_a?(Proc)
+      !param_hidden
+    end
   end
 end

data/lib/grape-swagger/version.rb

@@ -1,3 +1,3 @@
 module GrapeSwagger
-  VERSION = '0.21.0'.freeze
+  VERSION = '0.22.0'.freeze
 end

data/spec/lib/data_type_spec.rb

@@ -18,6 +18,18 @@ describe GrapeSwagger::DocMethods::DataType do
     it { expect(subject).to eql 'object' }
   end
 
+  describe 'Multi types in a string' do
+    let(:value) { { type: '[String, Integer]' } }
+
+    it { expect(subject).to eql 'string' }
+  end
+
+  describe 'Multi types in array' do
+    let(:value) { { type: [String, Integer] } }
+
+    it { expect(subject).to eql 'string' }
+  end
+
   describe 'Rack::Multipart::UploadedFile' do
     let(:value) { { type: Rack::Multipart::UploadedFile } }
 
@@ -53,4 +65,16 @@ describe GrapeSwagger::DocMethods::DataType do
 
     it { expect(subject).to eql 'string' }
   end
+
+  describe '[String]' do
+    let(:value) { { type: '[String]' } }
+
+    it { expect(subject).to eq('string') }
+  end
+
+  describe '[Integer]' do
+    let(:value) { { type: '[Integer]' } }
+
+    it { expect(subject).to eq('integer') }
+  end
 end

data/spec/lib/endpoint_spec.rb

@@ -2,4 +2,17 @@ require 'spec_helper'
 
 describe Grape::Endpoint do
   subject { described_class.new(Grape::Util::InheritableSetting.new, path: '/', method: :get) }
+
+  describe '#param_type_is_array?' do
+    it 'returns true if the value passed represents an array' do
+      expect(subject.send(:param_type_is_array?, 'Array')).to be_truthy
+      expect(subject.send(:param_type_is_array?, '[String]')).to be_truthy
+      expect(subject.send(:param_type_is_array?, 'Array[Integer]')).to be_truthy
+    end
+
+    it 'returns false if the value passed does not represent an array' do
+      expect(subject.send(:param_type_is_array?, 'String')).to be_falsey
+      expect(subject.send(:param_type_is_array?, '[String, Integer]')).to be_falsey
+    end
+  end
 end

data/spec/lib/move_params_spec.rb

@@ -7,86 +7,141 @@ describe GrapeSwagger::DocMethods::MoveParams do
 
   it { expect(subject.to_s).to eql 'GrapeSwagger::DocMethods::MoveParams' }
 
-  describe 'find_post_put' do
-    let(:paths) { {} }
+  describe 'parameters can_be_moved' do
+    let(:movable_params) do
+      [
+        { param_type: 'path', name: 'key', description: nil, type: 'integer', format: 'int32', required: true },
+        { param_type: 'body', name: 'in_body', description: 'in_body', type: 'integer', format: 'int32', required: true },
+        { param_type: 'query', name: 'in_query', description: 'in_query', type: 'integer', format: 'int32', required: true },
+        { param_type: 'header', name: 'in_header', description: 'in_header', type: 'integer', format: 'int32', required: true },
+        { param_type: 'formData', name: 'in_form_data', description: 'in_form_data', type: 'integer', format: 'int32', required: true }
+      ]
+    end
 
-    describe 'paths empty' do
-      specify { expect { |b| subject.find_post_put(paths, &b) }.not_to yield_control }
+    let(:not_movable_params) do
+      [
+        { in: 'path', name: 'key', description: nil, type: 'integer', format: 'int32', required: true },
+        { in: 'query', name: 'in_query', description: 'in_query', type: 'integer', format: 'int32', required: true },
+        { in: 'header', name: 'in_header', description: 'in_header', type: 'integer', format: 'int32', required: true },
+        { in: 'formData', name: 'in_form_data', description: 'in_form_data', type: 'integer', format: 'int32', required: true }
+      ]
     end
 
-    describe 'no post/put given' do
-      let(:paths) do
-        {
-          :'/foo' => { get: {}, delete: {} },
-          :'/bar/{key}' => { get: {}, delete: {} }
-        }
+    let(:allowed_verbs) do
+      [:post, :put, :patch, 'POST', 'PUT', 'PATCH']
+    end
+
+    let(:not_allowed_verbs) do
+      [:get, :delete, 'GET', 'DELETE']
+    end
+
+    describe 'movable params' do
+      specify 'allowed verbs' do
+        allowed_verbs.each do |verb|
+          expect(subject.can_be_moved?(movable_params, verb)).to be true
+        end
+      end
+
+      specify 'not allowed verbs' do
+        not_allowed_verbs.each do |verb|
+          expect(subject.can_be_moved?(movable_params, verb)).to be false
+        end
       end
-      specify { expect { |b| subject.find_post_put(paths, &b) }.not_to yield_control }
     end
 
-    describe 'no post/put given' do
-      let(:paths) do
-        {
-          :'/foo' => { get: {}, delete: {}, post: {}, put: {}, patch: {} },
-          :'/bar/{key}' => { get: {}, delete: {}, post: {}, put: {}, patch: {} }
-        }
+    describe 'not movable params' do
+      specify 'allowed verbs' do
+        allowed_verbs.each do |verb|
+          expect(subject.can_be_moved?(not_movable_params, verb)).to be false
+        end
+      end
+
+      specify 'not allowed verbs' do
+        not_allowed_verbs.each do |verb|
+          expect(subject.can_be_moved?(not_movable_params, verb)).to be false
+        end
+      end
+    end
+
+    describe 'movable_params' do
+      before do
+        subject.send(:unify!, movable_params)
       end
-      let(:expected) do
+      let(:expected_params) do
         [
-          { post: {}, put: {}, patch: {} },
-          { post: {}, put: {}, patch: {} }
+          { in: 'path', name: 'key', description: nil, type: 'integer', format: 'int32', required: true },
+          { in: 'query', name: 'in_query', description: 'in_query', type: 'integer', format: 'int32', required: true },
+          { in: 'header', name: 'in_header', description: 'in_header', type: 'integer', format: 'int32', required: true }
+        ]
+      end
+
+      let(:expected_movable_params) do
+        [
+          { in: 'body', name: 'in_body', description: 'in_body', type: 'integer', format: 'int32', required: true },
+          { in: 'body', name: 'in_form_data', description: 'in_form_data', type: 'integer', format: 'int32', required: true }
         ]
       end
-      specify { expect { |b| subject.find_post_put(paths, &b) }.to yield_control.twice }
-      specify { expect { |b| subject.find_post_put(paths, &b) }.to yield_successive_args *expected }
-    end
-  end
 
-  describe 'find_definition_and_params' do
-    specify do
-      subject.instance_variable_set(:@definitions, definitions)
-      subject.find_definition_and_params(found_path, :post)
-      expect(definitions.keys).to include 'InBody'
+      specify do
+        params_to_move = subject.send(:movable_params, movable_params)
+        expect(movable_params).to eql expected_params
+        expect(params_to_move).to eql expected_movable_params
+      end
     end
   end
 
-  describe 'move_params_to_new definition' do
-    let(:name) { 'Foo' }
-    let(:definitions) { {} }
-
-    describe 'post request' do
-      let(:verb) { 'post' }
+  describe 'parent_definition_of_params' do
+    describe 'POST' do
       let(:params) { paths['/in_body'][:post][:parameters] }
+      let(:options)  do
+        {
+          method: 'POST'
+        }
+      end
+      let(:env) { Rack::MockRequest.env_for('/in_body', options) }
+      let(:request) { Grape::Request.new(env) }
 
       specify do
-        subject.instance_variable_set(:@definitions, definitions)
-        name = subject.send(:build_definition, name, verb)
-        subject.move_params_to_new(name, params)
-
-        expect(definitions[name]).to eql expected_post_defs
-        expect(params).to be_empty
+        subject.to_definition(params, request, definitions)
+        expect(params).to eql(
+          [
+            { name: 'InBody', in: 'body', required: true, schema: { '$ref' => '#/definitions/postInBody' } }
+          ]
+        )
+        expect(subject.definitions['postInBody']).not_to include :description
+        expect(subject.definitions['postInBody']).to eql expected_post_defs
       end
     end
 
-    describe 'put request' do
-      let(:verb) { 'put' }
+    describe 'POST' do
       let(:params) { paths['/in_body/{key}'][:put][:parameters] }
+      let(:options)  do
+        {
+          method: 'PUT'
+        }
+      end
+      let(:env) { Rack::MockRequest.env_for('/in_body', options) }
+      let(:request) { Grape::Request.new(env) }
 
       specify do
-        subject.instance_variable_set(:@definitions, definitions)
-        name, definition = subject.send(:build_definition, name, verb)
-        subject.move_params_to_new(name, params)
-
-        expect(definitions[name]).to eql expected_put_defs
-        expect(params.length).to be 1
+        subject.to_definition(params, request, definitions)
+        expect(params).to eql(
+          [
+            { in: 'path', name: 'key', description: nil, type: 'integer', format: 'int32', required: true },
+            { name: 'InBody', in: 'body', required: true, schema: { '$ref' => '#/definitions/putInBody' } }
+          ]
+        )
+        expect(subject.definitions['putInBody']).not_to include :description
+        expect(subject.definitions['putInBody']).to eql expected_put_defs
       end
     end
   end
 
   describe 'nested definitions related' do
     describe 'prepare_nested_names' do
+      let(:property) { 'address' }
       before do
-        subject.send(:prepare_nested_names, params)
+        subject.send(:prepare_nested_names, property, params)
       end
 
       describe 'simple' do
@@ -106,8 +161,8 @@ describe GrapeSwagger::DocMethods::MoveParams do
       end
 
       describe 'array' do
-        let(:params) { [{ in: 'body', name: 'address[][street_lines]', description: 'street lines', type: 'array', required: true }] }
-        let(:expected) { [{ in: 'body', name: 'street_lines', description: 'street lines', type: 'array', required: true }] }
+        let(:params) { [{ in: 'body', name: 'address[street_lines]', description: 'street lines', type: 'array', items: { type: 'string' }, required: true }] }
+        let(:expected) { [{ in: 'body', name: 'street_lines', description: 'street lines', type: 'array', items: { type: 'string' }, required: true }] }
         specify do
           expect(params).to eql expected
         end
@@ -117,9 +172,10 @@ describe GrapeSwagger::DocMethods::MoveParams do
 
   describe 'private methods' do
     describe 'build_definition' do
+      let(:params) { [{ in: 'body', name: 'address[street][name]', description: 'street', type: 'string', required: true }] }
       before do
         subject.instance_variable_set(:@definitions, definitions)
-        subject.send(:build_definition, name, verb)
+        subject.send(:build_definition, name, params, verb)
       end
 
       describe 'verb given' do
@@ -129,8 +185,8 @@ describe GrapeSwagger::DocMethods::MoveParams do
 
         specify do
           definition = definitions.to_a.first
-          expect(definition.first).to eql 'postRequestFoo'
-          expect(definition.last).to eql(type: 'object', properties: {}, required: [])
+          expect(definition.first).to eql 'postFoo'
+          expect(definition.last).to eql(type: 'object', properties: {})
         end
       end
 
@@ -142,32 +198,20 @@ describe GrapeSwagger::DocMethods::MoveParams do
         specify do
           definition = definitions.to_a.first
           expect(definition.first).to eql 'FooBar'
-          expect(definition.last).to eql(type: 'object', properties: {}, required: [])
+          expect(definition.last).to eql(type: 'object', properties: {})
         end
       end
     end
 
     describe 'build_body_parameter' do
-      let(:response) { { schema: { '$ref' => '#/definitions/Somewhere' } } }
-
-      describe 'no name given' do
-        let(:name) { nil }
-        let(:expected_param) do
-          { name: 'Somewhere', in: 'body', required: true, schema: { '$ref' => '#/definitions/Somewhere' } }
-        end
-        specify do
-          parameter = subject.send(:build_body_parameter, response)
-          expect(parameter).to eql expected_param
-        end
-      end
-
       describe 'name given' do
         let(:name) { 'Foo' }
+        let(:reference) { 'Bar' }
         let(:expected_param) do
-          { name: 'Somewhere', in: 'body', required: true, schema: { '$ref' => "#/definitions/#{name}" } }
+          { name: name, in: 'body', required: true, schema: { '$ref' => "#/definitions/#{reference}" } }
         end
         specify do
-          parameter = subject.send(:build_body_parameter, response, name)
+          parameter = subject.send(:build_body_parameter, reference, name)
           expect(parameter).to eql expected_param
         end
       end
@@ -175,30 +219,17 @@ describe GrapeSwagger::DocMethods::MoveParams do
 
     describe 'parse_model' do
       let(:ref) { '#/definitions/InBody' }
-      subject(:object) { described_class.send(:parse_model, ref) }
-
-      specify { expect(object).to eql 'InBody' }
-    end
-
-    describe 'movable' do
-      describe 'path' do
-        let(:param) { { in: 'path', name: 'key', description: nil, type: 'integer', format: 'int32', required: true } }
-        it { expect(subject.send(:movable?, param)).to be true }
-      end
+      describe 'post request' do
+        subject(:object) { described_class.send(:parse_model, ref) }
 
-      describe 'body' do
-        let(:param) { { in: 'body', name: 'in_body', description: 'in_body', type: 'integer', format: 'int32', required: true } }
-        it { expect(subject.send(:movable?, param)).to be true }
+        specify { expect(object).to eql ref }
       end
 
-      describe 'query' do
-        let(:param) { { in: 'query', name: 'in_query', description: 'in_query', type: 'integer', format: 'int32', required: true } }
-        it { expect(subject.send(:movable?, param)).to be false }
-      end
+      describe 'post request' do
+        let(:put_ref) { '#/definitions/InBody/{id}' }
+        subject(:object) { described_class.send(:parse_model, put_ref) }
 
-      describe 'header' do
-        let(:param) { { in: 'header', name: 'in_header', description: 'in_header', type: 'integer', format: 'int32', required: true } }
-        it { expect(subject.send(:movable?, param)).to be false }
+        specify { expect(object).to eql ref }
       end
     end
 
@@ -224,32 +255,9 @@ describe GrapeSwagger::DocMethods::MoveParams do
       end
     end
 
-    describe 'should move' do
-      describe 'no move' do
-        let(:params) do
-          [
-            { in: 'path', name: 'key', description: nil, type: 'integer', format: 'int32', required: true },
-            { in: 'formData', name: 'in_form_data', description: 'in_form_data', type: 'integer', format: 'int32', required: true }
-          ]
-        end
-        it { expect(subject.send(:should_move?, params)).to be false }
-      end
-
-      describe 'move' do
-        let(:params) do
-          [
-            { in: 'path', name: 'key', description: nil, type: 'integer', format: 'int32', required: true },
-            { in: 'body', name: 'in_bosy', description: 'in_bosy', type: 'integer', format: 'int32', required: true },
-            { in: 'formData', name: 'in_form_data', description: 'in_form_data', type: 'integer', format: 'int32', required: true }
-          ]
-        end
-        it { expect(subject.send(:should_move?, params)).to be true }
-      end
-    end
-
     describe 'unify' do
-      before do
-        subject.send(:unify!, params) if subject.send(:should_move?, params)
+      before :each do
+        subject.send(:unify!, params)
       end
       describe 'param type with `:in` given' do
         let(:params) do