definition 0.7.0 → 0.8.0

data/lib/definition/dsl/comparators.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
+require "definition/v1_deprecator"
+
 module Definition
   module Dsl
     module Comparators
       # Example:
       # MaxSize(5)
-      def MaxSize(max_size) # rubocop:disable Style/MethodName
+      def MaxSize(max_size) # rubocop:disable Naming/MethodName
         Types::Lambda.new(:max_size, context: { max_size: max_size }) do |value|
           case value
           when String, Enumerable
@@ -18,7 +20,7 @@ module Definition
 
       # Example:
       # MinSize(5)
-      def MinSize(min_size) # rubocop:disable Style/MethodName
+      def MinSize(min_size) # rubocop:disable Naming/MethodName
         Types::Lambda.new(:min_size, context: { min_size: min_size }) do |value|
           case value
           when String, Enumerable
@@ -31,45 +33,53 @@ module Definition
 
       # Example:
       # NonEmptyString
-      def NonEmptyString # rubocop:disable Style/MethodName
+      def NonEmptyString # rubocop:disable Naming/MethodName
         Types::And.new(:non_empty_string, Type(String), MinSize(1))
       end
 
       # Example:
-      # GreaterThen(5)
-      def GreaterThen(min_value) # rubocop:disable Style/MethodName
-        Types::Lambda.new("greater_then", context: { min_value: min_value }) do |value|
+      # GreaterThan(5)
+      def GreaterThan(min_value) # rubocop:disable Naming/MethodName
+        Types::Lambda.new("greater_than", context: { min_value: min_value }) do |value|
           conform_with(value) if value.is_a?(Numeric) && value > min_value
         end
       end
+      alias GreaterThen GreaterThan
+      deprecate :GreaterThen, deprecator: V1Deprecator
 
       # Example:
-      # GreaterThenEqual(5)
-      def GreaterThenEqual(min_value) # rubocop:disable Style/MethodName
-        Types::Lambda.new("greater_then_equal", context: { min_value: min_value }) do |value|
+      # GreaterThanEqual(5)
+      def GreaterThanEqual(min_value) # rubocop:disable Naming/MethodName
+        Types::Lambda.new("greater_than_equal", context: { min_value: min_value }) do |value|
           conform_with(value) if value.is_a?(Numeric) && value >= min_value
         end
       end
+      alias GreaterThenEqual GreaterThanEqual
+      deprecate :GreaterThenEqual, deprecator: V1Deprecator
 
       # Example:
-      # LessThen(5)
-      def LessThen(max_value) # rubocop:disable Style/MethodName
-        Types::Lambda.new("less_then", context: { max_value: max_value }) do |value|
+      # LessThan(5)
+      def LessThan(max_value) # rubocop:disable Naming/MethodName
+        Types::Lambda.new("less_than", context: { max_value: max_value }) do |value|
           conform_with(value) if value.is_a?(Numeric) && value < max_value
         end
       end
+      alias LessThen LessThan
+      deprecate :LessThen, deprecator: V1Deprecator
 
       # Example:
-      # LessThenEqual(5)
-      def LessThenEqual(max_value) # rubocop:disable Style/MethodName
-        Types::Lambda.new("less_then_equal", context: { max_value: max_value }) do |value|
+      # LessThanEqual(5)
+      def LessThanEqual(max_value) # rubocop:disable Naming/MethodName
+        Types::Lambda.new("less_than_equal", context: { max_value: max_value }) do |value|
           conform_with(value) if value.is_a?(Numeric) && value <= max_value
         end
       end
+      alias LessThenEqual LessThanEqual
+      deprecate :LessThenEqual, deprecator: V1Deprecator
 
       # Example:
       # Equal("value")
-      def Equal(expected_value) # rubocop:disable Style/MethodName
+      def Equal(expected_value) # rubocop:disable Naming/MethodName
         Types::Lambda.new(:equal, context: { expected_value: expected_value }) do |value|
           conform_with(value) if value == expected_value
         end
@@ -77,7 +87,7 @@ module Definition
 
       # Example:
       # Empty
