committee 2.0.0.pre8 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a52179d89e7de15a76b440454d27fc478ca2e75b
-  data.tar.gz: 5a98b675cffcefd898612e6806dc466d58fa9d64
+  metadata.gz: 0719ce2f2d3336816d822c41eace6161265ab86b
+  data.tar.gz: 8eaf8c70a09ed4ef5b6613897e54d370f8523ea6
 SHA512:
-  metadata.gz: 59cab2ff0859d8ae77a734f3bdfe5103c9b52c70c2cbca18846739e9afff0280a900910479c72697e743bfc92b833864ce34529fd33a8ff45dec84bb03d6d2a0
-  data.tar.gz: 4034113794bb7f991542919a7f8f0b22bb8b4c5c52a1c9e5be03dba15ece0a3cb8d0fcaa451cd716e6c935d28f6d3185d200b06f0e3640e653c5d62179b09f5d
+  metadata.gz: c94926b7b0f4a0e92b99d448d5eb186c751b5b29fe7734038027f824ae2d892e8d93939d9c0d6f738b11d21926ef4235ac8a0818b2a03d8b4f421cbab5d396cf
+  data.tar.gz: 5df57d46e4d3f639705339a88c0464eb9c1677d314eccf1ea877d8449b13fb9f8d3da3d56f865fe1da5fcfe038eb1d3b2c43754de064a825a05ff4062447e5d6

data/lib/committee/middleware/request_validation.rb

@@ -9,6 +9,7 @@ module Committee::Middleware
       @optimistic_json     = options.fetch(:optimistic_json, false)
       @strict              = options[:strict]
       @coerce_date_times   = options.fetch(:coerce_date_times, false)
+      @coerce_recursive = options.fetch(:coerce_recursive, true)
 
       @coerce_form_params = options.fetch(:coerce_form_params,
         @schema.driver.default_coerce_form_params)
@@ -23,29 +24,18 @@ module Committee::Middleware
 
     def handle(request)
       link, param_matches = @router.find_request_link(request)
-      path_params = {}
 
       if link
         # Attempts to coerce parameters that appear in a link's URL to Ruby
         # types that can be validated with a schema.
         if @coerce_path_params
-          path_params = param_matches.merge(
-            Committee::StringParamsCoercer.new(
-              param_matches,
-              link.schema
-            ).call
-          )
+          Committee::StringParamsCoercer.new(param_matches, link.schema, coerce_recursive: @coerce_recursive).call!
         end
 
         # Attempts to coerce parameters that appear in a query string to Ruby
         # types that can be validated with a schema.
         if @coerce_query_params && !request.GET.nil? && !link.schema.nil?
-          request.env["rack.request.query_hash"].merge!(
-            Committee::StringParamsCoercer.new(
-              request.GET,
-              link.schema
-            ).call
-          )
+          Committee::StringParamsCoercer.new(request.GET, link.schema, coerce_recursive: @coerce_recursive).call!
         end
       end
 
@@ -58,14 +48,14 @@ module Committee::Middleware
         schema:             link ? link.schema : nil
       ).call
 
-      request.env[@params_key].merge!(path_params)
+      request.env[@params_key].merge!(param_matches) if param_matches
 
       if link
         validator = Committee::RequestValidator.new(link, check_content_type: @check_content_type)
         validator.call(request, request.env[@params_key])
 
-        parameter_coerce(request, link, @params_key)
-        parameter_coerce(request, link, "rack.request.query_hash") if !request.GET.nil? && !link.schema.nil?
+        parameter_coerce!(request, link, @params_key)
+        parameter_coerce!(request, link, "rack.request.query_hash") if !request.GET.nil? && !link.schema.nil?
 
         @app.call(request.env)
       elsif @strict
@@ -90,13 +80,10 @@ module Committee::Middleware
 
     private
 
-      def parameter_coerce(request, link, coerce_key)
-        request.env[coerce_key].merge!(
-            Committee::ParameterCoercer
-                .new(request.env[coerce_key], link.schema,
-                     coerce_date_times: @coerce_date_times)
-                .call
-        )
+      def parameter_coerce!(request, link, coerce_key)
+        Committee::ParameterCoercer.
+            new(request.env[coerce_key], link.schema, coerce_date_times: @coerce_date_times, coerce_recursive: @coerce_recursive).
+            call!
       end
   end
 end

