grape-swagger 0.21.0 → 0.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 21b83f7c1596856df6020d2a6191b69a2a9502af
-  data.tar.gz: d3f9532f1a8d5430baa061237d28b8c5fa8fced5
+  metadata.gz: 96f5daf8e980cca96f1dc18f0a7dad2faf86b1f3
+  data.tar.gz: 665c50fb9409756ff95f526b2a13600a37db8a40
 SHA512:
-  metadata.gz: a48aa84a04dcb5b0a6c12fb142e0fefbb92a42f8c363a9a0b34cf3931ea57a60996f2991b5f00e0d5b1154dd4f85b655d16f634101c6913e2cdbd0867ba7d735
-  data.tar.gz: 705b3490be3a33bf84ec5bd56df3d7ea9b698b0b2a79eef822facebb22554933fa1ff2a00e462e36f4df8c8af30d0c06f0c11eae9c4fe8c131eecf22e5fb05eb
+  metadata.gz: f4e73ba96c6060cd24e22733de9160f267d72fdd9bc73f8baf76ecb6fe31ac908dab1506171ea6a9384631140ea338768fe7452513c6fbc9eb4a81ae70bc4819
+  data.tar.gz: 6d1a9f3df56f08ade9c36f43573a669b9a3a3c1172218cd02dc885dcee3e99897500249bcc5340b6cb4bb3dabafd098a1c529bd1ebf9e07eb50a212630409bb0

data/.rubocop.yml

@@ -1,5 +1,6 @@
 AllCops:
   Exclude:
     - vendor/**/*
+    - example/**/*
 
 inherit_from: .rubocop_todo.yml

data/.rubocop_todo.yml

@@ -28,7 +28,7 @@ Metrics/AbcSize:
 # Offense count: 3
 # Configuration parameters: CountComments.
 Metrics/ClassLength:
-  Max: 206
+  Max: 220
 
 # Offense count: 10
 Metrics/CyclomaticComplexity:

data/CHANGELOG.md

@@ -8,6 +8,30 @@
 
 * Your contribution here.
 
