schemacop 3.0.6 → 3.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db3239081f4731794b9e52be8901752fc9ed70ca8a0c6b0afaa148be11015f36
-  data.tar.gz: cdb44d05750c603be99188670833605da946f507ab726456ed49aa2422381e68
+  metadata.gz: 40958dccae4c661f133f181907cc729c0002ca02702a6675c1beb1c90fed425e
+  data.tar.gz: 4ef5dcf205bd5f5cc8203867e95d07ff5a56a8c4654f3eac89e90596cb9a2e39
 SHA512:
-  metadata.gz: c64bf86004b0f5a0c7e52aa833d7b37efe267c993bd26fd7cadfa18891dbcc6375c89f0af68f91c168c0b83fa9e641dc5e3ec6b5121b9c67d8135956beec5a1d
-  data.tar.gz: f4c6d201ff95b6a1f2e0ebf6c6c447a0047ef72f39257b533420b64d5000573a6f4e58d2f95f5f4e0ba50397a8d8a76e7b08298d5338aff50ebce52bd73cacec
+  metadata.gz: 1af517385c88340f64067895363b6e79d2ce15e00415ef5d0110200706b2e264701e6a0eeac9332e2ea8d9c5967989e8e05a9e311291a1e942d1effc5cc15219
+  data.tar.gz: c773bd33014ae3a8ccb4f1cd22c2066b375de678fdde702d2d95dcbc78880bd6d19940bb06b8052b06f955bc740834b7761f5c389d21bec56250ee18a4680ce6

data/.releaser_config

@@ -1,3 +1,4 @@
 version_file: VERSION
 always_from_master: true
 gem_style: github
+ruby_command: ruby -S

data/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Change log
 
+## 3.0.11 (2021-03-26)
+
+* Treat blank string as nil when using `cast_str` option
+
+## 3.0.10 (2021-03-19)
+
+* If wrong type is given, report class of wrong type in error message
+
+## 3.0.9 (2021-02-26)
+
+* Fix casting of blank strings
+
+* Add `allow_blank` option to `String` nodes
+
+## 3.0.8 (2021-02-23)
+
+* Fix `object` nodes in hashes with no classes
+
+* Document `cast_str` option
+
+## 3.0.7 (2021-02-22)
+
+* Adapt schema definitions handling when using Swagger-standard JSON
+
 ## 3.0.6 (2021-02-14)
 
 * Remove option `json_format` from {Schemacop::Schema3.as_json as_json} again.

data/README_V3.md

@@ -75,12 +75,12 @@ Schemacop can raise the following exceptions:
   Example:
 
   ```ruby
-  schema = Schemacop::Schema3.new do
+  schema = Schemacop::Schema3.new :hash do
     int! :foo
   end
 
   schema.validate!(foo: 'bar')
-  # => Schemacop::Exceptions::ValidationError: /foo: Invalid type, expected "integer".
+  # => Schemacop::Exceptions::ValidationError: /foo: Invalid type, got type "String", expected "integer".
   ```
 
 * `Schemacop::Exceptions::InvalidSchemaError`: This exception is raised when the
@@ -141,7 +141,7 @@ schema = Schemacop::Schema3.new :string, enum: ['foo', 'bar', 42]
 
 schema.validate!('foo') # => "foo"
 schema.validate!('bar') # => "bar"
-schema.validate!(42)    # => Schemacop::Exceptions::ValidationError: /: Invalid type, expected "string".
+schema.validate!(42)    # => Schemacop::Exceptions::ValidationError: /: Invalid type, got type "Integer", expected "string".
 ```
 
 The enum will also be provided in the json output:
@@ -178,7 +178,7 @@ Note that the default value you use is also validated against the schema:
 schema = Schemacop::Schema3.new :string, default: 42
 
 schema.validate!('foo') # => "foo"
-schema.validate!(nil)   # => Schemacop::Exceptions::ValidationError: /: Invalid type, expected "string".
+schema.validate!(nil)   # => Schemacop::Exceptions::ValidationError: /: Invalid type, got type "Integer", expected "string".
 ```
 
 ## Nodes
@@ -199,14 +199,19 @@ transformed into various types.
 * `max_length`
   Defines the (inclusive) maximum required string length
 * `pattern`
