grape-swagger 0.20.2 → 0.20.3

data/lib/grape-swagger/grape/route.rb

@@ -0,0 +1,16 @@
+# backwards compatibility for Grape < 0.16.0
+module Grape
+  class Route
+    [:path, :prefix, :entity, :description, :settings, :params, :headers, :http_codes].each do |m|
+      define_method m do
+        send "route_#{m}"
+      end
+    end
+
+    def request_method
+      route_method
+    end
+
+    attr_reader :options
+  end
+end if defined?(Grape::VERSION) && Gem::Version.new(::Grape::VERSION) < Gem::Version.new('0.16.0')

data/lib/grape-swagger/version.rb

@@ -1,3 +1,3 @@
 module GrapeSwagger
-  VERSION = '0.20.2'.freeze
+  VERSION = '0.20.3'.freeze
 end

data/spec/issues/403_versions_spec.rb

@@ -0,0 +1,158 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe 'describing versions' do
+  describe 'nothings given' do
+    def app
+      Class.new(Grape::API) do
+        desc 'no versions given'
+        get '/nothings' do
+          { message: 'hello world …' }
+        end
+
+        add_swagger_documentation format: :json
+      end
+    end
+
+    subject do
+      get '/swagger_doc'
+      JSON.parse(last_response.body, symbolize_names: true)
+    end
+
+    specify do
+      expect(subject).to eql(
+        info: { title: 'API title', version: '0.0.1' },
+        swagger: '2.0',
+        produces: ['application/xml', 'application/json', 'application/octet-stream', 'text/plain'],
+        host: 'example.org',
+        tags: [{ name: 'nothings', description: 'Operations about nothings' }],
+        paths: {
+          :'/nothings' => {
+            get: {
+              description: 'no versions given',
+              produces: ['application/json'],
+              responses: {
+                :'200' => { description: 'no versions given' }
+              },
+              tags: ['nothings'],
+              operationId: 'getNothings'
+            } } })
+    end
+  end
+
+  describe 'API version given' do
+    def app
+      Class.new(Grape::API) do
+        version 'v2', using: :path
+        desc 'api versions given'
+        get '/api_version' do
+          { message: 'hello world …' }
+        end
+
+        add_swagger_documentation format: :json
+      end
+    end
+
+    subject do
+      get '/v2/swagger_doc'
+      JSON.parse(last_response.body, symbolize_names: true)
+    end
+
+    specify do
+      expect(subject).to eql(
+        info: { title: 'API title', version: '0.0.1' },
+        swagger: '2.0',
+        produces: ['application/xml', 'application/json', 'application/octet-stream', 'text/plain'],
+        host: 'example.org',
+        tags: [{ name: 'api_version', description: 'Operations about api_versions' }],
+        paths: {
+          :'/v2/api_version' => {
+            get: {
+              description: 'api versions given',
+              produces: ['application/json'],
+              responses: {
+                :'200' => { description: 'api versions given' }
+              },
+              tags: ['api_version'],
+              operationId: 'getV2ApiVersion'
+            } } })
+    end
+  end
+
+  describe 'DOC version given' do
+    def app
+      Class.new(Grape::API) do
+        desc 'doc versions given'
+        get '/doc_version' do
+          { message: 'hello world …' }
+        end
+
+        add_swagger_documentation doc_version: '0.0.2'
+      end
+    end
+
+    subject do
+      get '/swagger_doc'
+      JSON.parse(last_response.body, symbolize_names: true)
+    end
+
+    specify do
+      expect(subject).to eql(
+        info: { title: 'API title', version: '0.0.2' },
+        swagger: '2.0',
+        produces: ['application/xml', 'application/json', 'application/octet-stream', 'text/plain'],
+        host: 'example.org',
+        tags: [{ name: 'doc_version', description: 'Operations about doc_versions' }],
+        paths: {
+          :'/doc_version' => {
+            get: {
+              description: 'doc versions given',
+              produces: ['application/json'],
+              responses: {
+                :'200' => { description: 'doc versions given' }
+              },
+              tags: ['doc_version'],
+              operationId: 'getDocVersion'
+            } } })
+    end
+  end
+
+  describe 'both versions given' do
+    def app
+      Class.new(Grape::API) do
+        version :v2, using: :path
+        desc 'both versions given'
+        get '/both_versions' do
+          { message: 'hello world …' }
+        end
+
+        add_swagger_documentation doc_version: '0.0.2'
+      end
+    end
+
+    subject do
+      get '/v2/swagger_doc'
+      JSON.parse(last_response.body, symbolize_names: true)
+    end
+
+    specify do
+      expect(subject).to eql(
+        info: { title: 'API title', version: '0.0.2' },
+        swagger: '2.0',
+        produces: ['application/xml', 'application/json', 'application/octet-stream', 'text/plain'],
+        host: 'example.org',
+        tags: [{ name: 'both_versions', description: 'Operations about both_versions' }],
+        paths: {
+          :'/v2/both_versions' => {
+            get: {
+              description: 'both versions given',
+              produces: ['application/json'],
+              responses: {
+                :'200' => { description: 'both versions given' }
+              },
+              tags: ['both_versions'],
+              operationId: 'getV2BothVersions'
+            } } })
+    end
+  end
+end

