nxt_schema 1.0.0 → 1.0.1

data/lib/nxt_schema/node/base.rb

@@ -1,217 +1,116 @@
 module NxtSchema
   module Node
     class Base
-      def initialize(name:, type:, parent_node:, **options, &block)
-        resolve_name(name)
-
-        @parent_node = parent_node
-        @options = options
-        @is_root_node = parent_node.nil?
-        @root_node = parent_node.nil? ? self : parent_node.root_node
-        @path = resolve_path
-        @on_evaluators = []
-        @maybe_evaluators = []
-        @validations = []
-        @configuration = block
-
-        resolve_key_transformer
-        resolve_context
-        resolve_optional_option
-        resolve_omnipresent_option
-        resolve_type_system
-        resolve_type(type)
-        resolve_additional_keys_strategy
-        application_class # memoize
-        configure(&block) if block_given?
-      end
+      def initialize(node:, input: MissingInput.new, parent:, context:, error_key:)
+        @node = node
+        @input = input
+        @parent = parent
+        @output = nil
+        @error_key = error_key
+        @context = context || parent&.context
+        @coerced = false
+        @coerced_nodes = parent&.coerced_nodes || []
+        @is_root = parent.nil?
+        @root = parent.nil? ? self : parent.root
+        @errors = ErrorStore.new(self)
+        @locale = node.options.fetch(:locale) { parent&.locale || 'en' }.to_s
 
-      attr_accessor :name,
-                    :parent_node,
-                    :options,
-                    :type,
-                    :root_node,
-                    :additional_keys_strategy
-
-      attr_reader :type_system,
-                  :path,
-                  :context,
-                  :meta,
-                  :on_evaluators,
-                  :maybe_evaluators,
-                  :validations,
-                  :configuration,
-                  :key_transformer
-
-      def apply(input: MissingInput.new, context: self.context, parent: nil, error_key: nil)
-        build_application(input: input, context: context, parent: parent, error_key: error_key).call
+        @index = error_key
+        resolve_error_key(error_key)
       end
 
-      def apply!(input: MissingInput.new, context: self.context, parent: nil, error_key: nil)
-        result = build_application(input: input, context: context, parent: parent, error_key: error_key).call
-        return result if parent || result.errors.empty?
+      attr_accessor :output, :node, :input
+      attr_reader :parent, :context, :error_key, :coerced, :coerced_nodes, :root, :errors, :locale, :index
 
-        raise NxtSchema::Errors::Invalid.new(result)
+      def call
+        raise NotImplementedError, 'Implement this in our sub class'
       end
 
-      def build_application(input: MissingInput.new, context: self.context, parent: nil, error_key: nil)
-        application_class.new(
-          node: self,
-          input: input,
-          parent: parent,
-          context: context,
-          error_key: error_key
-        )
-      end
+      delegate :name, :options, to: :node
 
-      def root_node?
-        @is_root_node
+      def root?
+        @is_root
       end
 
-      def optional?
-        @optional
+      def valid?
+        errors.empty?
       end
 
-      def omnipresent?
-        @omnipresent
+      def add_error(error)
+        errors.add_validation_error(message: error)
       end
 
-      def default(value = NxtSchema::MissingInput.new, &block)
-        value = missing_input?(value) ? block : value
-        condition = ->(input) { missing_input?(input) || input.nil? }
-        on(condition, value)
-
-        self
+      def add_schema_error(error)
+        errors.add_schema_error(message: error)
       end
 
-      def on(condition, value = NxtSchema::MissingInput.new, &block)
-        value = missing_input?(value) ? block : value
-        on_evaluators << OnEvaluator.new(condition: condition, value: value)
-
-        self
+      def merge_errors(application)
+        errors.merge_errors(application)
       end
 
-      def maybe(value = NxtSchema::MissingInput.new, &block)
-        value = missing_input?(value) ? block : value
-        maybe_evaluators << MaybeEvaluator.new(value: value)
+      def run_validations
+        return false unless coerced?
 
-        self
+        node.validations.each do |validation|
+          args = [self, input]
+          validation.call(*args.take(validation.arity))
+        end
       end
 