data/lib/committee/parameter_coercer.rb

@@ -5,31 +5,63 @@ module Committee
       @schema = schema
 
       @coerce_date_times = options.fetch(:coerce_date_times, false)
+      @coerce_recursive = options.fetch(:coerce_recursive, false)
     end
 
-    def call
-      coerced = {}
-      return coerced unless @schema.respond_to?(:properties)
+    def call!
+      coerce_object!(@params, @schema)
+    end
+
+    private
 
-      @schema.properties.each do |k, s|
-        original_val = @params[k]
+      def coerce_object!(hash, schema)
+        return false unless schema.respond_to?(:properties)
 
-        unless original_val.nil?
-          s.type.each do |to_type|
-            if @coerce_date_times && to_type == "string" && s.format == "date-time"
-              coerce_val = parse_date_time(original_val)
-              coerced[k] = coerce_val if coerce_val
+        is_coerced = false
+        schema.properties.each do |k, s|
+          original_val = hash[k]
+          unless original_val.nil?
+            new_value, is_changed = coerce_value!(original_val, s)
+            if is_changed
+              hash[k] = new_value
+              is_coerced = true
             end
+          end
+        end
+
+        is_coerced
+      end
 
-            break if coerced.key?(k)
+      def coerce_value!(original_val, s)
+        s.type.each do |to_type|
+          if @coerce_date_times && to_type == "string" && s.format == "date-time"
+            coerced_val = parse_date_time(original_val)
+            return coerced_val, true if coerced_val
           end
+
+          return original_val, true if @coerce_recursive && (to_type == "array") && coerce_array_data!(original_val, s)
+
+          return original_val, true if @coerce_recursive && (to_type == "object") && coerce_object!(original_val, s)
         end
+        return nil, false
       end
 
-      coerced
-    end
+      def coerce_array_data!(original_val, schema)
+        return false unless schema.respond_to?(:items)
+        return false unless original_val.is_a?(Array)
+
+        is_coerced = false
+        original_val.each_with_index do |d, index|
+          new_value, is_changed = coerce_value!(d, schema.items)
+          if is_changed
+            original_val[index] = new_value
+            is_coerced = true
+          end
+        end
+
+        is_coerced
+      end
 
-    private
       def parse_date_time(original_val)
         begin
           DateTime.parse(original_val)

data/lib/committee/request_unpacker.rb

@@ -31,10 +31,7 @@ module Committee
         p = @request.POST
 
         if @coerce_form_params && @schema
-          p.merge!(Committee::StringParamsCoercer.new(
-            p,
-            @schema
-          ).call)
+          Committee::StringParamsCoercer.new(p, @schema).call!
         end
 
         p

data/lib/committee/string_params_coercer.rb

@@ -10,41 +10,90 @@ module Committee
   # errors are simply ignored and expected to be handled later by schema
   # validation.
   class StringParamsCoercer
-    def initialize(query_hash, schema)
+    def initialize(query_hash, schema, options = {})
       @query_hash = query_hash
       @schema = schema
+
+      @coerce_recursive = options.fetch(:coerce_recursive, false)
+    end
+
+    def call!
+      coerce_object!(@query_hash, @schema)
     end
 
-    def call
-      coerced = {}
-      @schema.properties.each do |k, s|
-        original_val = @query_hash[k]
+    private
+
+      def coerce_object!(hash, schema)
+        return false unless schema.respond_to?(:properties)
+
+        is_coerced = false
+        schema.properties.each do |k, s|
+          original_val = hash[k]
+          unless original_val.nil?
+            new_value, is_changed = coerce_value!(original_val, s)
+            if is_changed
+              hash[k] = new_value
+              is_coerced = true
+            end
+          end
+        end
+
+        is_coerced
+      end
+
+      def coerce_value!(original_val, s)
         unless original_val.nil?
           s.type.each do |to_type|
             case to_type