-  Defines a (ruby) regex pattern the value will be matched against. Must be a
-  string and should generally start with `^` and end with `$` so as to evaluate
-  the entire string. It should not be enclosed in `/` characters.
+  Defines a (ruby) regex pattern the value will be matched against. Must be either
+  a string which should not be enclosed in `/` characters, or a Ruby Regexp.
+  The pattern should generally start with `^` and end with `$` so as to evaluate
+  the entire string.
 * `format`
   The `format` option allows for basic semantic validation on certain kinds of
   string values that are commonly used. See section *formats* for more
   information on the available formats. Note that strings with a format are also
   **casted** into that format.
+* `allow_blank`
+  By default, blank strings are allowed and left as they are when casted (e.g.
+  the string `''` is valid). If you want to disallow blank strings, set this
+  option to `false`.
 
 #### Formats
 
@@ -246,6 +251,38 @@ transformed into various types.
 
 #### Examples
 
+```ruby
+# Basic example
+schema = Schemacop::Schema3.new :string
+schema.validate!(nil)   # => nil
+schema.validate!('')    # => ""
+schema.validate!('foo') # => "foo"
+schema.validate!("\n")  # => "\n"
+```
+
+With the `required` option:
+
+```ruby
+# Basic example
+schema = Schemacop::Schema3.new :string, required: true
+schema.validate!(nil)   # => Schemacop::Exceptions::ValidationError: /: Value must be given.
+schema.validate!('')    # => ""
+schema.validate!('foo') # => "foo"
+schema.validate!("\n")  # => "\n"
+```
+
+With the `allow_blank` option:
+
+```ruby
+# Basic example
+schema = Schemacop::Schema3.new :string, allow_blank: false
+schema.validate!(nil)   # => Schemacop::Exceptions::ValidationError: /: String is blank but must not be blank!
+schema.validate!('')    # => Schemacop::Exceptions::ValidationError: /: String is blank but must not be blank!
+schema.validate!('foo') # => "foo"
+schema.validate!("\n")  # => Schemacop::Exceptions::ValidationError: /: String is blank but must not be blank!
+```
+Example of using a `format` option:
+
 ```ruby
 # By using a format, string values are casted to that respective format
 schema = Schemacop::Schema3.new(:string, format: :date)
@@ -277,6 +314,10 @@ integer can be done.
 * `multiple_of`
   The received number has to be a multiple of the given number for the validation to
   pass.
+* `cast_str`
+  When set to `true`, this node also accepts strings that can be casted to an integer, e.g.
+  the values `'-5'` or `'42'`. Please note that you can only validate numbers which
+  are in the `Integer` format. Blank strings will be treated equally as `nil`.
 
 #### Examples
 
@@ -287,10 +328,37 @@ schema.validate!(42)            # => 42
 schema.validate!(43)            # => Schemacop::Exceptions::ValidationError: /: Value must be a multiple of 2.
 schema.validate!(-2)            # => Schemacop::Exceptions::ValidationError: /: Value must have a minimum of 0.
 schema.validate!(102)           # => Schemacop::Exceptions::ValidationError: /: Value must have a maximum of 100.
-schema.validate!(42.1)          # => Schemacop::Exceptions::ValidationError: /: Invalid type, expected "integer".
-schema.validate!(4r)            # => Schemacop::Exceptions::ValidationError: /: Invalid type, expected "integer".
-schema.validate!((4 + 0i))      # => Schemacop::Exceptions::ValidationError: /: Invalid type, expected "integer".
-schema.validate!(BigDecimal(5)) # => Schemacop::Exceptions::ValidationError: /: Invalid type, expected "integer".
+schema.validate!(42.1)          # => Schemacop::Exceptions::ValidationError: /: Invalid type, got type "Float", expected "integer".
+schema.validate!(4r)            # => Schemacop::Exceptions::ValidationError: /: Invalid type, got type "Rational", expected "integer".
+schema.validate!((4 + 0i))      # => Schemacop::Exceptions::ValidationError: /: Invalid type, got type "Complex", expected "integer".
+schema.validate!(BigDecimal(5)) # => Schemacop::Exceptions::ValidationError: /: Invalid type, got type "BigDecimal", expected "integer".
+```
+
+With `cast_str` enabled:
+
+```ruby
+# Validates that the input is an even number between 0 and 100 (inclusive)
+schema = Schemacop::Schema3.new(:integer, minimum: 0, maximum: 100, multiple_of: 2, cast_str: true)
+schema.validate!('42')            # => 42
+schema.validate!('43')            # => Schemacop::Exceptions::ValidationError: /: Matches 0 definitions but should match exactly 1.
+schema.validate!('-2')            # => Schemacop::Exceptions::ValidationError: /: Matches 0 definitions but should match exactly 1.
+schema.validate!('102')           # => Schemacop::Exceptions::ValidationError: /: Matches 0 definitions but should match exactly 1.
+schema.validate!('42.1')          # => Schemacop::Exceptions::ValidationError: /: Matches 0 definitions but should match exactly 1.
+schema.validate!('4r')            # => Schemacop::Exceptions::ValidationError: /: Matches 0 definitions but should match exactly 1.
+schema.validate!('(4 + 0i)')      # => Schemacop::Exceptions::ValidationError: /: Matches 0 definitions but should match exactly 1.
+schema.validate!(nil)             # => nil
+schema.validate!('')              # => nil
+```
+
+Please note, that `nil` and blank strings are treated equally when using the `cast_str` option,
+and validating a blank string will return `nil`.
+If you need a value, use the `required` option:
+
+```ruby
+schema = Schemacop::Schema3.new(:integer, minimum: 0, maximum: 100, multiple_of: 2, cast_str: true, required: true)
+schema.validate!('42')  # => 42
+schema.validate!(nil)   # => Schemacop::Exceptions::ValidationError: /: Value must be given.
+schema.validate!('')    # => Schemacop::Exceptions::ValidationError: /: Value must be given.
 ```
 
 ### Number