-      def validate(key = NxtSchema::MissingInput.new, *args, &block)
-        # TODO: This does not really work with all kinds of chaining combinations yet!
-
-        validator = if key.is_a?(Symbol)
-                      validator(key, *args)
-                    elsif key.respond_to?(:call)
-                      key
-                    elsif block_given?
-                      if key.is_a?(NxtSchema::MissingInput)
-                        block
-                      else
-                        configure(&block)
-                      end
-                    else
-                      raise ArgumentError, "Don't know how to resolve validator from: #{key} with: #{args} #{block}"
-                    end
-
-        register_validator(validator)
-
-        self
-      end
+      def up(levels = 1)
+        0.upto(levels - 1).inject(self) do |acc, _|
+          parent = acc.send(:parent)
+          break acc unless parent
 
-      def validate_with(&block)
-        proxy = ->(node) { NxtSchema::Validator::ValidateWithProxy.new(node).validate(&block) }
-        register_validator(proxy)
+          parent
+        end
       end
 
       private
 
-      attr_writer :path, :meta, :context, :on_evaluators, :maybe_evaluators
+      attr_writer :coerced, :root
 
-      def validator(key, *args)
-        Validators::REGISTRY.resolve!(key).new(*args).build
-      end
+      def coerce_input
+        output = input.is_a?(MissingInput) && node.omnipresent? ? input : node.type[input]
+        self.output = output
 
-      def register_validator(validator)
-        validations << validator
+      rescue Dry::Types::CoercionError => error
+        add_schema_error(error.message)
       end
 
-      def resolve_type(name_or_type)
-        @type = root_node.send(:type_resolver).resolve(type_system, name_or_type)
+      def apply_on_evaluators
+        node.on_evaluators.each { |evaluator| evaluator.call(input, self, context) { |result| self.input = result } }
       end
 
-      def resolve_type_system
-        @type_system = TypeSystemResolver.new(node: self).call
-      end
+      def maybe_evaluator_applies?
+        @maybe_evaluator_applies ||= node.maybe_evaluators.inject(false) do |acc, evaluator|
+          result = (acc || evaluator.call(input, self, context))
 
-      def type_resolver
-        @type_resolver ||= begin
-          root_node? ? TypeResolver.new : (raise NoMethodError, 'type_resolver is only available on root node')
+          if result
+            self.output = input
+            break true
+          else
+            false
+          end
         end
       end
 
-      def application_class
-        @application_class ||= "NxtSchema::Application::#{self.class.name.demodulize}".constantize
-      end
+      def register_as_coerced_when_no_errors
+        return unless valid?
 
-      def configure(&block)
-        if block.arity == 1
-          block.call(self)
-        else
-          instance_exec(&block)
-        end
+        self.coerced = true
+        coerced_nodes << self
       end
 
-      def resolve_additional_keys_strategy
-        @additional_keys_strategy = options.fetch(:additional_keys) do
-          parent_node&.send(:additional_keys_strategy) || :allow
-        end
+      def resolve_error_key(key)
+        parts = [parent&.error_key].compact
+        parts << (key.present? ? "#{node.name}[#{key}]" : node.name)
+        @error_key = parts.join('.')
       end
 
-      def resolve_optional_option
-        optional = options.fetch(:optional, false)
-        raise Errors::InvalidOptions, 'Optional nodes are only available within schemas' if optional && !parent_node.is_a?(Schema)
-        raise Errors::InvalidOptions, "Can't make omnipresent node optional" if optional && omnipresent?
-
-        if optional.respond_to?(:call)
-          # When a node is conditionally optional we make it optional and add a validator to the parent to check
-          # that it's there when the option does not apply.
-          optional_node_validator = validator(:optional_node, optional, name)
-          parent_node.send(:register_validator, optional_node_validator)
-          @optional = true
-        else
-          @optional = optional
-        end
-      end
-
-      def resolve_omnipresent_option
-        omnipresent = options.fetch(:omnipresent, false)
-        raise Errors::InvalidOptions, 'Omnipresent nodes are only available within schemas' if omnipresent && !parent_node.is_a?(Schema)
-        raise Errors::InvalidOptions, "Can't make omnipresent node optional" if optional? && omnipresent
-
-        @omnipresent = omnipresent
-      end
-
-      def resolve_path
-        self.path = root_node? ? name : "#{parent_node.path}.#{name}"
-      end
-
-      def resolve_context
-        self.context = options.fetch(:context) { parent_node&.send(:context) }
-      end
-
-      def missing_input?(value)
-        value.is_a? MissingInput
-      end
-
-      def resolve_key_transformer
-        @key_transformer = options.fetch(:transform_keys) { parent_node&.key_transformer || ->(key) { key.to_sym } }
-      end
-
-      def resolve_name(name)
-        raise ArgumentError, 'Name can either be a symbol or an integer' unless name.class.in?([Symbol, Integer])
-
-        @name = name
+      def coerced?(&block)
+        block.call(self) if @coerced && block_given?
+        @coerced
       end
     end
   end

