grape-swagger 0.30.1 → 0.31.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2cc4d92b47209a6323502fd863a738a8829e0d78b599a47e83a1aa9e52746cf7
-  data.tar.gz: cbc408aaf0f686032312bdfb3332671d73341e90eeff694162f2d0bdcfc14a81
+  metadata.gz: fb1e3a26202efe81153ad53197d67e8e3865ba34271a841d35e921eea5dc7a77
+  data.tar.gz: e0d34f81243e4d327d5268d100d0f654c5fbb0b63f95e47a50ba74e7ced602b2
 SHA512:
-  metadata.gz: 980563a6d50454d8f7f4439b96a820423a77758ee0c20a8ea353439ddcf46a596cf2763cdd714b07530d63c71b539c50e18775aeba2639168ae0755920887dd8
-  data.tar.gz: af45e27dccdbe492ba950a6dbf29f9e3f0e4348aea8e689813cc5ed32fdd595250c2dbb689a7aa41890dcdaa33280321fb704b0e2e72975e6356631d030ae370
+  metadata.gz: 97396d5bcecae0c152c5c67c060da11373cd080cd126f2e443766790663355ffb358743beb2b2d309fa80399b1cb813053bb83ef8f89686e0d6c63f2f2b23919
+  data.tar.gz: 5afd698ad351518cb9d5cc73dfe45360e182263203bab5993c2766fa5ece2cd6bf61328b90223e1b4883444798d9ae769b6f3dc32f7b442303911286d66a1e34

data/.rubocop_todo.yml

@@ -21,7 +21,7 @@ Metrics/AbcSize:
 # Offense count: 3
 # Configuration parameters: CountComments.
 Metrics/ClassLength:
-  Max: 287
+  Max: 248
 
 # Offense count: 10
 Metrics/CyclomaticComplexity:

data/CHANGELOG.md

@@ -2,13 +2,29 @@
 
 #### Features
 