@@ -327,6 +395,11 @@ With the various available options, validations on the value of the number can b
 * `multiple_of`
   The received number has to be a multiple of the given number for the validation to
   pass.
+* `cast_str`
+  When set to `true`, this node also accepts strings that can be casted to a number, e.g.
+  the values `'0.1'` or `'3.1415'`. Please note that you can only validate numbers which
+  are in the `Integer` or `Float` format, i.e. values like `'1.5r'` or `'(4 + 0i)'` will
+  not work. Blank strings will be treated equally as `nil`.
 
 #### Examples
 
@@ -340,7 +413,33 @@ schema.validate!(51)            # => Schemacop::Exceptions::ValidationError: /:
 schema.validate!(42.5)          # => 42.5
 schema.validate!(1.5r)          # => (3/2)
 schema.validate!(BigDecimal(5)) # => 0.5e1
-schema.validate!((4 + 0i))      # => Schemacop::Exceptions::ValidationError: /: Invalid type, expected "big_decimal" or "float" or "integer" or "rational".
+schema.validate!((4 + 0i))      # => Schemacop::Exceptions::ValidationError: /: Invalid type, got type "Complex", expected "big_decimal" or "float" or "integer" or "rational"
+```
+
+With `cast_str` enabled:
+
+```ruby
+schema = Schemacop::Schema3.new(:number, cast_str: true, minimum: 0.0, maximum: (50r), multiple_of: BigDecimal('0.5'))
+schema.validate!('42')        # => 42
+schema.validate!('42.2')      # => Schemacop::Exceptions::ValidationError: /: Matches 0 definitions but should match exactly 1.
+schema.validate!('-2')        # => Schemacop::Exceptions::ValidationError: /: Matches 0 definitions but should match exactly 1.
+schema.validate!('51')        # => Schemacop::Exceptions::ValidationError: /: Matches 0 definitions but should match exactly 1.
+schema.validate!('42.5')      # => 42.5
+schema.validate!('1.5r')      # => Schemacop::Exceptions::ValidationError: /: Matches 0 definitions but should match exactly 1.
+schema.validate!('(4 + 0i)')  # => Schemacop::Exceptions::ValidationError: /: Matches 0 definitions but should match exactly 1.
+schema.validate!(nil)         # => nil
+schema.validate!('')          # => nil
+```
+
+Please note, that `nil` and blank strings are treated equally when using the `cast_str` option,
+and validating a blank string will return `nil`.
+If you need a value, use the `required` option:
+
+```ruby
+schema = Schemacop::Schema3.new(:number, cast_str: true, minimum: 0.0, maximum: (50r), multiple_of: BigDecimal('0.5'), require: true)
+schema.validate!('42.5')  # => 42.5
+schema.validate!(nil)     # => Schemacop::Exceptions::ValidationError: /: Value must be given.
+schema.validate!('')      # => Schemacop::Exceptions::ValidationError: /: Value must be given.
 ```
 
 ### Symbol
@@ -350,15 +449,46 @@ DSL: `sym`
 
 The symbol type is used to validate elements for the Ruby `Symbol` class.
 
+#### Options
+
+* `cast_str`
+  When set to `true`, this node also accepts strings that can be casted to a symbol. Blank strings will be treated equally as `nil`.
+
 #### Examples
 
 ```ruby
 # Validates that the input is a symbol
 schema = Schemacop::Schema3.new(:symbol)