-      def Empty # rubocop:disable Style/MethodName
+      def Empty # rubocop:disable Naming/MethodName
         Types::Lambda.new(:empty) do |value|
           case value
           when String, Array, Hash
@@ -90,7 +100,7 @@ module Definition
 
       # Example:
       # NonEmpty
-      def NonEmpty # rubocop:disable Style/MethodName
+      def NonEmpty # rubocop:disable Naming/MethodName
         Types::Lambda.new(:non_empty) do |value|
           case value
           when String, Array, Hash
@@ -103,7 +113,7 @@ module Definition
 
       # Example:
       # Regex
-      def Regex(regex, name: :regex) # rubocop:disable Style/MethodName
+      def Regex(regex, name: :regex) # rubocop:disable Naming/MethodName
         Types::Lambda.new(name, context: { regex: regex.inspect }) do |value|
           case value
           when String

data/lib/definition/dsl/nil.rb

@@ -5,7 +5,7 @@ module Definition
     module Nil
       # Example:
       # Nil
-      def Nil # rubocop:disable Style/MethodName
+      def Nil # rubocop:disable Naming/MethodName
         Types::Lambda.new(:nil) do |value|
           conform_with(value) if value.nil?
         end

data/lib/definition/dsl.rb

@@ -9,33 +9,33 @@ module Definition
     #   required :name, Types::Type(String)
     #   optional :age, Types::Type(Integer)
     # end
-    def Keys(&block) # rubocop:disable Style/MethodName
+    def Keys(&block) # rubocop:disable Naming/MethodName
       Types::Keys.new(:hash).tap do |instance|
         instance.instance_exec(&block)
       end
     end
 
     # Example:
-    # And(Types::Type(Float), Types::GreaterThen(10.0))
-    def And(*definitions) # rubocop:disable Style/MethodName
+    # And(Types::Type(Float), Types::GreaterThan(10.0))
+    def And(*definitions) # rubocop:disable Naming/MethodName
       Types::And.new(:and, *definitions)
     end
 
     # Example:
     # Or(Types::Type(Float), Types::Type(Integer))
-    def Or(*definitions) # rubocop:disable Style/MethodName
+    def Or(*definitions) # rubocop:disable Naming/MethodName
       Types::Or.new(:or, *definitions)
     end
 
     # Example:
     # Type(Integer)
-    def Type(klass) # rubocop:disable Style/MethodName
+    def Type(klass) # rubocop:disable Naming/MethodName
       Types::Type.new(:type, klass)
     end
 
     # Example:
     # CoercibleType(Integer)
-    def CoercibleType(klass) # rubocop:disable Style/MethodName
+    def CoercibleType(klass) # rubocop:disable Naming/MethodName
       unless Kernel.respond_to?(klass.name)
         raise ArgumentError.new("#{klass} can't be used as CoercibleType because its not "\
                                 "a primitive that has a coercion function defined")
@@ -51,13 +51,13 @@ module Definition
     # Lambda(:even) do |value|
     #   value.even?
     # end
-    def Lambda(name, context: {}, &block) # rubocop:disable Style/MethodName
+    def Lambda(name, context: {}, &block) # rubocop:disable Naming/MethodName
       Types::Lambda.new(name, context: context, &block)
     end
 
     # Example:
     # Enum("allowed_value1", "allowed_value2")
-    def Enum(*allowed_values) # rubocop:disable Style/MethodName
+    def Enum(*allowed_values) # rubocop:disable Naming/MethodName
       Lambda("enum", context: { allowed_values: allowed_values }) do |value|
         conform_with(value) if allowed_values.include?(value)
       end
@@ -65,24 +65,24 @@ module Definition
 
     # Example:
     # Each(Definition::Type(Integer))
-    def Each(definition) # rubocop:disable Style/MethodName
+    def Each(definition) # rubocop:disable Naming/MethodName
       Types::Each.new(:each, definition: definition)
     end
 
     # Example:
     # Boolean
