definition 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 6b8b872d14fc97965062a65fcc1d75987cfd7b21c448fe4f61dfda1f11fd003b
-  data.tar.gz: 3195829dcc11b18abe5fa12826cefb2d16f70ce8d2bb127f715dc4ee6193b181
+SHA1:
+  metadata.gz: 2e17d7407705fa6a48ed0a3852b73abe91688fbe
+  data.tar.gz: 118a8ad2dc4663c8666a25b68614f89f8546ab16
 SHA512:
-  metadata.gz: 4861a2c4f8ee02c9706546b24dbf9040edc02e6ba8d05f6038529f7132d72d35403de1e079d46d40bb5b00e1d5e65fa2be93781cff4e920da58f5e835f84f242
-  data.tar.gz: 53c7365d464f2fed498ebb405dac60bffd5d960dd643485ff571c06c3bb76ca593bd7a2758295011e27f1c35cc38c7da687935f280fad03704791d5b412387ed
+  metadata.gz: fe00bb7ab22dbc910ab68df1e054e5d15618d3e02d91a266c2f1fb07c48a4d95553c0071fbe3f5e3274d446d833491efd1753cca8d6ef625c25aa17747c129c6
+  data.tar.gz: 5cee41aff7c8c40cb54c533f6424046152fdcdfd9a971e17fc11209ec833b21e3834d77158c200430678d9683e9fcdc510aac0527838276fc502a74ab91b5451

data/Changelog.md

@@ -4,6 +4,17 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.5.0] - 2019-03-28
+### Added
+- CoercibleValueObject Definition for better nesting of ValueObjects
+- Nilable Definition as shortcut for nil OR some other definition
+- Option for Keys Definition to ignore unexpected keys
+### Fixed
+- Error hash was missing some errors in a few cases
+- `ConformResult.error_hash` was empty for Definitions without any `Keys` Definition
+### Changed
+- And Definition stops processing after the first failure
+
 ## [0.4.0] - 2019-03-22
 ### Added
 - Added support for default values to Keys Definition

data/README.md

@@ -111,6 +111,28 @@ IntegerArray.new([1,2,"3"]) # => Definition::InvalidValueObjectError: Not all it
 
 You can access the conform result object via `InvalidValueObjectError#conform_result`
 
+#### Nesting value Objects
+
+Value objects can be nested by either using the value object itself as type definition,
+or by using the `CoercibleValueObject` Definition. The latter would convert input
+hashes that conform with the value objects schema to an instance of the value object.
+
+```ruby
+class IntegerArray < Definition::ValueObject
+  definition(Definition.Each(Definition.Type(Integer)))
+end
+
+class User < Definition::ValueObject
+  definition(Definition.Keys do
+    required :username, Definition.Type(String)
+    required :scores, Definition.CoercibleValueObject(IntegerArray)
+  end)
+end
+
+object = User.new(username: "John", scores: [1,2,3])
+object.scores.class.name # => IntegerArray
+```
+
 ### Conforming Hashes
 
 Hashes can be conformed by using the `Keys` definition. It allows you to configure
@@ -130,6 +152,25 @@ Definition.Keys do
 end
 ```
 
+#### Ignoring unexpected keys
+
+By default the `Keys` Definition does not conform with input hashes that contains
+keys that are not defined in the Definition. You can set the `:ignore_extra_keys`
+option to disable this.
+
+```ruby
+schema = Definition.Keys do
+  option :ignore_extra_keys
+
+  required :title, Definition.NonEmptyString
+  optional :publication_date, Definition.Type(Time)
+end
+
+conform_result = schema.conform({title: "My first blog post", body: "Shortest one ever!", publication_date: Time.new})
+conform_result.passed? # => true
+conform_result.value # => {title: "My first blog post", publication_date: 2018-12-30 11:43:00 UTC}
+```
+
 ### Validating types
 
 This will validate that the value is of the specified type.
@@ -159,17 +200,17 @@ Definition.CoercibleType(Float).conform("0.1").value # => 0.1
 ### Combining multiple definitions with "And"
 
 ```ruby
-Definition.And(definition1, definition2)
+Definition.And(definition1, definition2, ...)
 ```
 
 This definition will only conform if all definitions conform. The definitions will
 be processed from left to right and the output of the previous will be the input
-of the next.
+of the next. Processing of the And-Definition stops as soon as one definition does not conform.
 
 ### Combining multiple definitions with "Or"
 
 ```ruby
-Definition.Or(definition1, definition2)
+Definition.Or(definition1, definition2, ...)
 ```
 
 This definition will conform if at least one definition conforms. The definitions will
@@ -291,11 +332,20 @@ Definition.NonEmpty.conform({ a: 1 }) # => pass
 Definition.Nil.conform(nil) # => pass
 ```
 