data/spec/lib/data_type_spec.rb

@@ -1,55 +1,54 @@
 require 'spec_helper'
 
 describe GrapeSwagger::DocMethods::DataType do
-
   subject { described_class.call(value) }
 
-  describe "standards" do
+  describe 'standards' do
     ['Boolean', Date, Integer, String, Float].each do |type|
       specify do
-        data_type = described_class.call({ type: type })
+        data_type = described_class.call(type: type)
         expect(data_type).to eql type.to_s.downcase
       end
     end
   end
 
-  describe "Hash" do
+  describe 'Hash' do
     let(:value) { { type: Hash } }
 
     it { expect(subject).to eql 'object' }
   end
 
-  describe "Rack::Multipart::UploadedFile" do
+  describe 'Rack::Multipart::UploadedFile' do
     let(:value) { { type: Rack::Multipart::UploadedFile } }
 
     it { expect(subject).to eql 'file' }
   end
 
-  describe "Virtus::Attribute::Boolean" do
+  describe 'Virtus::Attribute::Boolean' do
     let(:value) { { type: Virtus::Attribute::Boolean } }
 
     it { expect(subject).to eql 'boolean' }
   end
 
-  describe "BigDecimal" do
+  describe 'BigDecimal' do
     let(:value) { { type: BigDecimal } }
 
     it { expect(subject).to eql 'double' }
   end
 
-  describe "DateTime" do
+  describe 'DateTime' do
     let(:value) { { type: DateTime } }
 
     it { expect(subject).to eql 'dateTime' }
   end
 
-  describe "Numeric" do
+  describe 'Numeric' do
     let(:value) { { type: Numeric } }
 
     it { expect(subject).to eql 'long' }
   end
 
-  describe "Symbol" do
+  describe 'Symbol' do
     let(:value) { { type: Symbol } }
 
     it { expect(subject).to eql 'string' }

data/spec/lib/endpoint_spec.rb

@@ -1,6 +1,5 @@
 require 'spec_helper'
 
 describe Grape::Endpoint do
-  subject { described_class.new(Grape::Util::InheritableSetting.new, {path: '/', method: :get}) }
-
+  subject { described_class.new(Grape::Util::InheritableSetting.new, path: '/', method: :get) }
 end

data/spec/lib/extensions_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
 describe GrapeSwagger::DocMethods::Extensions do
-  describe "#extended? and extension" do
+  describe '#extended? and extension' do
     subject { described_class }
-    describe "return false (default)" do
-      let(:part) { {foo: 'bar', bar: 'foo'} }
+    describe 'return false (default)' do
+      let(:part) { { foo: 'bar', bar: 'foo' } }
 
       specify do
         expect(subject.extended?(part)).to be false
@@ -12,42 +12,42 @@ describe GrapeSwagger::DocMethods::Extensions do
       end
     end
 
-    describe "return true" do
+    describe 'return true' do
       specify do
         part = { foo: 'bar', bar: 'foo', x: 'something' }
         expect(subject.extended?(part)).to be true
-        expect(subject.extension(part)).to eql({ x: 'something' })
+        expect(subject.extension(part)).to eql(x: 'something')
         expect(subject.extended?(part, :x)).to be true
-        expect(subject.extension(part, :x)).to eql({ x: 'something' })
+        expect(subject.extension(part, :x)).to eql(x: 'something')
       end
 
       specify do
         part = { foo: 'bar', bar: 'foo', x_path: 'something' }
         expect(subject.extended?(part, :x_path)).to be true
