nxt_schema 0.1.0 → 1.0.2

data/lib/nxt_schema/node/collection.rb

@@ -1,72 +1,56 @@
 module NxtSchema
   module Node
     class Collection < Node::Base
-      def initialize(name:, type: NxtSchema::Types::Strict::Array, parent_node:, **options, &block)
-        @template_store = TemplateStore.new
-        super
-      end
-
-      def apply(input, parent_node: self.parent_node, context: nil)
-        self.input = input
-        register_node(context)
-
-        self.parent_node = parent_node
-        self.schema_errors = { schema_errors_key => [] }
-        self.validation_errors = { schema_errors_key => [] }
-        self.value_store = []
-        self.value = input
-
-        if maybe_criteria_applies?(value)
-          self.value_store = value
-        else
-          self.value = value_or_default_value(value)
-
-          unless maybe_criteria_applies?(value)
-            self.value = coerce_value(value)
+      def call
+        apply_on_evaluators
+        child_nodes # build nodes here so we can access them even when invalid
+        return self if maybe_evaluator_applies?
+
+        coerce_input
+        validate_filled
+        return self unless valid?
+
+        child_nodes.each_with_index do |item, index|
+          child_node = item.call
+
+          if !child_node.valid?
+            merge_errors(child_node)
+          else
+            output[index] = child_node.output
+          end
+        end
 
-            current_node_store = {}
+        register_as_coerced_when_no_errors
+        run_validations
 
-            value.each_with_index do |item, index|
-              item_schema_errors = schema_errors[index] ||= { schema_errors_key => [] }
-              validation_errors[index] ||= { schema_errors_key => [] }
+        self
+      end
 
-              template_store.each do |node_name, node|
-                current_node = node.dup
-                current_node_store[node_name] = current_node
-                current_node.apply(item, parent_node: self, context: context)
-                value_store[index] = current_node.value
+      delegate :[], to: :child_nodes
 
-                # TODO: Extract method here
-                unless current_node.schema_errors?
-                  current_node_store.each do |node_name, node|
-                    node.schema_errors = { }
-                    node.validation_errors = { }
-                    item_schema_errors = schema_errors[index][node_name] = node.schema_errors
-                    validation_errors[index][node_name] = node.validation_errors
-                  end
+      private
 
-                  break
-                else
-                  schema_errors[index][node_name] = current_node.schema_errors
-                  validation_errors[index][node_name] = current_node.validation_errors
-                end
-              end
+      def validate_filled
+        add_schema_error('is not allowed to be empty') if input.blank? && !maybe_evaluator_applies?
+      end
 
-              item_schema_errors.reject! { |_, v| v.empty? }
-            end
+      def child_nodes
+        @child_nodes ||= begin
+          return [] unless input.respond_to?(:each_with_index)
 
-            # Once we collected all values ensure type by casting again
-            self.value_store = coerce_value(value_store)
-            self.value = value_store
+          input.each_with_index.map do |item, index|
+            build_child_node(item, index)
           end
         end
 
-        self_without_empty_schema_errors
-      rescue Dry::Types::ConstraintError, Dry::Types::CoercionError => error
-        add_schema_error(error.message)
-        self_without_empty_schema_errors
-      ensure
-        mark_as_applied
+      end
+
+      def build_child_node(item, error_key)
+        sub_node.build_node(input: item, context: context, parent: self, error_key: error_key)
+      end
+
+      def sub_node
+        @sub_node ||= node.sub_nodes.values.first
       end
     end
   end

data/lib/nxt_schema/node/error_store.rb

@@ -0,0 +1,41 @@
+module NxtSchema
+  module Node
+    class ErrorStore < ::Hash
+      def initialize(node)
+        super()
+        @node = node
+      end
+
+      attr_reader :node
+
+      def add_schema_error(message:)
+        add_error(
+          node,
+          NxtSchema::Node::Errors::SchemaError.new(
+            node: node,
+            message: message
+          )
+        )
+      end
+
+      def add_validation_error(message:)
+        add_error(
+          node,
+          NxtSchema::Node::Errors::ValidationError.new(
+            node: node,
+            message: message
+          )
+        )
+      end
+
+      def merge_errors(node)
+        merge!(node.errors)
+      end
+
+      def add_error(node, error)
+        self[node.error_key] ||= []
+        self[node.error_key] << error
+      end
+    end
+  end
+end