-schema.validate!(:foo)  # => :foo
-schema.validate!('foo') # => Schemacop::Exceptions::ValidationError: /: Invalid type, expected "Symbol".
-schema.validate!(123)   # => Schemacop::Exceptions::ValidationError: /: Invalid type, expected "Symbol".
-schema.validate!(false) # => Schemacop::Exceptions::ValidationError: /: Invalid type, expected "Symbol".
+schema.validate!(:foo)   # => :foo
+schema.validate!('foo')  # => Schemacop::Exceptions::ValidationError: /: Invalid type, got type "String", expected "Symbol".
+schema.validate!(123)    # => Schemacop::Exceptions::ValidationError: /: Invalid type, got type "Integer", expected "Symbol".
+schema.validate!(false)  # => Schemacop::Exceptions::ValidationError: /: Invalid type, got type "FalseClass", expected "Symbol".
+schema.validate!(:false) # => :false
+```
+
+With `cast_str` enabled:
+
+```ruby
+# Validates that the input is a symbol
+schema = Schemacop::Schema3.new(:symbol, cast_str: true)
+schema.validate!(':foo')   # => :":foo"
+schema.validate!('foo')    # => :foo
+schema.validate!('123')    # => :"123"
+schema.validate!('false')  # => :false
+schema.validate!(':false') # => :":false"
+schema.validate!(nil)      # => nil
+schema.validate!('')       # => nil
+```
+
+Please note, that `nil` and blank strings are treated equally when using the `cast_str` option,
+and validating a blank string will return `nil`.
+If you need a value, use the `required` option:
+
+```ruby
+schema = Schemacop::Schema3.new(:symbol, cast_str: true, required: true)
+schema.validate!('foo')   # => :foo
+schema.validate!(nil)     # => Schemacop::Exceptions::ValidationError: /: Value must be given.
+schema.validate!('')      # => Schemacop::Exceptions::ValidationError: /: Value must be given.
 ```
 
 ### Boolean
@@ -368,6 +498,12 @@ DSL: `boo`
 
 The boolean type is used to validate Ruby booleans, i.e. the `TrueClass` and `FalseClass`
 
+#### Options
+
+* `cast_str`
+  When set to `true`, this node also accepts strings that can be casted to a boolean, i.e.
+  the values `'true'` and `'false'`. Blank strings will be treated equally as `nil`.
+
 #### Examples
 
 ```ruby
@@ -375,9 +511,33 @@ The boolean type is used to validate Ruby booleans, i.e. the `TrueClass` and `Fa
 schema = Schemacop::Schema3.new(:boolean)
 schema.validate!(true)    # => true
 schema.validate!(false)   # => false
-schema.validate!(:false)  # => Schemacop::Exceptions::ValidationError: /: Invalid type, expected "boolean".
-schema.validate!('false') # => Schemacop::Exceptions::ValidationError: /: Invalid type, expected "boolean".
-schema.validate!(1234)    # => Schemacop::Exceptions::ValidationError: /: Invalid type, expected "boolean".
+schema.validate!(:false)  # => Schemacop::Exceptions::ValidationError: /: Invalid type, got type "Symbol", expected "boolean".
+schema.validate!('false') # => Schemacop::Exceptions::ValidationError: /: Invalid type, got type "String", expected "boolean".
+schema.validate!(1234)    # => Schemacop::Exceptions::ValidationError: /: Invalid type, got type "Integer", expected "boolean".
+```
+
+With `cast_str` enabled:
+
+```ruby
+schema = Schemacop::Schema3.new(:boolean, cast_str: true)
+schema.validate!(true)    # => true
+schema.validate!(false)   # => false
+schema.validate!(:false)  # => Schemacop::Exceptions::ValidationError: /: Matches 0 definitions but should match exactly 1.
+schema.validate!('false') # => false
+schema.validate!(1234)    # => Schemacop::Exceptions::ValidationError: /: Matches 0 definitions but should match exactly 1.
+schema.validate!(nil)     # => nil
+schema.validate!('')      # => nil
+```
+
+Please note, that `nil` and blank strings are treated equally when using the `cast_str` option,
+and validating a blank string will return `nil`.
+If you need a value, use the `required` option:
+
+```ruby
+schema = Schemacop::Schema3.new(:boolean, cast_str: true, required: true)
+schema.validate!('false') # => false
+schema.validate!(nil)     # => Schemacop::Exceptions::ValidationError: /: Value must be given.
+schema.validate!('')      # => Schemacop::Exceptions::ValidationError: /: Value must be given.
 ```
 
 ### Array