-    def Boolean # rubocop:disable Style/MethodName
+    def Boolean # rubocop:disable Naming/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,
+    # CoercibleModel(ModelClass)
+    def CoercibleModel(klass) # rubocop:disable Naming/MethodName
+      Types::Or.new(:coercible_model,
                     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|
+                      Lambda("value_object_coercion", context: { model_class: klass }) do |value|
                         conform_with(klass.new(value)) # Actually coerce the input to klass
                       end
                     ))
@@ -90,7 +90,7 @@ module Definition
 
     # Example:
     # Nilable(Definition.Type(Integer))
-    def Nilable(definition) # rubocop:disable Style/MethodName
+    def Nilable(definition) # rubocop:disable Naming/MethodName
       Types::Or.new(:nilable, Nil(), definition)
     end
   end

data/lib/definition/initializer.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Definition
+  module Initializer
+    class InvalidArgumentError < ArgumentError
+      attr_accessor :conform_result
+
+      def initialize(conform_result)
+        super("Arguments passed into the initializer are invalid: #{conform_result.error_message}")
+        self.conform_result = conform_result
+      end
+    end
+
+    module ClassMethods
+      def required(name, *args)
+        _keys_definition.required(name, *args)
+        _define_attr_accessor(name)
+      end
+
+      def optional(name, *args, **kwargs)
+        _keys_definition.optional(name, *args, **kwargs)
+        _define_attr_accessor(name)
+      end
+
+      def _keys_definition
+        @_keys_definition ||= Definition.Keys {}
+      end
+
+      def _define_attr_accessor(key)
+        define_method(key) do
+          @_attributes.fetch(key, nil)
+        end
+        define_method("#{key}=") do |value|
+          @_attributes[key] = value
+        end
+        protected key
+        protected "#{key}="
+      end
+    end
+
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+
+    def initialize(**kwargs)
+      result = self.class._keys_definition.conform(kwargs)
+      raise InvalidArgumentError.new(result) unless result.passed?
+
+      @_attributes = result.value
+    end
+  end
+end

data/lib/definition/model.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Definition
+  class InvalidModelError < StandardError
+    attr_accessor :conform_result
+
+    def initialize(conform_result)
+      super(conform_result.error_message)
+      self.conform_result = conform_result
+    end
+  end
+
+  class Model
+    class << self
+      def conform(value)
+        _definition.conform(value)
+      end
+
+      def required(key, definition)
+        _define_attr_accessor(key)
+        _definition.required(key, definition)
+      end
+
+      def optional(key, definition, **opts)
+        _define_attr_accessor(key)
+        _definition.optional(key, definition, **opts)
+      end
+
+      def option(option_name)
+        _definition.option(option_name)
+      end
+
+      def _define_attr_accessor(key)
+        define_method(key) do
+          @_attributes.fetch(key, nil)
+        end
+      end
+
+      def _definition
+        @_definition ||= ::Definition.Keys {}
+      end
+    end
+
+    def initialize(hash = nil, **kwargs)
+      result = self.class.conform(hash || kwargs)
+      raise InvalidModelError.new(result) unless result.passed?
+
+      @_attributes = result.value.freeze
+    end
+
+    def new(**kwargs)
+      self.class.new(**to_h.merge!(kwargs))
+    end
+
+    def ==(other)
+      return false unless other.is_a?(self.class)
+
+      @_attributes == other.instance_variable_get(:@_attributes)
+    end
+
+    def to_h
+      _deep_transform_values_in_object(@_attributes) do |value|
+        value.is_a?(::Definition::Model) ? value.to_h : value
+      end
+    end
+
+    private
+
+    def _deep_transform_values_in_object(object, &block)
+      case object
+      when Hash
+        object.transform_values { |value| _deep_transform_values_in_object(value, &block) }
+      when Array
+        object.map { |e| _deep_transform_values_in_object(e, &block) }
+      else
+        yield(object)
+      end
+    end
+  end
+end

data/lib/definition/types/keys.rb

@@ -9,11 +9,11 @@ module Definition
     class Keys < Base
       module Dsl
         def required(key, definition)
-          required_definitions[key] = definition
+          required_definitions << { key: key, definition: definition }
         end
 
         def optional(key, definition, **opts)
-          optional_definitions[key] = definition
+          optional_definitions << { key: key, definition: definition }
           default(key, opts[:default]) if opts.key?(:default)
         end
 