data/lib/nxt_schema/node/errors/schema_error.rb

@@ -0,0 +1,15 @@
+module NxtSchema
+  module Node
+    module Errors
+      class SchemaError < ::String
+        def initialize(node:, message:)
+          super(message)
+          @node = node
+        end
+
+        attr_reader :node
+      end
+    end
+  end
+end
+

data/lib/nxt_schema/node/errors/validation_error.rb

@@ -0,0 +1,15 @@
+module NxtSchema
+  module Node
+    module Errors
+      class ValidationError < ::String
+        def initialize(node:, message:)
+          super(message)
+          @node = node
+        end
+
+        attr_reader :node
+      end
+    end
+  end
+end
+

data/lib/nxt_schema/node/leaf.rb

@@ -1,42 +1,14 @@
 module NxtSchema
   module Node
     class Leaf < Node::Base
-      def initialize(name:, type:, parent_node:, **options, &block)
-        super
-        @type = resolve_type(type)
-      end
-
-      def leaf?
-        true
-      end
-
-      def apply(input, parent_node: self.parent_node, context: nil)
-        self.input = input
-        register_node(context)
-
-        self.parent_node = parent_node
-        self.schema_errors = { schema_errors_key => [] }
-        self.validation_errors = { schema_errors_key => [] }
-
-        if maybe_criteria_applies?(input)
-          self.value = input
-        else
-          self.value = value_or_default_value(input)
-          self.value = coerce_value(value) unless maybe_criteria_applies?(value)
-        end
-
-        self_without_empty_schema_errors
-      rescue Dry::Types::ConstraintError, Dry::Types::CoercionError => error
-        add_schema_error(error.message)
-        self_without_empty_schema_errors
-      ensure
-        mark_as_applied
-      end
-
-      private
-
-      def resolve_type(name_or_type)
-        root.send(:type_resolver).resolve(type_system, name_or_type)
+      def call
+        apply_on_evaluators
+        return self if maybe_evaluator_applies?
+
+        coerce_input
+        register_as_coerced_when_no_errors
+        run_validations
+        self
       end
     end
   end

data/lib/nxt_schema/node/schema.rb

@@ -1,146 +1,113 @@
 module NxtSchema
   module Node
     class Schema < Node::Base
-      def initialize(name:, type: NxtSchema::Types::Strict::Hash, parent_node:, **options, &block)
-        @template_store = TemplateStore.new
-        super
-      end
-
-      def apply(input, parent_node: self.parent_node, context: nil)
-        self.input = input
-        register_node(context)
-
-        self.parent_node = parent_node
-        self.schema_errors = { schema_errors_key => [] }
-        self.validation_errors = { schema_errors_key => [] }
-        self.value_store = {}
-        self.value = transform_keys(input)
-
-        if maybe_criteria_applies?(value)
-          self.value_store = value
-        else
-          self.value = value_or_default_value(value)
-
-          unless maybe_criteria_applies?(value)
-            self.value = coerce_value(value)
-
-            # TODO: We should not allow additional keys to be present per default?!
-            # TODO: Handle this here
+      def call
+        apply_on_evaluators
+        child_nodes # build nodes here so we can access them even when invalid
+        return self if maybe_evaluator_applies?
 
+        coerce_input
+        return self unless valid?
 
+        flag_missing_keys
+        apply_additional_keys_strategy
 
-            sanitized_keys.each do |key|
-              node = template_store[key]
+        child_nodes.each do |key, child|
+          current_node = child.call
 
-              if allowed_additional_key?(key)
-                value_store[key] = input[key]
-              elsif node.presence? || input.key?(key)
-                node.apply(input[key], parent_node: self, context: context).schema_errors?
-                value_store[key] = node.value
-                schema_errors[key] = node.schema_errors
-                validation_errors[key] = node.validation_errors
-              else
-                evaluate_optional_option(node, input, key)
-              end
-            end
-
-            self.value_store = coerce_value(value_store)
-            self.value = value_store
+          if !current_node.valid?
+            merge_errors(current_node)
+          else
+            output[key] = current_node.output
           end
         end
 
-        self_without_empty_schema_errors
-      rescue Dry::Types::ConstraintError, Dry::Types::CoercionError => error
-        add_schema_error(error.message)
-        self_without_empty_schema_errors
-      ensure
-        mark_as_applied
+        transform_keys
+        register_as_coerced_when_no_errors
+        run_validations
+        self
       end
 