@@ -420,7 +580,7 @@ end
 
 schema.validate!([])      # => Schemacop::Exceptions::ValidationError: /: At least one entry must match schema {"type"=>"integer", "minimum"=>5}.
 schema.validate!([1, 5])  # => [1, 5]
-schema.validate!(['foo']) # => Schemacop::Exceptions::ValidationError: /[0]: Invalid type, expected "integer". /: At least one entry must match schema {"type"=>"integer", "minimum"=>5}
+schema.validate!(['foo']) # => Schemacop::Exceptions::ValidationError: /[0]: Invalid type, got type "String", expected "integer". /: At least one entry must match schema {"type"=>"integer", "minimum"=>5}
 ```
 
 You can also use it with the tuple validation (see below), e.g. if you want
@@ -461,10 +621,10 @@ schema = Schemacop::Schema3.new :array do
   list :integer, minimum: 1, maximum: 5
 end
 
-schema.validate!([])     # => []
-schema.validate!([1, 3]) # => [1, 3]
-schema.validate!([0, 6]) # => Schemacop::Exceptions::ValidationError: /[0]: Value must have a minimum of 1. /[1]: Value must have a maximum of 5.
-schema.validate! ['foo'] # => Schemacop::Exceptions::ValidationError: /[0]: Invalid type, expected "integer".
+schema.validate!([])      # => []
+schema.validate!([1, 3])  # => [1, 3]
+schema.validate!([0, 6])  # => Schemacop::Exceptions::ValidationError: /[0]: Value must have a minimum of 1. /[1]: Value must have a maximum of 5.
+schema.validate!(['foo']) # => Schemacop::Exceptions::ValidationError: /[0]: Invalid type, got type "String", expected "integer".
 ```
 
 You can also build more complex structures, e.g. an array containing an arbitrary
@@ -479,7 +639,7 @@ end
 
 schema.validate!([])                # => []
 schema.validate!([[1], [2, 3]])     # => [[1], [2, 3]]
-schema.validate!([['foo'], [2, 3]]) # => Schemacop::Exceptions::ValidationError: /[0]/[0]: Invalid type, expected "integer".
+schema.validate!([['foo'], [2, 3]]) # => Schemacop::Exceptions::ValidationError: /[0]/[0]: Invalid type, got type "String", expected "integer".
 ```
 
 Please note that you can only specify *one* `list` item:
@@ -541,7 +701,7 @@ end
 
 schema.validate!([])                # => Schemacop::Exceptions::ValidationError: /: Array has 0 items but must have exactly 2.
 schema.validate!([1, 'foo'])        # => [1, "foo"]
-schema.validate!([1, 'foo', 'bar']) # => Schemacop::Exceptions::ValidationError: /[2]: Invalid type, expected "integer".
+schema.validate!([1, 'foo', 'bar']) # => Schemacop::Exceptions::ValidationError: /[2]: Invalid type, got type "String", expected "integer".
 schema.validate!([1, 'foo', 2, 3])  # => [1, "foo", 2, 3]
 ```
 
@@ -700,7 +860,7 @@ schema = Schemacop::Schema3.new :hash do
   str? :foo
 end
 