data/lib/nxt_schema/node/collection.rb

@@ -1,21 +1,56 @@
 module NxtSchema
   module Node
     class Collection < Node::Base
-      include HasSubNodes
+      def call
+        apply_on_evaluators
+        child_applications # build applications here so we can access them even when invalid
+        return self if maybe_evaluator_applies?
 
-      DEFAULT_TYPE = NxtSchema::Types::Strict::Array
+        coerce_input
+        validate_filled
+        return self unless valid?
 
-      def initialize(name:, type: DEFAULT_TYPE, parent_node:, **options, &block)
-        super
+        child_applications.each_with_index do |item, index|
+          current_application = item.call
+
+          if !current_application.valid?
+            merge_errors(current_application)
+          else
+            output[index] = current_application.output
+          end
+        end
+
+        register_as_coerced_when_no_errors
+        run_validations
+
+        self
       end
 
+      delegate :[], to: :child_applications
+
       private
 
-      def add_sub_node(node)
-        # TODO: Spec that this raises
-        raise ArgumentError, "It's not possible to define multiple nodes within a collection" unless sub_nodes.empty?
+      def validate_filled
+        add_schema_error('is not allowed to be empty') if input.blank? && !maybe_evaluator_applies?
+      end
+
+      def child_applications
+        @child_applications ||= begin
+          return [] unless input.respond_to?(:each_with_index)
+
+          input.each_with_index.map do |item, index|
+            build_child_application(item, index)
+          end
+        end
+
+      end
+
+      def build_child_application(item, error_key)
+        sub_node.build_application(input: item, context: context, parent: self, error_key: error_key)
+      end
 
-        super
+      def sub_node
+        @sub_node ||= node.sub_nodes.values.first
       end
     end
   end

data/lib/nxt_schema/{application → node}/error_store.rb

@@ -1,5 +1,5 @@
 module NxtSchema
-  module Application
+  module Node
     class ErrorStore < ::Hash
       def initialize(application)
         super()