-      def optional(name, type, **options, &block)
-        raise_invalid_options_presence_options if options[:presence]
+      delegate :[], to: :child_nodes
 
-        node(name, type, options.merge(optional: true), &block)
-      end
+      private
 
-      def present(name, type, **options, &block)
-        raise_invalid_options_presence_options if options[:optional]
+      def transform_keys
+        transformer = node.key_transformer
+        return unless transformer && output.respond_to?(:transform_keys!)
 
-        node(name, type, options.merge(presence: true), &block)
+        output.transform_keys!(&transformer)
       end
 
-      private
+      def keys
+        @keys ||= node.sub_nodes.reject { |key, _| optional_and_not_given_key?(key) }.keys
+      end
 
-      def evaluate_optional_option(node, hash, key)
-        optional_option = node.options[:optional]
-
-        if optional_option.respond_to?(:call)
-          # Validator is added to the schema node!
-          add_validators(validator(:optional_node, optional_option, key))
-        elsif !optional_option
-          error_message = ErrorMessages.resolve(
-            locale,
-            :required_key_missing,
-            key: key,
-            target: hash
-          )
-
-          add_schema_error(error_message)
-        end
+      def additional_keys
+        @additional_keys ||= input.keys - keys
       end
 
-      def transform_keys(hash)
-        return hash unless key_transformer && hash.respond_to?(:transform_keys!)
+      def optional_and_not_given_key?(key)
+        node.sub_nodes[key].optional? && !input.key?(key)
+      end
 
-        hash.transform_keys! { |key| Callable.new(key_transformer).bind(key).call(key) }
+      def additional_keys?
+        additional_keys.any?
       end
 
-      def key_transformer
-        @key_transformer ||= root.options.fetch(:transform_keys) { false }
+      def missing_keys
+        @missing_keys ||= node.sub_nodes.reject { |_, node| node.omnipresent? || node.optional? }.keys - input.keys
       end
 
-      def sanitized_keys
-        return template_store.keys if additional_keys_from_input.empty? || ignore_additional_keys?
-        return template_store.keys + additional_keys_from_input if additional_keys_allowed?
+      def apply_additional_keys_strategy
+        return if allow_additional_keys?
+        return unless additional_keys?
 
         if restrict_additional_keys?
-          error_message = ErrorMessages.resolve(
-            locale,
-            :additional_keys_detected,
-            keys: additional_keys_from_input,
-            target: input
-          )
-
-          add_schema_error(error_message)
-
-          template_store.keys
-        else
-          raise Errors::InvalidOptionsError, "Invalid option for additional keys: #{additional_keys_strategy}"
+          add_schema_error("Additional keys are not allowed: #{additional_keys}")
+        elsif reject_additional_keys?
+          self.output = output.except(*additional_keys)
         end
       end
 
-      def allowed_additional_key?(key)
-        additional_keys_from_input.include?(key)
-      end
+      def flag_missing_keys
+        return if missing_keys.empty?
 
-      def additional_keys_from_input
-        (input&.keys || [])  - template_store.keys
+        add_schema_error("The following keys are missing: #{missing_keys}")
       end
 
-      def additional_keys_allowed?
-        additional_keys_strategy.to_s == 'allow'
+      def allow_additional_keys?
+        node.additional_keys_strategy == :allow
       end
 
-      def ignore_additional_keys?
-        additional_keys_strategy.to_s == 'ignore'
+      def reject_additional_keys?
+        node.additional_keys_strategy == :reject
       end
 
       def restrict_additional_keys?
-        additional_keys_strategy.to_s == 'restrict'
+        node.additional_keys_strategy == :restrict
+      end
+
+      def child_nodes
+        @child_nodes ||= begin
+          keys.inject({}) do |acc, key|
+            child_node = build_child_node(key)
+            acc[key] = child_node if child_node.present?
+            acc
+          end
+        end
+      end
+
+      def build_child_node(key)
+        sub_node = node.sub_nodes[key]
+        return unless sub_node.present?
+
+        value = input_has_key?(input, key) ? input[key] : Undefined.new
+        sub_node.build_node(input: value, context: context, parent: self)
       end
 
-      def raise_invalid_options_presence_options
-        raise InvalidOptionsError, 'Options :presence and :optional exclude each other'
+      def input_has_key?(input, key)
+        input.respond_to?(:key?) && input.key?(key)
       end
     end
   end