-            when "null"
-              coerced[k] = nil if original_val.empty?
-            when "integer"
-              begin
-                coerced[k] = Integer(original_val)
-              rescue ArgumentError => e
-                raise e unless e.message =~ /invalid value for Integer/
-              end
-            when "number"
-              begin
-                coerced[k] = Float(original_val)
-              rescue ArgumentError => e
-                raise e unless e.message =~ /invalid value for Float/
-              end
-            when "boolean"
-              coerced[k] = true if original_val == "true" || original_val == "1"
-              coerced[k] = false if original_val == "false" || original_val == "0"
+              when "null"
+                return nil, true if original_val.empty?
+              when "integer"
+                begin
+                  return Integer(original_val), true
+                rescue ArgumentError => e
+                  raise e unless e.message =~ /invalid value for Integer/
+                end
+              when "number"
+                begin
+                  return Float(original_val), true
+                rescue ArgumentError => e
+                  raise e unless e.message =~ /invalid value for Float/
+                end
+              when "boolean"
+                if original_val == "true" || original_val == "1"
+                  return true, true
+                end
+                if original_val == "false" || original_val == "0"
+                  return false, true
+                end
+              when "array"
+                if @coerce_recursive && coerce_array_data!(original_val, s)
+                  return original_val, true # change original value
+                end
+              when "object"
+                if @coerce_recursive && coerce_object!(original_val, s)
+                  return original_val, true # change original value
+                end
             end
-            break if coerced.key?(k)
           end
         end
+        return nil, false
+      end
+
+      def coerce_array_data!(original_val, schema)
+        return false unless schema.respond_to?(:items)
+        return false unless original_val.is_a?(Array)
+
+        is_coerced = false
+        original_val.each_with_index do |d, index|
+          new_value, is_changed = coerce_value!(d, schema.items)
+          if is_changed
+            original_val[index] = new_value
+            is_coerced = true
+          end
+        end
+
+        is_coerced
       end
-      coerced
-    end
   end
 end

data/test/middleware/request_validation_test.rb

@@ -7,6 +7,50 @@ describe Committee::Middleware::RequestValidation do
     @app
   end
 