+### 0.22.0 (July 12, 2016)
+
+#### Features
+
+* [#470](https://github.com/ruby-grape/grape-swagger/pull/470): Document request definitions inline - [@LeFnord](https://github.com/LeFnord).
+* [#448](https://github.com/ruby-grape/grape-swagger/pull/448): Header parameters are now prepended to the parameter list - [@anakinj](https://github.com/anakinj).
+* [#444](https://github.com/ruby-grape/grape-swagger/pull/444): With multi types parameter the first type is use as the documentation type - [@scauglog](https://github.com/scauglog).
+* [#463](https://github.com/ruby-grape/grape-swagger/pull/463): Added 'hidden' option for parameter to be exclude from generated documentation - [@anakinj](https://github.com/anakinj).
+* [#471](https://github.com/ruby-grape/grape-swagger/pull/471): Allow Security Definitions Objects to be defined - [@bendodd](https://github.com/bendodd).
+
+#### Fixes
+
+* [#472](https://github.com/ruby-grape/grape-swagger/pull/472): Fixes required property for request definitions - [@LeFnord](https://github.com/LeFnord).
+* [#467](https://github.com/ruby-grape/grape-swagger/pull/467): Refactors moving of body params - [@LeFnord](https://github.com/LeFnord).
+* [#464](https://github.com/ruby-grape/grape-swagger/pull/464): Fixes array params, sets correct type and format for items - [@LeFnord](https://github.com/LeFnord).
+* [#461](https://github.com/ruby-grape/grape-swagger/pull/461): Fixes issue by adding extensions to definitions. It appeared, if for the given status code, no definition could be found - [@LeFnord](https://github.com/LeFnord).
+* [#455](https://github.com/ruby-grape/grape-swagger/pull/455): Setting `type:` option as `Array[Class]` creates `array` type in JSON - [@tyspring](https://github.com/tyspring).
+* [#450](https://github.com/ruby-grape/grape-swagger/pull/438): Do not add :description to definitions if :description is missing on path - [@texpert](https://github.com/texpert).
+* [#447](https://github.com/ruby-grape/grape-swagger/pull/447): Version part of the url is now ignored when generating tags for endpoint - [@anakinj](https://github.com/anakinj).
+* [#444](https://github.com/ruby-grape/grape-swagger//pull/444): Default value provided in the documentation hash, override the grape default [@scauglog](https://github.com/scauglog).
+* [#443](https://github.com/ruby-grape/grape-swagger/issues/443): Type provided in the documentation hash, override the grape type [@scauglog](https://github.com/scauglog).
+* [#454](https://github.com/ruby-grape/grape-swagger/pull/454): Include documented Hashes in documentation output - [@aschuster3](https://github.com/aschuster3).
+* [#457](https://github.com/ruby-grape/grape-swagger/issues/457): Using camel case on namespace throws exception on add_swagger_documentation method - [@rayko](https://github.com/rayko/).
+
 ### 0.21.0 (June 1, 2016)
 
 #### Features
@@ -15,7 +39,6 @@
 * [#413](https://github.com/ruby-grape/grape-swagger/pull/413): Move all model parsing logic to separate gems `grape-swagger-entity` and added representable parser `grape-swagger` - [@Bugagazavr](https://github.com/Bugagazavr).
 * [#434](https://github.com/ruby-grape/grape-swagger/pull/434): Add summary to the operation object generator to be more compliant with [OpenAPI v2](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md#operation-object) - [@aschuster3](https://github.com/aschuster3).
 * [#441](https://github.com/ruby-grape/grape-swagger/pull/441): Accepting `String`, `lambda` and `proc` for `host` and `base_path` - [@LeFnord](https://github.com/LeFnord).
-* Your contribution here.
 
 #### Fixes
 
@@ -23,7 +46,6 @@
 * [#419](https://github.com/ruby-grape/grape-swagger/pull/419): Replaced github ref to rubygems for external gems - [@Bugagazavr](https://github.com/Bugagazavr).
 * [#420](https://github.com/ruby-grape/grape-swagger/pull/420): Raise SwaggerSpec exception if swagger spec isn't satisfied, when no parser for model is registered or response model is empty - [@Bugagazavr](https://github.com/Bugagazavr).
 * [#438](https://github.com/ruby-grape/grape-swagger/pull/438): Route version was missing in :options passed to PathString, so Endpoint.path_and_definitions_objects wasn't returning a versioned path when required - [@texpert](https://github.com/texpert).
-* Your contribution here.
 
 ### 0.20.3 (May 9, 2016)
 

data/Gemfile

@@ -10,3 +10,8 @@ else
 end
 
 gem ENV['MODEL_PARSER'] if ENV.key?('MODEL_PARSER')
+
+if RUBY_VERSION < '2.2.2'
+  gem 'rack', '<2.0.0'
+  gem 'activesupport', '<5.0.0'
+end

data/README.md

@@ -49,7 +49,8 @@ grape-swagger | swagger spec | grape                   | grape-entity | represen
 0.11.0        |     1.2      |               >= 0.16.2 |  < 0.5.0     | n/a           |
 0.20.1        |     2.0      | >= 0.12.0 ... <= 0.14.0 | <= 0.5.1     | n/a           |
 0.20.3        |     2.0      | >= 0.12.0 ... ~> 0.16.2 | ~> 0.5.1     | n/a           |
-0.21.0 (next) |     2.0      | >= 0.12.0 ... <= 0.16.2 | <= 0.5.1     | >= 2.4.1      |
+0.21.0        |     2.0      | >= 0.12.0 ... <= 0.16.2 | <= 0.5.1     | >= 2.4.1      |
+0.21.1 (next) |     2.0      | >= 0.12.0 ... <= 0.16.2 | <= 0.5.1     | >= 2.4.1      |
 
 <a name="swagger-spec" />
 ## Swagger-Spec
@@ -191,6 +192,7 @@ end
 * [add_version](#add_version)
 * [doc_version](#doc_version)
 * [markdown](#markdown)
+* [security_definitions](#security_definitions)
 * [models](#models)
 * [hide_documentation_path](#hide_documentation_path)
 * [info](#info)
@@ -272,12 +274,24 @@ add_swagger_documentation \
   markdown: GrapeSwagger::Markdown::RedcarpetAdapter.new
 ```
 
+<a name="security_definitions" />
+#### security_definitions:
+Specify the [Security Definitions Object](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md#security-definitions-object)
+
+```ruby
+add_swagger_documentation \
+  security_definitions: {
+    api_key: {
+      type: "apiKey",
+      name: "api_key",
+      in: "header"
+    }
+  }
+```
 
 #### *authorizations*:
 This value is added to the `authorizations` key in the JSON documentation.
 
-
-
 <a name="models" />
 #### models:
 A list of entities to document. Combine with the [grape-entity](https://github.com/ruby-grape/grape-entity) gem.
@@ -343,9 +357,14 @@ add_swagger_documentation \
 
 * [Swagger Header Parameters](#headers)
 * [Hiding an Endpoint](#hiding)
+* [Overriding Auto-Generated Nicknames](#overriding-auto-generated-nicknames)
 * [Defining an endpoint as array](#array)
 * [Using an options hash](#options)
 * [Specify endpoint details](#details)
+* [Overriding param type](#overriding-param-type)
+* [Overriding type](#overriding-type)
+* [Multi types](#multi-types)
+* [Hiding parameters](#hiding-parameters)
 * [Response documentation](#response)
 
 
@@ -453,6 +472,89 @@ post :act do
 end
 ```
 
+#### Overriding type
+
+You can override type, using the documentation hash.
+
+```ruby
+params do
+  requires :input, type: String, documentation: { type: 'integer' }
+end
+post :act do
+  ...
+end
+```
+
+```json
+{
+  "in": "formData",
+  "name": "input",
+  "type": "integer",
+  "format": "int32",
+  "required": true
+}
+```
+
+#### Array type
+
+Array types are also supported.
+
+```ruby
+params do
+  requires :action_ids, type: Array[Integer]
+end
+post :act do
+  ...
+end
+```
+
+```json
+{
+  "in": "formData",
+  "name": "action_ids",
+  "type": "array",
+  "items": {
+      "type": "integer"
+  },
+  "required": true
+}
+```
+
+#### Multi types
+
+By default when you set multi types, the first type is selected as swagger type
+
+```ruby
+params do
+  requires :action, types: [String, Integer]
+end
+post :act do
+  ...
+end
+```
+
+```json
+{
+  "in": "formData",
+  "name": "action",
+  "type": "string",
+  "required": true
+}
+```
+
+#### Hiding parameters
+
+Exclude single optional parameter from the documentation
+
+```ruby
+params do
+  optional :one, documentation: { hidden: true }
+  optional :two, documentation: { hidden: -> { true } }
+end
+post :act do
+  ...
+end
+```
 
 #### Overriding the route summary
 

data/example/api/endpoints.rb

@@ -23,21 +23,21 @@ module Api
       namespace :splines do
         #
         desc 'Get all splines',
-             is_array: true,
-             http_codes: [
-               { code: 200, message: 'get Splines', model: Api::Entities::Splines },
-               { code: 422, message: 'SplinesOutError' }
-             ]
+          is_array: true,
+          http_codes: [
+            { code: 200, message: 'get Splines', model: Api::Entities::Splines },
+            { code: 422, message: 'SplinesOutError' }
+          ]
         get do
           present :items, @@splines, with: Entities::Splines
         end
 
         #
         desc 'Return a spline.',
-             http_codes: [
-               { code: 200, message: 'get Splines' },
-               { code: 422, message: 'SplinesOutError' }
-             ]
+          http_codes: [
+            { code: 200, message: 'get Splines' },
+            { code: 422, message: 'SplinesOutError' }
+          ]
         params do
           requires :id, type: Integer, desc: 'Spline id.'
         end
@@ -49,9 +49,9 @@ module Api
 
         #
         desc 'Create a spline.',
-             http_codes: [
-               { code: 201, message: 'Spline created', model: Api::Entities::Splines }
-             ]
+          http_codes: [
+            { code: 201, message: 'Spline created', model: Api::Entities::Splines }
+          ]
         params do
           requires :spline, type: Hash do
             requires :x, type: Numeric
@@ -73,10 +73,10 @@ module Api
 
         #
         desc 'Update a spline.',
-             http_codes: [
-               { code: 200, message: 'update Splines', model: Api::Entities::Splines },
-               { code: 422, message: 'SplinesOutError' }
-             ]
+          http_codes: [
+            { code: 200, message: 'update Splines', model: Api::Entities::Splines },
+            { code: 422, message: 'SplinesOutError' }
+          ]
         params do
           requires :id, type: Integer, desc: 'Spline id.'
           optional :spline, type: Hash do

data/lib/grape-swagger.rb

@@ -65,7 +65,6 @@ module Grape
           next unless route_match
           resource = route_match.captures.first
           next if resource.empty?
-          resource.downcase!
           @target_class.combined_routes[resource] ||= []
           next if doc_klass.hide_documentation_path && route.path.match(/#{doc_klass.mount_path}($|\/|\(\.)/)
           @target_class.combined_routes[resource] << route

data/lib/grape-swagger/doc_methods.rb

@@ -102,6 +102,7 @@ module GrapeSwagger
         hide_documentation_path: true,
         format: :json,
         authorizations: nil,
+        security_definitions: nil,
         api_documentation: { desc: 'Swagger compatible API description' },
         specific_api_documentation: { desc: 'Swagger compatible API description for specific API' }
       }

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

@@ -3,9 +3,10 @@ module GrapeSwagger
     class DataType
       class << self
         def call(value)
-          raw_data_type = value[:type] if value.is_a?(Hash)
-          raw_data_type = value unless value.is_a?(Hash)
-          raw_data_type ||= 'string'
+          raw_data_type = value.is_a?(Hash) ? value[:type] : value
+          raw_data_type ||= 'String'
+          raw_data_type = parse_multi_type(raw_data_type)
+
           case raw_data_type.to_s
           when 'Boolean', 'Date', 'Integer', 'String', 'Float', 'JSON', 'Array'
             raw_data_type.to_s.downcase
@@ -28,6 +29,17 @@ module GrapeSwagger
           end
         end
 
+        def parse_multi_type(raw_data_type)
+          case raw_data_type
+          when /\A\[.*\]\z/
+            raw_data_type.gsub(/[(\A\[)(\s+)(\]\z)]/, '').split(',').first
+          when Array
+            raw_data_type.first
+          else
+            raw_data_type
+          end
+        end
+
         def parse_entity_name(model)
           if model.respond_to?(:entity_name)
             model.entity_name

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

@@ -4,6 +4,7 @@ module GrapeSwagger
       class << self
         def add(path, definitions, route)
           @route = route
+
           description = route.settings[:description]
           add_extension_to(path[method], extension(description)) if description && extended?(description, :x)
 
@@ -20,29 +21,32 @@ module GrapeSwagger
           def_extension = extension(settings, :x_def)
 
           if def_extension[:x_def].is_a?(Array)
-            def_extension[:x_def].each do |extension|
-              next unless extension.key?(:for)
-              status = extension.delete(:for)
-              definition = find_definition(status, path)
-              add_extension_to(definitions[definition], x_def: extension)
-            end
+            def_extension[:x_def].each { |extension| setup_definition(extension, path, definitions) }
           else
-            return unless def_extension[:x_def].key?(:for)
-            status = def_extension[:x_def].delete(:for)
-            definition = find_definition(status, path)
-            add_extension_to(definitions[definition], def_extension)
+            setup_definition(def_extension[:x_def], path, definitions)
           end
         end
 
+        def setup_definition(def_extension, path, definitions)
+          return unless def_extension.key?(:for)
+          status = def_extension[:for]
+
+          definition = find_definition(status, path)
+          add_extension_to(definitions[definition], x_def: def_extension)
+        end
+
         def find_definition(status, path)
           response = path[method][:responses][status]
+          return if response.nil?
 
-          response[:schema]['$ref'].split('/').last
+          return response[:schema]['$ref'].split('/').last if response[:schema].key?('$ref')
+          return response[:schema]['items']['$ref'].split('/').last if response[:schema].key?('items')
         end
 
         def add_extension_to(part, extensions)
+          return if part.nil?
           concatenate(extensions).each do |key, value|
-            part[key] = value
+            part[key] = value unless key.start_with?('x-for')
           end
         end
 

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

@@ -2,159 +2,204 @@ module GrapeSwagger
   module DocMethods
     class MoveParams
       class << self
-        def to_definition(paths, definitions)
+        attr_accessor :definitions
+
+        def can_be_moved?(params, http_verb)
+          move_methods.include?(http_verb) && includes_body_param?(params)
+        end
+
+        def to_definition(params, route, definitions)
           @definitions = definitions
+          unify!(params)
 
-          find_post_put(paths) do |method_definition|
-            verb = method_definition.keys.first
-            method_object = method_definition[verb]
+          params_to_move = movable_params(params)
+          params << parent_definition_of_params(params_to_move, route)
 
-            find_definition_and_params(method_object, verb)
-          end
+          params
         end
 
-        def find_post_put(paths)
-          paths.each do |x|
-            found = x.last.select { |y| move_methods.include?(y) }
-            yield found unless found.empty?
+        private
+
+        def parent_definition_of_params(params, route)
+          definition_name = GrapeSwagger::DocMethods::OperationId.manipulate(parse_model(route.path))
+          referenced_definition = build_definition(definition_name, params, route.request_method.downcase)
+          definition = @definitions[referenced_definition]
+
+          move_params_to_new(definition, params)
+
+          definition[:description] = route.description if route.respond_to?(:description)
+
+          build_body_parameter(referenced_definition, definition_name)
+        end
+
+        def move_params_to_new(definition, params)
+          params, nested_params = params.partition { |x| !x[:name].include?('[') }
+
+          unless params.blank?
+            properties, required = build_properties(params)
+            add_properties_to_definition(definition, properties, required)
           end
+
+          nested_properties = build_nested_properties(nested_params) unless nested_params.blank?
+          add_properties_to_definition(definition, nested_properties, []) unless nested_params.blank?
         end
 
-        def find_definition_and_params(path, verb)
-          params = path[:parameters]
+        def build_nested_properties(params, properties = {})
+          property = params.bsearch { |x| x[:name].include?('[') }[:name].split('[').first
 
-          return if params.nil?
-          return unless should_move?(params)
+          nested_params, params = params.partition { |x| x[:name].start_with?("#{property}[") }
+          prepare_nested_names(property, nested_params)
 
-          unify!(params)
+          recursive_call(properties, property, nested_params) unless nested_params.empty?
+          build_nested_properties(params, properties) unless params.empty?
 
-          status_code = GrapeSwagger::DocMethods::StatusCodes.get[verb.to_sym][:code]
-          response = path[:responses][status_code]
+          properties
+        end
 
-          if response[:schema] && response[:schema]['$ref']
-            referenced_definition = parse_model(response[:schema]['$ref'])
-            name = build_definition(referenced_definition, verb)
+        def recursive_call(properties, property, nested_params)
+          if should_expose_as_array?(nested_params)
+            properties[property] = array_type
+            move_params_to_new(properties[property][:items], nested_params)
           else
-            referenced_definition = path[:operationId]
-            name = build_definition(referenced_definition)
+            properties[property] = object_type
+            move_params_to_new(properties[property], nested_params)
           end
+        end
 
-          move_params_to_new(name, params)
+        def movable_params(params)
+          to_delete = params.each_with_object([]) { |x, memo| memo << x if deletable?(x) }
+          delete_from(params, to_delete)
 
-          @definitions[name][:description] = path[:description]
-          path[:parameters] << build_body_parameter(response.dup, name)
+          to_delete
         end
 
-        def move_params_to_new(name, params)
-          properties = {}
-          definition = @definitions[name]
+        def delete_from(params, to_delete)
+          to_delete.each { |x| params.delete(x) }
+        end
 
-          nested_definitions(name, params, properties)
+        def add_properties_to_definition(definition, properties, required)
+          if definition.key?(:items)
+            definition[:items][:properties].merge!(properties)
+            add_to_required(definition[:items], required)
+          else
+            definition[:properties].merge!(properties)
+            add_to_required(definition, required)
+          end
+        end
 
-          params.dup.each do |param|
-            next unless movable?(param)
+        def add_to_required(definition, value)
+          return if value.blank?
 
-            name = param[:name].to_sym
-            properties[name] = {}
-
-            properties[name].tap do |x|
-              property_keys.each do |attribute|
-                x[attribute] = param[attribute] unless param[attribute].nil?
-              end
-            end
+          definition[:required] ||= []
+          definition[:required].push(*value)
+        end
 
-            properties[name][:readOnly] = true unless deletable?(param)
-            params.delete(param) if deletable?(param)
+        def build_properties(params)
+          properties = {}
+          required = []
 
-            definition[:required] << name if deletable?(param) && param[:required]
-          end
+          prepare_nested_types(params) if should_expose_as_array?(params)
 
-          definition.delete(:required) if definition[:required].empty?
-          definition[:properties] = properties
-        end
+          params.each do |param|
+            name = param[:name].to_sym
+            properties[name] = {}
 
-        def nested_definitions(name, params, properties)
-          loop do
-            nested_name = params.bsearch { |x| x[:name].include?('[') }
-            return if nested_name.nil?
+            if should_expose_as_array?([param])
+              prepare_nested_types([param])
 
-            nested_name = nested_name[:name].split('[').first
+              properties[name][:type] = 'array'
+              properties[name][:items] = {}
+              properties[name][:items].tap do |x|
+                property_keys.each do |attribute|
+                  x[attribute] = param[attribute] unless param[attribute].nil?
+                end
+              end
+            else
 
-            nested, = params.partition { |x| x[:name].start_with?("#{nested_name}[") }
-            nested.each { |x| params.delete(x) }
-            nested_def_name = GrapeSwagger::DocMethods::OperationId.manipulate(nested_name)
-            def_name = "#{name}#{nested_def_name}"
-            properties[nested_name] = { '$ref' => "#/definitions/#{def_name}" }
+              properties[name].tap do |x|
+                property_keys.each do |attribute|
+                  x[attribute] = param[attribute] unless param[attribute].nil?
+                end
+              end
+            end
 
-            prepare_nested_names(nested)
-            build_definition(def_name)
-            @definitions[def_name][:description] = "#{name} - #{nested_name}"
-            move_params_to_new(def_name, nested)
+            required << name if deletable?(param) && param[:required]
           end
-        end
 
-        private
+          [properties, required]
+        end
 
-        def build_body_parameter(response, name = false)
-          entity = response[:schema] ? parse_model(response[:schema]['$ref']) : name
-          body_param = {}
-          body_param.tap do |x|
-            x[:name] = entity
+        def build_body_parameter(reference, name)
+          {}.tap do |x|
+            x[:name] = name
             x[:in] = 'body'
             x[:required] = true
-            x[:schema] = { '$ref' => response[:schema]['$ref'] } unless name
-            x[:schema] = { '$ref' => "#/definitions/#{name}" } if name
+            x[:schema] = { '$ref' => "#/definitions/#{reference}" }
           end
         end
 
-        def build_definition(name, verb = nil)
-          name = "#{verb}Request#{name}" if verb
-          @definitions[name] = { type: 'object', properties: {}, required: [] }
+        def build_definition(name, params, verb = nil)
+          name = "#{verb}#{name}" if verb
+          @definitions[name] = should_expose_as_array?(params) ? array_type : object_type
 
           name
         end
 
-        def prepare_nested_names(params)
-          params.each do |param|
-            param.tap do |x|
-              name = x[:name].partition('[').last.sub(']', '')
-              name = name.partition('[').last.sub(']', '') if name.start_with?('[')
-              x[:name] = name
-            end
-          end
+        def array_type
+          { type: 'array', items: { type: 'object', properties: {} } }
         end
 
-        def unify!(params)
+        def object_type
+          { type: 'object', properties: {} }
+        end
+
+        def prepare_nested_types(params)
           params.each do |param|
-            param[:in] = param.delete(:param_type) if param.key?(:param_type)
-            param[:in] = 'body' if param[:in] == 'formData'
+            next unless param[:items]
+            param[:type] = param[:items][:type] == 'array' ? 'string' : param[:items][:type]
+            param[:format] = param[:items][:format] if param[:items][:format]
+            param.delete(:items)
           end
         end
 
-        def parse_model(ref)
-          ref.split('/').last
+        def prepare_nested_names(property, params)
+          params.each { |x| x[:name] = x[:name].sub(property, '').sub('[', '').sub(']', '') }
         end
 
-        def move_methods
-          [:post, :put, :patch]
+        def unify!(params)
+          params.each { |x| x[:in] = x.delete(:param_type) if x[:param_type] }
+          params.each { |x| x[:in] = 'body' if x[:in] == 'formData' } if includes_body_param?(params)
+        end
+
+        def parse_model(ref)
+          parts = ref.split('/')
+          parts.last.include?('{') ? parts[0..-2].join('/') : parts[0..-1].join('/')
         end
 
         def property_keys
           [:type, :format, :description, :minimum, :maximum, :items]
         end
 
-        def movable?(param)
-          return true if param[:in] == 'body' || param[:in] == 'path'
-          false
+        def deletable?(param)
+          param[:in] == 'body'
         end
 
-        def deletable?(param)
-          return true if movable?(param) && param[:in] == 'body'
+        def move_methods
+          [:post, :put, :patch, 'POST', 'PUT', 'PATCH']
+        end
+
+        def includes_body_param?(params)
+          params.map { |x| return true if x[:in] == 'body' || x[:param_type] == 'body' }
           false
         end
 
-        def should_move?(params)
-          !params.select { |x| x[:in] == 'body' || x[:param_type] == 'body' }.empty?
+        def should_expose_as_array?(params)
+          should_exposed_as(params) == 'array'
+        end
+
+        def should_exposed_as(params)
+          params.map { |x| return 'object' if x[:type] && x[:type] != 'array' }
+          'array'
         end
       end
     end