@@ -11,7 +11,7 @@ module NxtSchema
       def add_schema_error(message:)
         add_error(
           application,
-          NxtSchema::Application::Errors::SchemaError.new(
+          NxtSchema::Node::Errors::SchemaError.new(
             application: application,
             message: message
           )
@@ -21,7 +21,7 @@ module NxtSchema
       def add_validation_error(message:)
         add_error(
           application,
-          NxtSchema::Application::Errors::ValidationError.new(
+          NxtSchema::Node::Errors::ValidationError.new(
             application: application,
             message: message
           )
@@ -39,7 +39,7 @@ module NxtSchema
 
       # def schema_errors
       #   inject({}) do |acc, (k, v)|
-      #     errors = v.select { |e| e.is_a?(NxtSchema::Application::Errors::SchemaError) }
+      #     errors = v.select { |e| e.is_a?(NxtSchema::Node::Errors::SchemaError) }
       #     acc[k] = errors if errors.any?
       #     acc
       #   end
@@ -47,7 +47,7 @@ module NxtSchema
       #
       # def validation_errors
       #   inject({}) do |acc, (k, v)|
-      #     errors = v.select { |e| e.is_a?(NxtSchema::Application::Errors::ValidationError) }
+      #     errors = v.select { |e| e.is_a?(NxtSchema::Node::Errors::ValidationError) }
       #     acc[k] = errors if errors.any?
       #     acc
       #   end

data/lib/nxt_schema/{application → node}/errors/schema_error.rb

@@ -1,5 +1,5 @@
 module NxtSchema
-  module Application
+  module Node
     module Errors
       class SchemaError < ::String
         def initialize(application:, message:)

data/lib/nxt_schema/{application → node}/errors/validation_error.rb

@@ -1,5 +1,5 @@
 module NxtSchema
-  module Application
+  module Node
     module Errors
       class ValidationError < ::String
         def initialize(application:, message:)

data/lib/nxt_schema/node/leaf.rb

@@ -1,12 +1,14 @@
 module NxtSchema
   module Node
     class Leaf < Node::Base
-      def initialize(name:, type: :String, parent_node:, **options, &block)
-        super
-      end
+      def call
+        apply_on_evaluators
+        return self if maybe_evaluator_applies?
 
-      def leaf?
-        true
+        coerce_input
+        register_as_coerced_when_no_errors
+        run_validations
+        self
       end
     end
   end

data/lib/nxt_schema/node/schema.rb

@@ -1,20 +1,113 @@
 module NxtSchema
   module Node
     class Schema < Node::Base
-      include HasSubNodes
+      def call
+        apply_on_evaluators
+        child_applications # build applications here so we can access them even when invalid
+        return self if maybe_evaluator_applies?
 
-      DEFAULT_TYPE = NxtSchema::Types::Strict::Hash
+        coerce_input
+        return self unless valid?
 
-      def initialize(name:, type: DEFAULT_TYPE, parent_node:, **options, &block)
-        super
+        flag_missing_keys
+        apply_additional_keys_strategy
+
+        child_applications.each do |key, child|
+          current_application = child.call
+
+          if !current_application.valid?
+            merge_errors(current_application)
+          else
+            output[key] = current_application.output
+          end
+        end
+
+        transform_keys
+        register_as_coerced_when_no_errors
+        run_validations
+        self
       end
 
-      def optional(name, node_or_type_of_node, **options, &block)
-        node(name, node_or_type_of_node, **options.merge(optional: true), &block)
+      delegate :[], to: :child_applications
+
+      private
+
+      def transform_keys
+        transformer = node.key_transformer
+        return unless transformer && output.respond_to?(:transform_keys!)
+
+        output.transform_keys!(&transformer)
+      end
+
+      def keys
+        @keys ||= node.sub_nodes.reject { |key, _| optional_and_not_given_key?(key) }.keys
+      end
+
+      def additional_keys
+        @additional_keys ||= input.keys - keys
+      end
+
+      def optional_and_not_given_key?(key)
+        node.sub_nodes[key].optional? && !input.key?(key)
+      end
+
+      def additional_keys?
+        additional_keys.any?
+      end
+
+      def missing_keys
+        @missing_keys ||= node.sub_nodes.reject { |_, node| node.omnipresent? || node.optional? }.keys - input.keys
+      end
+
+      def apply_additional_keys_strategy
+        return if allow_additional_keys?
+        return unless additional_keys?
+
+        if restrict_additional_keys?
+          add_schema_error("Additional keys are not allowed: #{additional_keys}")
+        elsif reject_additional_keys?
+          self.output = output.except(*additional_keys)
+        end
+      end
+
+      def flag_missing_keys
+        return if missing_keys.empty?
+
+        add_schema_error("The following keys are missing: #{missing_keys}")
+      end
+
+      def allow_additional_keys?
+        node.additional_keys_strategy == :allow
+      end
+
+      def reject_additional_keys?
+        node.additional_keys_strategy == :reject
+      end
+
+      def restrict_additional_keys?
+        node.additional_keys_strategy == :restrict
+      end
+
+      def child_applications
+        @child_applications ||= begin
+          keys.inject({}) do |acc, key|
+            child_application = build_child_application(key)
+            acc[key] = child_application if child_application.present?
+            acc
+          end
+        end
+      end
+
+      def build_child_application(key)
+        sub_node = node.sub_nodes[key]
+        return unless sub_node.present?
+
+        value = input_has_key?(input, key) ? input[key] : MissingInput.new
+        sub_node.build_application(input: value, context: context, parent: self)
       end
 
-      def omnipresent(name, node_or_type_of_node, **options, &block)
-        node(name, node_or_type_of_node, **options.merge(omnipresent: true), &block)
+      def input_has_key?(input, key)
+        input.respond_to?(:key?) && input.key?(key)
       end
     end
   end