@@ -30,15 +30,10 @@ module Definition
           raise ArgumentError.new("Included Definition can only be a Keys Definition") unless other.is_a?(Types::Keys)
 
           ensure_keys_do_not_interfere(other)
-          other.required_definitions.each do |key, definition|
-            required(key, definition)
-          end
-          other.optional_definitions.each do |key, definition|
-            optional(key, definition)
-          end
-          other.defaults.each do |key, default|
-            default(key, default)
-          end
+
+          self.required_definitions += other.required_definitions
+          self.optional_definitions += other.optional_definitions
+          defaults.merge!(other.defaults)
         end
 
         private
@@ -62,8 +57,8 @@ module Definition
 
       def initialize(name, req: {}, opt: {}, defaults: {}, options: {})
         super(name)
-        self.required_definitions = req
-        self.optional_definitions = opt
+        self.required_definitions = req.map { |key, definition| { key: key, definition: definition } }
+        self.optional_definitions = opt.map { |key, definition| { key: key, definition: definition } }
         self.defaults = defaults
         self.ignore_extra_keys = options.fetch(:ignore_extra_keys, false)
       end
@@ -73,7 +68,7 @@ module Definition
       end
 
       def keys
-        required_definitions.keys + optional_definitions.keys
+        (required_definitions + optional_definitions).map { |hash| hash[:key] }
       end
 
       class Conformer
@@ -81,18 +76,15 @@ module Definition
           self.definition = definition
           self.value = value
           self.errors = []
+          @conform_result_value = {} # This will be the output value after conforming
+          @not_conformed_value_keys = value.dup # Used to track which keys are left over in the end (unexpected keys)
         end
 
         def conform
-          if valid_input_type?
-            add_extra_key_errors unless definition.ignore_extra_keys
-            add_missing_key_errors
-            values = conform_all_keys
-          else
-            errors.push(ConformError.new(definition,
-                                         "#{definition.name} is not a Hash",
-                                         i18n_key: "keys.not_a_hash"))
-          end
+          return invalid_input_result unless valid_input_type?
+
+          values = conform_all_keys
+          add_extra_key_errors unless definition.ignore_extra_keys
 
           ConformResult.new(values, errors: errors)
         end
@@ -101,12 +93,19 @@ module Definition
 
         attr_accessor :errors
 
+        def invalid_input_result
+          errors = [ConformError.new(definition,
+                                     "#{definition.name} is not a Hash",
+                                     i18n_key: "keys.not_a_hash")]
+          ConformResult.new(value, errors: errors)
+        end
+
         def valid_input_type?
           value.is_a?(Hash)
         end
 
         def add_extra_key_errors
-          extra_keys = value.keys - all_keys
+          extra_keys = @not_conformed_value_keys.keys
           return if extra_keys.empty?
 
           extra_keys.each do |key|
@@ -120,59 +119,42 @@ module Definition
         end
 
         def conform_all_keys
-          required_keys_values = conform_definitions(required_definitions)
-          optional_keys_values = conform_definitions(optional_definitions)
+          conform_definitions(definition.required_definitions, required: true)
+          conform_definitions(definition.optional_definitions, required: false)
 
-          definition.defaults.merge(required_keys_values.merge!(optional_keys_values))
+          @conform_result_value
         end
 
-        def all_keys
-          required_keys + optional_keys
-        end
-
-        def required_definitions
-          definition.required_definitions
-        end
-
-        def required_keys
-          required_definitions.keys
-        end
-
-        def optional_definitions
-          definition.optional_definitions
-        end
-
-        def optional_keys
-          optional_definitions.keys
+        def conform_definitions(keys, required:)
+          keys.each do |hash|
+            key = hash[:key]
+            key_definition = hash[:definition]
+            conform_definition(key, key_definition, required: required)
+          end
         end
 
-        def conform_definitions(keys)
-          keys.each_with_object({}) do |(key, key_definition), result_value|
-            next unless value.key?(key)
+        # Rubcop rules are disabled for performance optimization purposes
+        def conform_definition(key, key_definition, required:) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+          @not_conformed_value_keys.delete(key) # Keys left over in that hash at the end are considered unexpected
 