-* [#686](https://github.com/ruby-grape/grape-swagger/pull/686): Allow response headers for responses with no content and for files - [@jdmurphy](https://github.com/jdmurphy).
 * Your contribution here.
 
 #### Fixes
 
 * Your contribution here.
 
+###  0.31.0 (August 22, 2018)
+
+#### Features
+
+* [#622](https://github.com/ruby-grape/grape-swagger/pull/622): Add support for 'brackets' collection format - [@korstiaan](https://github.com/korstiaan).
+* [#637](https://github.com/ruby-grape/grape-swagger/pull/637): Add an option to add braces to array params - [@adie](https://github.com/adie).
+
+* [#688](https://github.com/ruby-grape/grape-swagger/pull/688): Use deep merge for nested parameter definitions - [@jdmurphy](https://github.com/jdmurphy).
+* [#691](https://github.com/ruby-grape/grape-swagger/pull/691): Disregard order when parsing request params for arrays - [@jdmurphy](https://github.com/jdmurphy).
+* [#696](https://github.com/ruby-grape/grape-swagger/pull/696): Delegate required properties parsing to model parsers - [@Bugagazavr](https://github.com/Bugagazavr).
+
+###  0.30.1 (July 19, 2018)
+
+#### Features
+
+* [#686](https://github.com/ruby-grape/grape-swagger/pull/686): Allow response headers for responses with no content and for files - [@jdmurphy](https://github.com/jdmurphy).
+
 ###  0.30.0 (July 19, 2018)
 
 #### Features

data/README.md

@@ -50,7 +50,7 @@ grape-swagger | swagger spec | grape                   | grape-entity | represen
 0.11.0        |     1.2      |               >= 0.16.2 |  < 0.5.0     | n/a           |
 0.25.2        |     2.0      | >= 0.14.0 ... <= 0.18.0 | <= 0.6.0     | >= 2.4.1      |
 0.26.0        |     2.0      | >= 0.16.2               | <= 0.6.1     | >= 2.4.1      |
-0.27.0        |     2.0      | >= 0.16.2               | => 0.5.0     | >= 2.4.1      |
+0.27.0        |     2.0      | >= 0.16.2               | >= 0.5.0     | >= 2.4.1      |
 
 
 ## Swagger-Spec <a name="swagger-spec" />
@@ -200,7 +200,7 @@ end
 * [tags](#tags)
 * [hide_documentation_path](#hide_documentation_path)
 * [info](#info)
-
+* [array_uses_braces](#array_uses_braces)
 
 You can pass a hash with optional configuration settings to ```add_swagger_documentation```.
 The examples show the default value.
@@ -372,7 +372,27 @@ add_swagger_documentation \
 
 A hash merged into the `info` key of the JSON documentation.
 
-
+#### array_uses_braces: <a name="array_uses_braces" />
+```ruby
+add_swagger_documentation \
+  array_use_braces: true
+```
+ This setting must be `true` in order for params defined as an `Array` type to submit each element properly.
+ ```ruby
+params do
+  optional :metadata, type: Array[String]
+end
+```
+ with `array_uses_braces: true`:
+```
+metadata[]: { "name": "Asset ID", "value": "12345" }
+metadata[]: { "name": "Asset Tag", "value": "654321"}
+```
+ with `array_uses_braces: false`:
+```
+metadata: {"name": "Asset ID", "value": "123456"}
+metadata: {"name": "Asset Tag", "value": "654321"}
+```
 
 ## Routes Configuration <a name="routes" />
 

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

@@ -4,11 +4,15 @@ module GrapeSwagger
   module DocMethods
     class BuildModelDefinition
       class << self
-        def build(model, properties)
+        def build(model, properties, required)
           definition = { type: 'object', properties: properties }
 
-          required = required_attributes(model)
-          definition[:required] = required unless required.blank?
+          if required.nil?
+            required_attrs = required_attributes(model)
+            definition[:required] = required_attrs unless required_attrs.blank?
+          end
+
+          definition[:required] = required if required.is_a?(Array) && required.any?
 
           definition
         end
@@ -22,6 +26,8 @@ module GrapeSwagger
         def parse_entity(model)
           return unless model.respond_to?(:documentation)
 
+          deprecated_workflow_for('grape-swagger-entity')
+
           model.documentation
                .select { |_name, options| options[:required] }
                .map { |name, options| options[:as] || name }
@@ -30,10 +36,17 @@ module GrapeSwagger
         def parse_representable(model)
           return unless model.respond_to?(:map)
 
+          deprecated_workflow_for('grape-swagger-representable')
+
           model.map
                .select { |p| p[:documentation] && p[:documentation][:required] }
                .map(&:name)
         end
+
+        def deprecated_workflow_for(gem_name)
+          warn "DEPRECATED: You using old #{gem_name} version, wich not provides" \
+            "required attributes, to solve this problem please update #{gem_name}"
+        end
       end
     end
   end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'active_support/core_ext/hash/deep_merge'
+
 module GrapeSwagger
   module DocMethods
     class MoveParams
@@ -114,11 +116,11 @@ module GrapeSwagger
 
         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)
+            properties[property.to_sym] = array_type
+            move_params_to_new(properties[property.to_sym][:items], nested_params)
           else
-            properties[property] = object_type
-            move_params_to_new(properties[property], nested_params)
+            properties[property.to_sym] = object_type
+            move_params_to_new(properties[property.to_sym], nested_params)
           end
         end
 
@@ -135,10 +137,10 @@ module GrapeSwagger
 
         def add_properties_to_definition(definition, properties, required)
           if definition.key?(:items)
-            definition[:items][:properties].merge!(properties)
+            definition[:items][:properties].deep_merge!(properties)
             add_to_required(definition[:items], required)
           else
-            definition[:properties].merge!(properties)
+            definition[:properties].deep_merge!(properties)
             add_to_required(definition, required)
           end
         end

data/lib/grape-swagger/endpoint.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 require 'active_support'
-require 'active_support/core_ext/string/inflections.rb'
+require 'active_support/core_ext/string/inflections'
+require 'grape-swagger/endpoint/params_parser'
 
 module Grape
   class Endpoint
@@ -118,7 +119,7 @@ module Grape
       method[:description] = description_object(route)
       method[:produces]    = produces_object(route, options[:produces] || options[:format])
       method[:consumes]    = consumes_object(route, options[:format])
-      method[:parameters]  = params_object(route, path)
+      method[:parameters]  = params_object(route, options, path)
       method[:security]    = security_object(route)
       method[:responses]   = response_object(route)
       method[:tags]        = route.options.fetch(:tags, tag_object(route, path))
@@ -174,8 +175,8 @@ module Grape
       GrapeSwagger::DocMethods::ProducesConsumes.call(route.settings.dig(:description, :consumes) || format)
     end
 
-    def params_object(route, path)
-      parameters = partition_params(route).map do |param, value|
+    def params_object(route, options, path)
+      parameters = partition_params(route, options).map do |param, value|
         value = { required: false }.merge(value) if value.is_a?(Hash)
         _, value = default_type([[param, value]]).first if value == ''
         if value[:type]
@@ -279,8 +280,7 @@ module Grape
       memo['schema'] = { type: 'file' }
     end
 
-    # rubocop:disable Style/IfUnlessModifier
-    def partition_params(route)
+    def partition_params(route, settings)
       declared_params = route.settings[:declared_params] if route.settings[:declared_params].present?
       required = merge_params(route)
       required = GrapeSwagger::DocMethods::Headers.parse(route) + required unless route.headers.nil?
@@ -288,12 +288,11 @@ module Grape
       default_type(required)
 
       request_params = unless declared_params.nil? && route.headers.nil?
-                         parse_request_params(required)
+                         GrapeSwagger::Endpoint::ParamsParser.parse_request_params(required, settings)
                        end || {}
 
       request_params.empty? ? required : request_params
     end
-    # rubocop:enable Style/IfUnlessModifier
 
     def merge_params(route)
       param_keys = route.params.keys
@@ -305,27 +304,6 @@ module Grape
       params.each { |param| param[-1] = param.last == '' ? default_param_type : param.last }
     end
 
-    def parse_request_params(params)
-      array_key = nil
-      params.select { |param| public_parameter?(param) }.each_with_object({}) do |param, memo|
-        name, options = *param
-        param_type = options[:type]
-        param_type = param_type.to_s unless param_type.nil?
-        array_key = name.to_s if param_type_is_array?(param_type)
-        options[:is_array] = true if array_key && name.start_with?(array_key)
-        memo[name] = options unless %w[Hash Array].include?(param_type) && !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(value)
       if value.is_a?(Class) && GrapeSwagger.model_parsers.find(value)
         expose_params_from_model(value)
@@ -348,13 +326,13 @@ module Grape
       parser = GrapeSwagger.model_parsers.find(model)
       raise GrapeSwagger::Errors::UnregisteredParser, "No parser registered for #{model_name}." unless parser
 
-      properties = parser.new(model, self).call
+      properties, required = parser.new(model, self).call
       unless properties&.any?
         raise GrapeSwagger::Errors::SwaggerSpec,
               "Empty model #{model_name}, swagger 2.0 doesn't support empty definitions."
       end
 
-      @definitions[model_name] = GrapeSwagger::DocMethods::BuildModelDefinition.build(model, properties)
+      @definitions[model_name] = GrapeSwagger::DocMethods::BuildModelDefinition.build(model, properties, required)
 
       model_name
     end
@@ -369,13 +347,5 @@ module Grape
       return route_hidden unless route_hidden.is_a?(Proc)
       options[:token_owner] ? route_hidden.call(send(options[:token_owner].to_sym)) : route_hidden.call
     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/endpoint/params_parser.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module GrapeSwagger
+  module Endpoint
+    class ParamsParser
+      attr_reader :params, :settings
+
+      def self.parse_request_params(params, settings)
+        new(params, settings).parse_request_params
+      end
+
+      def initialize(params, settings)
+        @params = params
+        @settings = settings
+      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
+          end
+
+          memo[name] = options unless %w[Hash Array].include?(param_type) && !options.key?(:documentation)
+        end
+      end
+
+      private
+
+      def array_use_braces?(options)
+        settings[:array_use_braces] && !(options[:documentation] && options[:documentation][:param_type] == 'body')
+      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 public_params
+        params.select { |param| public_parameter?(param) }
+      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
+end

data/lib/grape-swagger/version.rb

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

data/spec/lib/endpoint/params_parser_spec.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe GrapeSwagger::Endpoint::ParamsParser do
+  let(:settings) { {} }
+  let(:params) { [] }
+
+  let(:parser) { described_class.new(params, settings) }
+
+  describe '#parse_request_params' do
+    context 'when param is of array type' do
+      let(:params) { [['param_1', { type: 'Array[String]' }]] }
+
+      it 'adds is_array option' do
+        expect(parser.parse_request_params).to eq('param_1' => { type: 'Array[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(parser.parse_request_params.keys.first).to eq 'param_1[]'
+        end
+      end
+    end
+
+    context 'when param is of simple type' do
+      let(:params) { [['param_1', { type: 'String' }]] }
+
+      it 'does not change options' do
+        expect(parser.parse_request_params).to eq('param_1' => { type: 'String' })
+      end
+
+      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(parser.parse_request_params.keys.first).to eq 'param_1'
+        end
+      end
+    end
+
+    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
+        expect(parser.parse_request_params).not_to have_key 'param_1'
+      end
+
+      it 'adds is_array option to the nested param' do
+        expect(parser.parse_request_params).to eq('param_1[param_2]' => { 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(parser.parse_request_params.keys.first).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
+        expect(parser.parse_request_params).not_to have_key 'param_1'
+      end
+
+      it 'does not change options to the nested param' do
+        expect(parser.parse_request_params).to eq('param_1[param_2]' => { type: 'String' })
+      end
+
+      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(parser.parse_request_params.keys.first).to eq 'param_1[param_2]'
+        end
+      end
+    end
+  end
+
+  describe '#param_type_is_array?' do
+    it 'returns true if the value passed represents an array' do
+      expect(parser.send(:param_type_is_array?, 'Array')).to be_truthy
+      expect(parser.send(:param_type_is_array?, '[String]')).to be_truthy
+      expect(parser.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(parser.send(:param_type_is_array?, 'String')).to be_falsey
+      expect(parser.send(:param_type_is_array?, '[String, Integer]')).to be_falsey
+    end
+  end
+end