-        expect(subject.extension(part, :x_path)).to eql({ x_path: 'something' })
+        expect(subject.extension(part, :x_path)).to eql(x_path: 'something')
       end
 
       specify do
         part = { foo: 'bar', bar: 'foo', x_def: 'something' }
         expect(subject.extended?(part, :x_def)).to be true
-        expect(subject.extension(part, :x_def)).to eql({ x_def: 'something' })
+        expect(subject.extension(part, :x_def)).to eql(x_def: 'something')
       end
 
       specify do
         part = { foo: 'bar', bar: 'foo', x_path: 'something', x_def: 'something' }
         expect(subject.extended?(part, :x_path)).to be true
-        expect(subject.extension(part, :x_path)).to eql({ x_path: 'something' })
+        expect(subject.extension(part, :x_path)).to eql(x_path: 'something')
         expect(subject.extended?(part, :x_def)).to be true
-        expect(subject.extension(part, :x_def)).to eql({ x_def: 'something' })
+        expect(subject.extension(part, :x_def)).to eql(x_def: 'something')
       end
     end
   end
 
-  describe "concatenate" do
-    describe "not nested" do
-      describe "simple" do
-        let(:extensions) { {x: {key_1: 'foo'}} }
-        let(:result) { {'x-key_1' => 'foo'} }
+  describe 'concatenate' do
+    describe 'not nested' do
+      describe 'simple' do
+        let(:extensions) { { x: { key_1: 'foo' } } }
+        let(:result) { { 'x-key_1' => 'foo' } }
         subject { described_class.concatenate(extensions) }
 
         specify do
@@ -55,9 +55,9 @@ describe GrapeSwagger::DocMethods::Extensions do
         end
       end
 
-      describe "multiple" do
-        let(:extensions) { {x: {key_1: 'foo', key_2: 'bar'}} }
-        let(:result) { {'x-key_1' => 'foo', 'x-key_2' => 'bar'} }
+      describe 'multiple' do
+        let(:extensions) { { x: { key_1: 'foo', key_2: 'bar' } } }
+        let(:result) { { 'x-key_1' => 'foo', 'x-key_2' => 'bar' } }
         subject { described_class.concatenate(extensions) }
 
         specify do
@@ -66,10 +66,10 @@ describe GrapeSwagger::DocMethods::Extensions do
       end
     end
 
-    describe "nested" do
-      describe "simple" do
-        let(:extensions) { {x: {key_1: { key_2: 'foo'}}} }
-        let(:result) { {'x-key_1' => { key_2: 'foo'}} }
+    describe 'nested' do
+      describe 'simple' do
+        let(:extensions) { { x: { key_1: { key_2: 'foo' } } } }
+        let(:result) { { 'x-key_1' => { key_2: 'foo' } } }
         subject { described_class.concatenate(extensions) }
 
         specify do
@@ -77,9 +77,9 @@ describe GrapeSwagger::DocMethods::Extensions do
         end
       end
 
-      describe "simple multiple" do
-        let(:extensions) { {x: {key_1: { key_2: 'foo', key_3: 'bar'}}} }
-        let(:result) { {'x-key_1' => { key_2: 'foo', key_3: 'bar'}} }
+      describe 'simple multiple' do
+        let(:extensions) { { x: { key_1: { key_2: 'foo', key_3: 'bar' } } } }
+        let(:result) { { 'x-key_1' => { key_2: 'foo', key_3: 'bar' } } }
         subject { described_class.concatenate(extensions) }
 
         specify do
@@ -87,9 +87,9 @@ describe GrapeSwagger::DocMethods::Extensions do
         end
       end
 
-      describe "simple deeper" do
-        let(:extensions) { {x: {key_1: { key_2: {key_3: 'foo'}}}} }
-        let(:result) { {'x-key_1' => { key_2: {key_3: 'foo'}}} }
+      describe 'simple deeper' do
+        let(:extensions) { { x: { key_1: { key_2: { key_3: 'foo' } } } } }
+        let(:result) { { 'x-key_1' => { key_2: { key_3: 'foo' } } } }
         subject { described_class.concatenate(extensions) }
 
         specify do
@@ -97,9 +97,9 @@ describe GrapeSwagger::DocMethods::Extensions do
         end
       end
 