+#### Boolean
+
+```ruby
+Definition.Boolean.conform(tru) # => pass
+```
+
 #### All types
 
 ```ruby
 Definition.Equal(5).conform(5) # => pass
 Definition.Equal("foo").conform("foo") # => pass
+
+Definition.Nilable(Definition.Type(String)).conform(nil) # => pass
+Definition.Nilable(Definition.Type(String)).conform("foo") # => pass
 ```
 
 ### Examples

data/lib/definition/conform_result.rb

@@ -33,14 +33,14 @@ module Definition
     def error_hash
       {}.tap do |error_hash|
         errors.each do |error|
-          next if error.error_path.empty?
+          path_hash = if error.error_path.empty?
+                        { "" => error }
+                      else
+                        error.error_path.reverse
+                             .inject([error]) { |errors, key| { key => errors } }
+                      end
 
-          path_hash = error.error_path.reverse
-                           .inject([error]) { |errors, key| { key => errors } }
-
-          error_hash.deep_merge!(path_hash) do |_key, old, new|
-            old + new if old.is_a?(Array) && new.is_a?(Array) # concat arrays during deep_merge
-          end
+          merge_error_hash(error_hash, path_hash)
         end
       end
     end
@@ -51,6 +51,16 @@ module Definition
 
     private
 
+    def merge_error_hash(hash, new_hash)
+      hash.deep_merge!(new_hash) do |_key, old, new|
+        if old.is_a?(Array) && new.is_a?(Hash) # Dont replace Hashes with arrays
+          new
+        elsif old.is_a?(Array) && new.is_a?(Array) # concat arrays during deep_merge
+          old + new
+        end
+      end
+    end
+
     def find_next_parent_key_error(error)
       current = error
       loop do

data/lib/definition/dsl.rb

@@ -76,5 +76,24 @@ module Definition
     def Boolean # rubocop:disable Style/MethodName
       Types::Or.new(:boolean, Type(TrueClass), Type(FalseClass))
     end
+
+    # Example:
+    # CoercibleValueObject(ValueObjectClass)
+    def CoercibleValueObject(klass) # rubocop:disable Style/MethodName
+      Types::Or.new(:coercible_value_object,
+                    Definition.Type(klass), # If its of ther correct type already this will let it pass already
+                    And(
+                      klass, # First make sure that the input could be coerced to 'klass'
+                      Lambda("value_object_coercion", context: { value_object_class: klass }) do |value|
+                        conform_with(klass.new(value)) # Actually coerce the input to klass
+                      end
+                    ))
+    end
+
+    # Example:
+    # Nilable(Definition.Type(Integer))
+    def Nilable(definition) # rubocop:disable Style/MethodName
+      Types::Or.new(:nullable, Nil(), definition)
+    end
   end
 end

data/lib/definition/types/and.rb

@@ -51,6 +51,7 @@ module Definition
             result = definition.conform(value)
             value = result.value
             results << result
+            break unless result.passed?
           end
           results
         end

data/lib/definition/types/keys.rb

@@ -22,16 +22,26 @@ module Definition
         def default(key, value)
           defaults[key] = value
         end
+
+        def option(option_name)
+          case option_name
+          when :ignore_extra_keys
+            self.ignore_extra_keys = true
+          else
+            raise "Option #{option_name} is not defined"
+          end
+        end
       end
 
       include Dsl
-      attr_accessor :required_definitions, :optional_definitions, :defaults
+      attr_accessor :required_definitions, :optional_definitions, :defaults, :ignore_extra_keys
 
-      def initialize(name, req: {}, opt: {}, defaults: {})
+      def initialize(name, req: {}, opt: {}, defaults: {}, options: {})
         super(name)
         self.required_definitions = req
         self.optional_definitions = opt
         self.defaults = defaults
+        self.ignore_extra_keys = options.fetch(:ignore_extra_keys, false)
       end
 
       def conform(value)
@@ -50,7 +60,7 @@ module Definition
         end
 
         def conform
-          add_extra_key_errors
+          add_extra_key_errors unless definition.ignore_extra_keys
           add_missing_key_errors
           values = conform_all_keys
 

data/lib/definition/types/type.rb

@@ -6,6 +6,8 @@ module Definition
   module Types
     class Type < Base
       def initialize(name, klass, &coerce)
+        raise "#{klass.inspect} is not a class" unless klass.is_a?(Class)
+
         self.klass = klass
         self.coerce = coerce
         super(name, context: { class: klass })

data/lib/definition/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Definition
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: definition
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Dominik Goltermann
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-03-22 00:00:00.000000000 Z
+date: 2019-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -299,7 +299,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Simple and composable validation and coercion of data structures inspired