+  ARRAY_PROPERTY = [
+      {
+          "update_time" => "2016-04-01T16:00:00.000+09:00",
+          "per_page" => 1,
+          "nested_coercer_object" => {
+              "update_time" => "2016-04-01T16:00:00.000+09:00",
+              "threshold" => 1.5
+          },
+          "nested_no_coercer_object" => {
+              "per_page" => 1,
+              "threshold" => 1.5
+          },
+          "nested_coercer_array" => [
+              {
+                  "update_time" => "2016-04-01T16:00:00.000+09:00",
+                  "threshold" => 1.5
+              }
+          ],
+          "nested_no_coercer_array" => [
+              {
+                  "per_page" => 1,
+                  "threshold" => 1.5
+              }
+          ],
+          "integer_array" => [
+              1, 2, 3
+          ],
+          "datetime_array" => [
+              "2016-04-01T16:00:00.000+09:00",
+              "2016-04-01T17:00:00.000+09:00",
+              "2016-04-01T18:00:00.000+09:00"
+          ]
+      },
+      {
+          "update_time" => "2016-04-01T16:00:00.000+09:00",
+          "per_page" => 1,
+          "threshold" => 1.5
+      },
+      {
+          "threshold" => 1.5,
+          "per_page" => 1
+      }
+  ]
+
   it "passes through a valid request" do
     @app = new_rack_app(schema: hyper_schema)
     params = {
@@ -35,18 +79,162 @@ describe Committee::Middleware::RequestValidation do
     assert_equal 200, last_response.status
   end
 
-  it "passes given a datetime and with coerce_date_times enabled on POST endpoint" do
+  it "passes a nested object with recursive option" do
     key_name = "update_time"
     params = {
-        key_name => "2016-04-01T16:00:00.000+09:00"
+        key_name => "2016-04-01T16:00:00.000+09:00",
+        "query" => "cloudnasium",
+        "array_property" => ARRAY_PROPERTY
     }
 
     check_parameter = lambda { |env|
+      hash = env['rack.request.query_hash']
+      assert_equal DateTime, hash['array_property'].first['update_time'].class
+      assert_equal 1, hash['array_property'].first['per_page']
+      assert_equal DateTime, hash['array_property'].first['nested_coercer_object']['update_time'].class
+      assert_equal 1, hash['array_property'].first['nested_no_coercer_object']['per_page']
+      assert_equal 2, hash['array_property'].first['integer_array'][1]
+      assert_equal DateTime, hash['array_property'].first['datetime_array'][0].class
+      assert_equal DateTime, hash[key_name].class
+      [200, {}, []]
+    }
+
+    @app = new_rack_app_with_lambda(check_parameter,
+                                    coerce_query_params: true,
+                                    coerce_recursive: true,
+                                    coerce_date_times: true,
+                                    schema: hyper_schema)
+
+    get "/search/apps", params
+    assert_equal 200, last_response.status
+  end
+
+  it "passes a nested object with coerce_recursive false" do
+    key_name = "update_time"
+    params = {
+        key_name => "2016-04-01T16:00:00.000+09:00",
+        "query" => "cloudnasium",
+        "array_property" => ARRAY_PROPERTY
+    }
+
+    @app = new_rack_app(coerce_query_params: true, coerce_date_times: true, coerce_recursive: false, schema: hyper_schema)
+
+    get "/search/apps", params
+    assert_equal 400, last_response.status # schema expect integer but we don't convert string to integer, so 400
+  end
+
+  it "passes a nested object with coerce_recursive default(true)" do
+    key_name = "update_time"
+    params = {
+        key_name => "2016-04-01T16:00:00.000+09:00",
+        "query" => "cloudnasium",
+        "array_property" => ARRAY_PROPERTY
+    }
+
+    @app = new_rack_app(coerce_query_params: true, coerce_date_times: true, schema: hyper_schema)
+
+    get "/search/apps", params
+    assert_equal 200, last_response.status # schema expect integer but we don't convert string to integer, so 400
+  end
+
+  it "passes given a nested datetime and with coerce_recursive=true and coerce_date_times=true on POST endpoint" do
+    key_name = "update_time"
+    params = {
+        key_name => "2016-04-01T16:00:00.000+09:00",
+        "array_property" => ARRAY_PROPERTY
+    }
+
+    check_parameter = lambda { |env|
+      hash = env['committee.params']
+      assert_equal DateTime, hash['array_property'].first['update_time'].class
+      assert_equal 1, hash['array_property'].first['per_page']
+      assert_equal DateTime, hash['array_property'].first['nested_coercer_object']['update_time'].class
+      assert_equal 1, hash['array_property'].first['nested_no_coercer_object']['per_page']
+      assert_equal 2, hash['array_property'].first['integer_array'][1]
+      assert_equal DateTime, hash['array_property'].first['datetime_array'][0].class
       assert_equal DateTime, env['committee.params'][key_name].class
       [200, {}, []]
     }
 
-    @app = new_rack_app_with_lambda(check_parameter, coerce_date_times: true, schema: hyper_schema)
+    @app = new_rack_app_with_lambda(check_parameter, coerce_date_times: true, coerce_recursive: true, schema: hyper_schema)
+
+    header "Content-Type", "application/json"
+    post "/apps", JSON.generate(params)
+    assert_equal 200, last_response.status
+  end
+
+  it "passes given a nested datetime and with coerce_recursive=true and coerce_date_times=true on POST endpoint" do
+    key_name = "update_time"
+    params = {
+        key_name => "2016-04-01T16:00:00.000+09:00",
+        "array_property" => ARRAY_PROPERTY
+    }
+
+    check_parameter = lambda { |env|
+      hash = env['committee.params']
+      assert_equal String, hash['array_property'].first['update_time'].class
+      assert_equal 1, hash['array_property'].first['per_page']
+      assert_equal String, hash['array_property'].first['nested_coercer_object']['update_time'].class
+      assert_equal 1, hash['array_property'].first['nested_no_coercer_object']['per_page']
+      assert_equal 2, hash['array_property'].first['integer_array'][1]
+      assert_equal String, hash['array_property'].first['datetime_array'][0].class
+      assert_equal String, env['committee.params'][key_name].class
+      [200, {}, []]
+    }
+
+    @app = new_rack_app_with_lambda(check_parameter, schema: hyper_schema)
+
+    header "Content-Type", "application/json"
+    post "/apps", JSON.generate(params)
+    assert_equal 200, last_response.status
+  end
+
+  it "passes given a nested datetime and with coerce_recursive=false and coerce_date_times=true on POST endpoint" do
+    key_name = "update_time"
+    params = {
+        key_name => "2016-04-01T16:00:00.000+09:00",
+        "array_property" => ARRAY_PROPERTY
+    }
+
+    check_parameter = lambda { |env|
+      hash = env['committee.params']
+      assert_equal String, hash['array_property'].first['update_time'].class
+      assert_equal 1, hash['array_property'].first['per_page']
+      assert_equal String, hash['array_property'].first['nested_coercer_object']['update_time'].class
+      assert_equal 1, hash['array_property'].first['nested_no_coercer_object']['per_page']
+      assert_equal 2, hash['array_property'].first['integer_array'][1]
+      assert_equal String, hash['array_property'].first['datetime_array'][0].class
+      assert_equal DateTime, env['committee.params'][key_name].class
+      [200, {}, []]
+    }
+
+    @app = new_rack_app_with_lambda(check_parameter, coerce_date_times: true, coerce_recursive: false, schema: hyper_schema)
+
+    header "Content-Type", "application/json"
+    post "/apps", JSON.generate(params)
+    assert_equal 200, last_response.status
+  end
+
+  it "passes given a nested datetime and with coerce_recursive=false and coerce_date_times=false on POST endpoint" do
+    key_name = "update_time"
+    params = {
+        key_name => "2016-04-01T16:00:00.000+09:00",
+        "array_property" => ARRAY_PROPERTY
+    }
+
+    check_parameter = lambda { |env|
+      hash = env['committee.params']
+      assert_equal String, hash['array_property'].first['update_time'].class
+      assert_equal 1, hash['array_property'].first['per_page']
+      assert_equal String, hash['array_property'].first['nested_coercer_object']['update_time'].class
+      assert_equal 1, hash['array_property'].first['nested_no_coercer_object']['per_page']
+      assert_equal 2, hash['array_property'].first['integer_array'][1]
+      assert_equal String, hash['array_property'].first['datetime_array'][0].class
+      assert_equal String, env['committee.params'][key_name].class
+      [200, {}, []]
+    }
+
+    @app = new_rack_app_with_lambda(check_parameter, schema: hyper_schema)
 
     header "Content-Type", "application/json"
     post "/apps", JSON.generate(params)
@@ -153,7 +341,12 @@ describe Committee::Middleware::RequestValidation do
   end
 
   it "passes through a valid request for OpenAPI" do
-    @app = new_rack_app(schema: open_api_2_schema)
+    check_parameter = lambda { |env|
+      assert_equal 3, env['rack.request.query_hash']['limit']
+      [200, {}, []]
+    }
+
+    @app = new_rack_app_with_lambda(check_parameter, schema: open_api_2_schema)
     get "/api/pets?limit=3"
     assert_equal 200, last_response.status
   end

data/test/parameter_coercer_test.rb

@@ -12,22 +12,100 @@ describe Committee::ParameterCoercer do
 
   it "pass datetime string" do
     params = { "update_time" => "2016-04-01T16:00:00.000+09:00"}
-    converted_params = call(params, coerce_date_times: true)
+    call(params, coerce_date_times: true)
 
-    assert_kind_of DateTime, converted_params["update_time"]
+    assert_kind_of DateTime, params["update_time"]
+  end
+
+  it "don't change object type" do
+    params = HashLikeObject.new
+    params["update_time"] = "2016-04-01T16:00:00.000+09:00"
+    call(params, coerce_date_times: true)
+
+    assert_kind_of DateTime, params["update_time"]
+    assert_kind_of HashLikeObject, params
   end
 
   it "pass invalid datetime string, not convert" do
-    params = { "update_time" => "llmfllmf"}
-    converted_params = call(params, coerce_date_times: true)
+    invalid_datetime = "llmfllmf"
+    params = { "update_time" => invalid_datetime}
+    call(params, coerce_date_times: true)
 
-    assert_nil converted_params["update_time"]
+    assert_equal invalid_datetime, params["update_time"]
+  end
+
+  it "pass array property" do
+    params = {
+        "array_property" => [
+            {
+                "update_time" => "2016-04-01T16:00:00.000+09:00",
+                "per_page" => 1,
+                "nested_coercer_object" => {
+                    "update_time" => "2016-04-01T16:00:00.000+09:00",
+                    "threshold" => 1.5
+                },
+                "nested_no_coercer_object" => {
+                    "per_page" => 1,
+                    "threshold" => 1.5
+                },
+                "nested_coercer_array" => [
+                    {
+                        "update_time" => "2016-04-01T16:00:00.000+09:00",
+                        "threshold" => 1.5
+                    }
+                ],
+                "nested_no_coercer_array" => [
+                    {
+                        "per_page" => 1,
+                        "threshold" => 1.5
+                    }
+                ]
+            },
+            {
+                "update_time" => "2016-04-01T16:00:00.000+09:00",
+                "per_page" => 1,
+                "threshold" => 1.5
+            },
+            {
+                "threshold" => 1.5,
+                "per_page" => 1
+            }
+        ],
+    }
+    call(params, coerce_date_times: true, coerce_recursive: true)
+
+    first_data = params["array_property"][0]
+    assert_kind_of DateTime, first_data["update_time"]
+    assert_kind_of Integer, first_data["per_page"]
+
+    second_data = params["array_property"][1]
+    assert_kind_of DateTime, second_data["update_time"]
+    assert_kind_of Integer, second_data["per_page"]
+    assert_kind_of Float, second_data["threshold"]
+
+    third_data = params["array_property"][1]
+    assert_kind_of Integer, third_data["per_page"]
+    assert_kind_of Float, third_data["threshold"]
+
+    assert_kind_of DateTime, first_data["nested_coercer_object"]["update_time"]
+    assert_kind_of Float, first_data["nested_coercer_object"]["threshold"]
+
+    assert_kind_of Integer, first_data["nested_no_coercer_object"]["per_page"]
+    assert_kind_of Float, first_data["nested_no_coercer_object"]["threshold"]
+
+    assert_kind_of DateTime, first_data["nested_coercer_array"].first["update_time"]
+    assert_kind_of Float, first_data["nested_coercer_array"].first["threshold"]
+
+    assert_kind_of Integer, first_data["nested_no_coercer_array"].first["per_page"]
+    assert_kind_of Float, first_data["nested_no_coercer_array"].first["threshold"]
   end
 
   private
 
+  class HashLikeObject < Hash; end
+
   def call(params, options={})
     link = Committee::Drivers::HyperSchema::Link.new(@link)
-    Committee::ParameterCoercer.new(params, link.schema, options).call
+    Committee::ParameterCoercer.new(params, link.schema, options).call!
   end
 end

data/test/string_params_coercer_test.rb

@@ -9,65 +9,122 @@ describe Committee::StringParamsCoercer do
   end
 
   it "doesn't coerce params not in the schema" do
-    data = {"owner" => "admin"}
-    assert_equal({}, call(data))
+    check_convert("onwer", "admin", "admin")
   end
 
   it "skips values for string param" do
-    data = {"name" => "foo"}
-    assert_equal({}, call(data))
+    check_convert("name", "foo", "foo")
   end
 
   it "coerces valid values for boolean param" do
-    data = {"deleted" => "true"}
-    assert_equal({"deleted" => true}, call(data))
-    data = {"deleted" => "false"}
-    assert_equal({"deleted" => false}, call(data))
-    data = {"deleted" => "1"}
-    assert_equal({"deleted" => true}, call(data))
-    data = {"deleted" => "0"}
-    assert_equal({"deleted" => false}, call(data))
+    check_convert("deleted", "true", true)
+    check_convert("deleted", "false", false)
+    check_convert("deleted", "1", true)
+    check_convert("deleted", "0", false)
   end
 
   it "skips invalid values for boolean param" do
-    data = {"deleted" => "foo"}
-    assert_equal({}, call(data))
+    check_convert("deleted", "foo", "foo")
   end
 
   it "coerces valid values for integer param" do
-    data = {"per_page" => "3"}
-    assert_equal({"per_page" => 3}, call(data))
+    check_convert("per_page", "3", 3)
   end
 
   it "skips invalid values for integer param" do
-    data = {"per_page" => "3.5"}
-    assert_equal({}, call(data))
-    data = {"per_page" => "false"}
-    assert_equal({}, call(data))
-    data = {"per_page" => ""}
-    assert_equal({}, call(data))
+    check_convert("per_page", "3.5", "3.5")
+    check_convert("per_page", "false", "false")
+    check_convert("per_page", "", "")
   end
 
   it "coerces valid values for number param" do
-    data = {"threshold" => "3"}
-    assert_equal({"threshold" => 3.0}, call(data))
-    data = {"threshold" => "3.5"}
-    assert_equal({"threshold" => 3.5}, call(data))
+    check_convert("threshold", "3", 3.0)
+    check_convert("threshold", "3.5", 3.5)
   end
 
   it "skips invalid values for number param" do
-    data = {"threshold" => "false"}
-    assert_equal({}, call(data))
+    check_convert("threshold", "false", "false")
   end
 
   it "coerces valid values for null param" do
-    data = {"threshold" => ""}
-    assert_equal({"threshold" => nil}, call(data))
+    check_convert("threshold", "", nil)
+  end
+
+  it "pass array property" do
+    params = {
+        "array_property" => [
+            {
+                "update_time" => "2016-04-01T16:00:00.000+09:00",
+                "per_page" => "1",
+                "nested_coercer_object" => {
+                    "update_time" => "2016-04-01T16:00:00.000+09:00",
+                    "threshold" => "1.5"
+                },
+                "nested_no_coercer_object" => {
+                    "per_page" => "1",
+                    "threshold" => "1.5"
+                },
+                "nested_coercer_array" => [
+                    {
+                        "update_time" => "2016-04-01T16:00:00.000+09:00",
+                        "threshold" => "1.5"
+                    }
+                ],
+                "nested_no_coercer_array" => [
+                    {
+                        "per_page" => "1",
+                        "threshold" => "1.5"
+                    }
+                ]
+            },
+            {
+                "update_time" => "2016-04-01T16:00:00.000+09:00",
+                "per_page" => "1",
+                "threshold" => "1.5"
+            },
+            {
+                "threshold" => "1.5",
+                "per_page" => "1"
+            }
+        ],
+    }
+    call(params, coerce_recursive: true)
+
+    first_data = params["array_property"][0]
+    assert_kind_of String, first_data["update_time"]
+    assert_kind_of Integer, first_data["per_page"]
+
+    second_data = params["array_property"][1]
+    assert_kind_of String, second_data["update_time"]
+    assert_kind_of Integer, second_data["per_page"]
+    assert_kind_of Float, second_data["threshold"]
+
+    third_data = params["array_property"][1]
+    assert_kind_of Integer, third_data["per_page"]
+    assert_kind_of Float, third_data["threshold"]
+
+    assert_kind_of String, first_data["nested_coercer_object"]["update_time"]
+    assert_kind_of Float, first_data["nested_coercer_object"]["threshold"]
+
+    assert_kind_of Integer, first_data["nested_no_coercer_object"]["per_page"]
+    assert_kind_of Float, first_data["nested_no_coercer_object"]["threshold"]
+
+    assert_kind_of String, first_data["nested_coercer_array"].first["update_time"]
+    assert_kind_of Float, first_data["nested_coercer_array"].first["threshold"]
+
+    assert_kind_of Integer, first_data["nested_no_coercer_array"].first["per_page"]
+    assert_kind_of Float, first_data["nested_no_coercer_array"].first["threshold"]
   end
 
   private
 
-  def call(data)
-    Committee::StringParamsCoercer.new(data, @link.schema).call
+  def check_convert(key, before_value, after_value)
+    data = {key => before_value}
+    call(data)
+    assert_equal(data[key], after_value)
+  end
+
+  def call(data, options={})
+    Committee::StringParamsCoercer.new(data, @link.schema, options).call!
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: committee
 version: !ruby/object:Gem::Version
-  version: 2.0.0.pre8
+  version: 2.0.0
 platform: ruby
 authors:
 - Brandur
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-27 00:00:00.000000000 Z
+date: 2017-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json_schema
@@ -207,12 +207,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: A collection of Rack middleware to support JSON Schema.