-      describe "multiple" do
-        let(:extensions) { {x: {key_1: { key_3: 'foo'}, key_2: { key_3: 'bar' }}} }
-        let(:result) { {'x-key_1' => { key_3: 'foo'}, 'x-key_2' => { key_3: 'bar' }} }
+      describe 'multiple' do
+        let(:extensions) { { x: { key_1: { key_3: 'foo' }, key_2: { key_3: 'bar' } } } }
+        let(:result) { { 'x-key_1' => { key_3: 'foo' }, 'x-key_2' => { key_3: 'bar' } } }
         subject { described_class.concatenate(extensions) }
 
         specify do
@@ -108,15 +108,19 @@ describe GrapeSwagger::DocMethods::Extensions do
       end
     end
 
-    describe "reale example" do
-      let(:extensions) { {x: {
-        'amazon-apigateway-auth' => {type: 'none'},
-        'amazon-apigateway-integration' => {type: 'aws', uri: 'foo_bar_uri', httpMethod: 'get'}
-      }} }
-      let(:result) { {
-        'x-amazon-apigateway-auth' => {type: 'none'},
-        'x-amazon-apigateway-integration' => {type: 'aws', uri: 'foo_bar_uri', httpMethod: 'get'}
-      } }
+    describe 'real example' do
+      let(:extensions) do
+        { x: {
+          'amazon-apigateway-auth' => { type: 'none' },
+          'amazon-apigateway-integration' => { type: 'aws', uri: 'foo_bar_uri', httpMethod: 'get' }
+        } }
+      end
+      let(:result) do
+        {
+          'x-amazon-apigateway-auth' => { type: 'none' },
+          'x-amazon-apigateway-integration' => { type: 'aws', uri: 'foo_bar_uri', httpMethod: 'get' }
+        }
+      end
       subject { described_class.concatenate(extensions) }
 
       specify do

data/spec/lib/move_params_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe GrapeSwagger::DocMethods::MoveParams do
-  include_context "the api paths/defs"
+  include_context 'the api paths/defs'
 
   subject { described_class }
 
@@ -15,22 +15,28 @@ describe GrapeSwagger::DocMethods::MoveParams do
     end
 
     describe 'no post/put given' do
-      let(:paths) {{
-        :'/foo'=> { get: {}, delete: {}},
-        :'/bar/{key}'=> { get: {}, delete: {}},
-      }}
+      let(:paths) do
+        {
+          :'/foo' => { get: {}, delete: {} },
+          :'/bar/{key}' => { get: {}, delete: {} }
+        }
+      end
       specify { expect { |b| subject.find_post_put(paths, &b) }.not_to yield_control }
     end
 
     describe 'no post/put given' do
-      let(:paths) {{
-        :'/foo'=> { get: {}, delete: {}, post: {}, put: {}, patch: {} },
-        :'/bar/{key}'=> { get: {}, delete: {}, post: {}, put: {}, patch: {}},
-      }}
-      let(:expected) {[
-        { post: {}, put: {}, patch: {}},
-        { post: {}, put: {}, patch: {}},
-      ]}
+      let(:paths) do
+        {
+          :'/foo' => { get: {}, delete: {}, post: {}, put: {}, patch: {} },
+          :'/bar/{key}' => { get: {}, delete: {}, post: {}, put: {}, patch: {} }
+        }
+      end
+      let(:expected) do
+        [
+          { post: {}, put: {}, patch: {} },
+          { post: {}, put: {}, patch: {} }
+        ]
+      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
@@ -39,19 +45,18 @@ describe GrapeSwagger::DocMethods::MoveParams do
   describe 'find_definition_and_params' do
     specify do
       subject.instance_variable_set(:@definitions, definitions)
-      subject.find_definition_and_params(found_path)
-
-      expect(definitions.keys).to include 'InBody', 'postRequestInBody'
+      subject.find_definition_and_params(found_path, :post)
+      expect(definitions.keys).to include 'InBody'
     end
   end
 
   describe 'move_params_to_new definition' do
     let(:name) { 'Foo' }
-    let(:definitions) {{}}
+    let(:definitions) { {} }
 
     describe 'post request' do
       let(:verb) { 'post' }
-      let(:params) { paths["/in_body"][:post][:parameters] }
+      let(:params) { paths['/in_body'][:post][:parameters] }
 
       specify do
         subject.instance_variable_set(:@definitions, definitions)
@@ -65,7 +70,7 @@ describe GrapeSwagger::DocMethods::MoveParams do
 
     describe 'put request' do
       let(:verb) { 'put' }
