schemacop 3.0.5 → 3.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 27400e248bfdb65fc7cc229fbbb625cfa68a1421996fc5cbbb3283eb82d28a1e
-  data.tar.gz: 4b435374b7d2c0ce05e4410235995983dc0f96c8d6c21b69d88e80abdae7aed0
+  metadata.gz: 8700be126ea3aced42828ce418ad665095584ba0e217eebb0cf2e42faf5b4aef
+  data.tar.gz: 9774973e128d64f02a06e84cfa19990b0a7b0890cf57d4fb94c0f5058337dd20
 SHA512:
-  metadata.gz: 194c2f72fcadad2e311e1c96ca9bfd004e5f27c5d591bd1188a1fb177d56a75aa2670b50fddc07e7afaee99fd48f98195156a8f98a250485fd6a75a0ac57bda8
-  data.tar.gz: 798a3dfaf53b6c2996e2799cc841bdf2172ef4ebd89c022c67a2d21424add61f1c0ef0c686e11c17b589b417961343f603012395e5510284573cb8a7e78a3468
+  metadata.gz: 0cdd515a0d47c7d707b8418fa5f0c7e6e73375ccb28bd2552b8c5f960e0279c75fb3a89c99b4ff677069c7a75e3d2f2376645d720d0d65980688602af09e4d28
+  data.tar.gz: 27cb5b5b8c4c8e14601c907c443d4fd904457ad0762c31af26aabf7d75febbf49459555e19665a1e56674b05601b4a223ccc18cb12fcebf9fddd526c3ec37442

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,14 +1,34 @@
 # Change log
 
-<!--
-## master (unreleased)
+## 3.0.10 (2021-03-19)
 
-### New features
+* If wrong type is given, report class of wrong type in error message
 
-### Bug fixes
+## 3.0.9 (2021-02-26)
 
-### Changes
--->
+* 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.
+  If you need to use the swagger format, use
+  {Schemacop::V3::Context.with_json_format} instead.
+
+* Rename `Schemacop::V3::Context.spawn_with` to
+  {Schemacop::V3::Context.with_json_format} and make keyword argument
+  `json_format` a positional argument.
 
 ## 3.0.5 (2021-02-14)
 

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.
 
 #### Examples
 
@@ -287,10 +328,24 @@ 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.
 ```
 
 ### Number
@@ -327,6 +382,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.
 
 #### Examples
 
@@ -340,7 +400,20 @@ 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.
 ```
 
 ### Symbol
@@ -350,15 +423,33 @@ 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.
+
 #### 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"
 ```
 
 ### Boolean
@@ -368,6 +459,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'`
+
 #### Examples
 
 ```ruby
@@ -375,9 +472,20 @@ 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.
 ```
 
 ### Array
@@ -420,7 +528,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 +569,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 +587,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 +649,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 +808,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 +892,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 +916,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 +991,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 +1006,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 +1180,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.5
+3.0.10

data/lib/schemacop/schema3.rb

@@ -14,8 +14,8 @@ module Schemacop
       root.validate(data)
     end
 
-    def as_json(json_format: V3::Context::DEFAULT_JSON_FORMAT)
-      Schemacop.context.spawn_with(json_format: json_format) { root.as_json }
+    def as_json
+      root.as_json
     end
   end
 end

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

data/lib/schemacop/v3/context.rb

@@ -17,7 +17,7 @@ module Schemacop
         ).freeze
       end
 
-      def spawn_with(json_format: @json_format)
+      def with_json_format(json_format)
         prev_json_format = @json_format
         @json_format = json_format
         return yield

data/lib/schemacop/v3/node.rb

@@ -48,7 +48,7 @@ module Schemacop
       end
 
       def self.allowed_options
-        %i[name required default description examples enum parent options cast_str title as]
+        %i[name required default description examples enum parent options title as]
       end
 
       def self.dsl_methods
@@ -161,12 +161,13 @@ module Schemacop
       end
 
       def process_json(attrs, json)
-        if @schemas.any?
+        if !context.swagger_json? && @schemas.any?
           json[:definitions] = {}
           @schemas.each do |name, subschema|
             json[:definitions][name] = subschema.as_json
           end
         end
+
         attrs.each do |attr|
           if options.include?(attr)
             json[attr.to_s.camelize(:lower).to_sym] = options[attr]
@@ -205,7 +206,7 @@ module Schemacop
         # Validate type #
         if allowed_types.any? && allowed_types.keys.none? { |c| data.send(type_assertion_method, c) }
           collection = allowed_types.values.map { |t| "\"#{t}\"" }.uniq.sort.join(' or ')
-          result.error %(Invalid type, expected #{collection}.)
+          result.error "Invalid type, got type \"#{data.class}\", expected #{collection}."
           return nil
         end