-schema.validate!({foo: 1})      # => Schemacop::Exceptions::ValidationError: /foo: Invalid type, expected "string".
+schema.validate!({foo: 1})      # => Schemacop::Exceptions::ValidationError: /foo: Invalid type, got type "Integer", expected "string".
 schema.validate!({foo: 'bar'})  # => {"foo"=>"bar"}
 ```
 
@@ -784,7 +944,7 @@ end
 
 schema.validate!({id: 1})             # => {"id"=>1}
 schema.validate!({id: 1, foo: 'bar'}) # => {"id"=>1, "foo"=>"bar"}
-schema.validate!({id: 1, foo: 42})    # => Schemacop::Exceptions::ValidationError: /foo: Invalid type, expected "string".
+schema.validate!({id: 1, foo: 42})    # => Schemacop::Exceptions::ValidationError: /foo: Invalid type, got type "Integer", expected "string".
 ```
 
 Using the option `property_names`, you can additionaly specify a pattern that
@@ -808,8 +968,8 @@ end
 
 schema.validate!({})                # => {}
 schema.validate!({foo: [1, 2, 3]})  # => {"foo"=>[1, 2, 3]}
-schema.validate!({foo: :bar})       # => Schemacop::Exceptions::ValidationError: /foo: Invalid type, expected "array".
-schema.validate!({Foo: :bar})       # => Schemacop::Exceptions::ValidationError: /: Property name :Foo does not match "^[a-z]+$". /Foo: Invalid type, expected "array".
+schema.validate!({foo: :bar})       # => Schemacop::Exceptions::ValidationError: /foo: Invalid type, got type "Symbol", expected "array".
+schema.validate!({Foo: :bar})       # => Schemacop::Exceptions::ValidationError: /: Property name :Foo does not match "^[a-z]+$". /Foo: Invalid type, got type "Symbol", expected "array".
 ```
 
 ##### Dependencies
@@ -883,10 +1043,10 @@ of allowed classes:
 schema = Schemacop::Schema3.new :object, classes: [String]
 
 schema.validate!(nil)             # => nil
-schema.validate!(true)            # => Schemacop::Exceptions::ValidationError: /: Invalid type, expected "String".
-schema.validate!(Object.new)      # => Schemacop::Exceptions::ValidationError: /: Invalid type, expected "String".
+schema.validate!(true)            # => Schemacop::Exceptions::ValidationError: /: Invalid type, got type "TrueClass", expected "String".
+schema.validate!(Object.new)      # => Schemacop::Exceptions::ValidationError: /: Invalid type, got type "Object", expected "String".
 schema.validate!('foo')           # => "foo"
-schema.validate!('foo'.html_safe) # => Schemacop::Exceptions::ValidationError: /: Invalid type, expected "String".
+schema.validate!('foo'.html_safe) # => Schemacop::Exceptions::ValidationError: /: Invalid type, got type "ActiveSupport::SafeBuffer", expected "String".
 ```
 
 Here, the node checks if the given value is an instance of any of the given
@@ -898,8 +1058,8 @@ If you want to allow subclasses, you can specify this by using the `strict` opti
 schema = Schemacop::Schema3.new :object, classes: [String], strict: false
 
 schema.validate!(nil)             # => nil
-schema.validate!(true)            # => Schemacop::Exceptions::ValidationError: /: Invalid type, expected "String".
-schema.validate!(Object.new)      # => Schemacop::Exceptions::ValidationError: /: Invalid type, expected "String".
+schema.validate!(true)            # => Schemacop::Exceptions::ValidationError: /: Invalid type, got type "TrueClass", expected "String".
+schema.validate!(Object.new)      # => Schemacop::Exceptions::ValidationError: /: Invalid type, got type "Object", expected "String".
 schema.validate!('foo')           # => "foo"
 schema.validate!('foo'.html_safe) # => "foo"
 ```
@@ -1072,7 +1232,7 @@ schema.validate!({
   shipping_address: 'foo',
   billing_address: 42
 })
-# => Schemacop::Exceptions::ValidationError: /shipping_address: Invalid type, expected "object". /billing_address: Invalid type, expected "object".
+# => Schemacop::Exceptions::ValidationError: /shipping_address: Invalid type, got type "String", expected "object". /billing_address: Invalid type, got type "Integer", expected "object".
 
 schema.validate!({
   shipping_address: {

data/VERSION

@@ -1 +1 @@
-3.0.6
+3.0.11

data/lib/schemacop/v3/boolean_node.rb

@@ -19,6 +19,10 @@ module Schemacop
           default
         end
       end
+
+      def self.allowed_options
+        super + %i[cast_str]
+      end
     end
   end
 end