-      let(:params) { paths["/in_body/{key}"][:put][:parameters] }
+      let(:params) { paths['/in_body/{key}'][:put][:parameters] }
 
       specify do
         subject.instance_variable_set(:@definitions, definitions)
@@ -85,24 +90,24 @@ describe GrapeSwagger::DocMethods::MoveParams do
       end
 
       describe 'simple' do
-        let(:params) {[{:in=>"body", :name=>"address[street]", :description=>"street", :type=>"string", :required=>true}]}
-        let(:expected) {[{:in=>"body", :name=>"street", :description=>"street", :type=>"string", :required=>true}]}
+        let(:params) { [{ in: 'body', name: 'address[street]', description: 'street', type: 'string', required: true }] }
+        let(:expected) { [{ in: 'body', name: 'street', description: 'street', type: 'string', required: true }] }
         specify do
           expect(params).to eql expected
         end
       end
 
       describe 'nested' do
-        let(:params) {[{:in=>"body", :name=>"address[street][name]", :description=>"street", :type=>"string", :required=>true}]}
-        let(:expected) {[{:in=>"body", :name=>"street[name]", :description=>"street", :type=>"string", :required=>true}]}
+        let(:params) { [{ in: 'body', name: 'address[street][name]', description: 'street', type: 'string', required: true }] }
+        let(:expected) { [{ in: 'body', name: 'street[name]', description: 'street', type: 'string', required: true }] }
         specify do
           expect(params).to eql expected
         end
       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', required: true }] }
+        let(:expected) { [{ in: 'body', name: 'street_lines', description: 'street lines', type: 'array', required: true }] }
         specify do
           expect(params).to eql expected
         end
@@ -120,36 +125,36 @@ describe GrapeSwagger::DocMethods::MoveParams do
       describe 'verb given' do
         let(:verb) { 'post' }
         let(:name) { 'Foo' }
-        let(:definitions) {{}}
+        let(:definitions) { {} }
 
         specify do
           definition = definitions.to_a.first
           expect(definition.first).to eql 'postRequestFoo'
-          expect(definition.last).to eql({ type: 'object', properties: {}, required: [] })
+          expect(definition.last).to eql(type: 'object', properties: {}, required: [])
         end
       end
 
       describe 'no verb given' do
         let(:name) { 'FooBar' }
-        let(:definitions) {{}}
+        let(:definitions) { {} }
         let(:verb) { nil }
 
         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: {}, required: [])
         end
       end
     end
 
     describe 'build_body_parameter' do
-      let(:response) {{ schema: { '$ref' => '#/definitions/Somewhere'} }}
+      let(:response) { { schema: { '$ref' => '#/definitions/Somewhere' } } }
 
       describe 'no name given' do
         let(:name) { nil }
-        let(:expected_param) {
-          {:name=>"Somewhere", :in=>"body", :required=>true, :schema=>{'$ref' => "#/definitions/Somewhere"}}
-        }
+        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
@@ -158,9 +163,9 @@ describe GrapeSwagger::DocMethods::MoveParams do
 
       describe 'name given' do
         let(:name) { 'Foo' }
-        let(:expected_param) {
-          {:name=>"Somewhere", :in=>"body", :required=>true, :schema=>{'$ref' => "#/definitions/#{name}"}}
-        }
+        let(:expected_param) do
+          { name: 'Somewhere', in: 'body', required: true, schema: { '$ref' => "#/definitions/#{name}" } }
+        end
         specify do
           parameter = subject.send(:build_body_parameter, response, name)
           expect(parameter).to eql expected_param
@@ -177,63 +182,67 @@ describe GrapeSwagger::DocMethods::MoveParams do
 
     describe 'movable' do
       describe 'path' do
-        let(:param) {{ in: "path", name: "key", description: nil, type: "integer", format: "int32", required: true }}
+        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 'body' do
-        let(:param) {{ in: "body", name: "in_body", description: "in_body", type: "integer", format: "int32", required: true }}
+        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 }
       end
 
       describe 'query' do
-        let(:param) {{ in: "query", name: "in_query", description: "in_query", type: "integer", format: "int32", required: true }}
+        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 'header' do
-        let(:param) {{ in: "header", name: "in_header", description: "in_header", type: "integer", format: "int32", required: true }}
+        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 }
       end
     end
 
     describe 'deletable' do
       describe 'path' do