-            result = key_definition.conform(value[key])
-            result_value[key] = result.value
-            next if result.passed?
-
-            errors.push(KeyConformError.new(key_definition,
-                                            "#{definition.name} fails validation for key #{key}",
-                                            key:        key,
-                                            sub_errors: result.error_tree))
+          # If the input value is missing a key:
+          # a) add a missing key error if it is a required key
+          # b) otherwise initialize the missing key in the output value if a default value is configured
+          unless value.key?(key)
+            errors.push(missing_key_error(key)) if required
+            @conform_result_value[key] = definition.defaults[key] if definition.defaults.key?(key)
+            return
           end
-        end
 
-        def add_missing_key_errors
-          required_definition = Types::Include.new(
-            definition.name,
-            *required_keys
-          )
-
-          result = required_definition.conform(value)
+          # If the input value has a key then its value is conformed against the configured definition
+          result = key_definition.conform(value[key])
+          @conform_result_value[key] = result.value
           return if result.passed?
 
-          result.errors.each do |error|
-            errors.push(missing_key_error(error.key))
-          end
+          errors.push(KeyConformError.new(key_definition,
+                                          "#{definition.name} fails validation for key #{key}",
+                                          key:        key,
+                                          sub_errors: result.error_tree))
         end
 
         def missing_key_error(key)

data/lib/definition/types/lambda.rb

@@ -52,10 +52,16 @@ module Definition
           "Did not pass test for #{definition.name}"
         end
 
+        def contextual_error_message
+          return standard_error_message if definition.context.empty?
+
+          "#{standard_error_message} (#{definition.context.values.join(',')})"
+        end
+
         def failure_result_with(value, error_message)
           ConformResult.new(value, errors: [
                               ConformError.new(definition,
-                                               standard_error_message,
+                                               contextual_error_message,
                                                translated_message: error_message)
                             ])
         end

data/lib/definition/types/type.rb

@@ -14,7 +14,7 @@ module Definition
       end
 
       def conform(value)
-        value = coerce.call(value) if coerce && !valid?(value)
+        value = coerce.call(value) if value && coerce && !valid?(value)
 
         try_conform(value)
       end

data/lib/definition/v1_deprecator.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "active_support/deprecation"
+
+module Definition
+  V1Deprecator = ActiveSupport::Deprecation.new("1.0", "Definition")
+end

data/lib/definition/version.rb

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

data/lib/definition.rb

@@ -5,6 +5,8 @@ require "definition/dsl"
 require "definition/dsl/comparators"
 require "definition/dsl/nil"
 require "definition/value_object"
+require "definition/initializer"
+require "definition/model"
 require "definition/i18n"
 
 module Definition

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: definition
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Dominik Goltermann
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-02-25 00:00:00.000000000 Z
+date: 2022-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -255,7 +255,6 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".approvals"
 - ".circleci/config.yml"
 - ".gitignore"
 - ".rspec"
@@ -267,8 +266,11 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- UpgradeNotes.md
 - benchmark/coercion.rb
 - benchmark/complex_example.rb
+- benchmark/initializer.rb
+- benchmark/model.rb
 - benchmark/validation_only.rb
 - bin/console
 - bin/setup
@@ -281,7 +283,9 @@ files:
 - lib/definition/dsl/comparators.rb
 - lib/definition/dsl/nil.rb
 - lib/definition/i18n.rb
+- lib/definition/initializer.rb
 - lib/definition/key_conform_error.rb
+- lib/definition/model.rb
 - lib/definition/types.rb
 - lib/definition/types/and.rb
 - lib/definition/types/base.rb
@@ -294,9 +298,9 @@ files:
 - lib/definition/types/lambda.rb
 - lib/definition/types/or.rb
 - lib/definition/types/type.rb
+- lib/definition/v1_deprecator.rb
 - lib/definition/value_object.rb
 - lib/definition/version.rb
-- tags
 homepage: https://github.com/Goltergaul/definition
 licenses:
 - MIT
@@ -316,7 +320,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Simple and composable validation and coercion of data structures inspired