-        let(:param) {{ in: "path", name: "key", description: nil, type: "integer", format: "int32", required: true }}
+        let(:param) { { in: 'path', name: 'key', description: nil, type: 'integer', format: 'int32', required: true } }
         it { expect(subject.send(:deletable?, param)).to be false }
       end
 
       describe 'body' do
-        let(:param) {{ in: "body", name: "in_body_1", description: "in_body_1", type: "integer", format: "int32", required: true }}
+        let(:param) { { in: 'body', name: 'in_body_1', description: 'in_body_1', type: 'integer', format: 'int32', required: true } }
         it { expect(subject.send(:deletable?, param)).to be true }
       end
 
       describe 'query' do
-        let(:param) {{ in: "query", name: "in_query_1", description: "in_query_1", type: "integer", format: "int32", required: true }}
+        let(:param) { { in: 'query', name: 'in_query_1', description: 'in_query_1', type: 'integer', format: 'int32', required: true } }
         it { expect(subject.send(:deletable?, param)).to be false }
       end
 
       describe 'header' do
-        let(:param) {{ in: "header", name: "in_header_1", description: "in_header_1", type: "integer", format: "int32", required: true }}
+        let(:param) { { in: 'header', name: 'in_header_1', description: 'in_header_1', type: 'integer', format: 'int32', required: true } }
         it { expect(subject.send(:deletable?, param)).to be false }
       end
     end
 
     describe 'should move' do
       describe 'no move' do
-        let(:params) {[
-          { 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 }
-        ]}
+        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) {[
-          { 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 }
-        ]}
+        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
@@ -243,54 +252,65 @@ describe GrapeSwagger::DocMethods::MoveParams do
         subject.send(:unify!, params) if subject.send(:should_move?, params)
       end
       describe 'param type with `:in` given' do
-        let(:params) {[
-          { in: "path", name: "key", description: nil, type: "integer", format: "int32", required: true },
-          { in: "body", name: "in_body", description: "in_body", 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 }
-        ]}
-
-        let(:expected_params) {[
-          { in: "path", name: "key", description: nil, type: "integer", format: "int32", required: true },
-          { in: "body", name: "in_body", description: "in_body", 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: "body", name: "in_form_data", description: "in_form_data", type: "integer", format: "int32", required: true }
-        ]}
+        let(:params) do
+          [
+            { in: 'path', name: 'key', description: nil, type: 'integer', format: 'int32', required: true },
+            { in: 'body', name: 'in_body', description: 'in_body', 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
+
+        let(:expected_params) do
+          [
+            { in: 'path', name: 'key', description: nil, type: 'integer', format: 'int32', required: true },
+            { in: 'body', name: 'in_body', description: 'in_body', 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: 'body', name: 'in_form_data', description: 'in_form_data', type: 'integer', format: 'int32', required: true }
+          ]
+        end
         it { expect(params).to eql expected_params }
       end
 
       describe 'let it as is' do
-        let(:params) {[
-          { 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 }
-        ]}
-
-        let(:expected_params) {[
-          { 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 }
-        ]}
-        it { expect(params).to eql expected_params }
+        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
 
+        let(:expected_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(params).to eql expected_params }
       end
 
       describe 'param type with `:param_type` given' do
-        let(:params) {[
-          { 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 }
-        ]}
-
-        let(:expected_params) {[
-          { name: "key", description: nil, type: "integer", format: "int32", required: true, in: "path" },
-          { name: "in_body", description: "in_body", type: "integer", format: "int32", required: true, in: "body" },
-          { name: "in_query", description: "in_query", type: "integer", format: "int32", required: true, in: "query" },
-          { name: "in_header", description: "in_header", type: "integer", format: "int32", required: true, in: "header" },
-          { name: "in_form_data", description: "in_form_data", type: "integer", format: "int32", required: true, in: "body" }
-        ]}
+        let(: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
+
+        let(:expected_params) do
+          [
+            { name: 'key', description: nil, type: 'integer', format: 'int32', required: true, in: 'path' },
+            { name: 'in_body', description: 'in_body', type: 'integer', format: 'int32', required: true, in: 'body' },
+            { name: 'in_query', description: 'in_query', type: 'integer', format: 'int32', required: true, in: 'query' },
+            { name: 'in_header', description: 'in_header', type: 'integer', format: 'int32', required: true, in: 'header' },
+            { name: 'in_form_data', description: 'in_form_data', type: 'integer', format: 'int32', required: true, in: 'body' }
+          ]
+        end
         it { expect(params).to eql expected_params }
       end
     end