nxt_schema 0.1.2 → 1.0.0

data/lib/nxt_schema.rb

@@ -1,68 +1,75 @@
-require "nxt_schema/version"
-require "active_support/all"
+require 'nxt_schema/version'
+require 'active_support/all'
 require 'dry-types'
 require 'nxt_registry'
+require 'nxt_init'
 require 'yaml'
 
-require "nxt_schema/types"
-require "nxt_schema/undefined"
-require "nxt_schema/registry"
-require "nxt_schema/callable"
-require "nxt_schema/callable_or_value"
-require "nxt_schema/validators/registry"
-require "nxt_schema/node/validate_with_proxy"
+require_relative 'nxt_schema/types'
+require_relative 'nxt_schema/callable'
+require_relative 'nxt_schema/application'
+require_relative 'nxt_schema/missing_input'
+require_relative 'nxt_schema/error'
+require_relative 'nxt_schema/errors/invalid'
+require_relative 'nxt_schema/errors/invalid_options'
 
-require "nxt_schema/errors"
-require "nxt_schema/errors/error"
-require "nxt_schema/errors/schema_not_applied_error"
-require "nxt_schema/errors/invalid_options_error"
+require_relative 'nxt_schema/validators/registry'
+require_relative 'nxt_schema/validators/validate_with_proxy'
+require_relative 'nxt_schema/validators/error_messages'
+require_relative 'nxt_schema/validators/validator'
+require_relative 'nxt_schema/validators/attribute'
+require_relative 'nxt_schema/validators/equal_to'
+require_relative 'nxt_schema/validators/optional_node'
+require_relative 'nxt_schema/validators/greater_than'
+require_relative 'nxt_schema/validators/greater_than_or_equal'
+require_relative 'nxt_schema/validators/less_than'
+require_relative 'nxt_schema/validators/less_than_or_equal'
+require_relative 'nxt_schema/validators/pattern'
+require_relative 'nxt_schema/validators/included_in'
+require_relative 'nxt_schema/validators/includes'
+require_relative 'nxt_schema/validators/excluded_in'
+require_relative 'nxt_schema/validators/excludes'
+require_relative 'nxt_schema/validators/query'
 
-require "nxt_schema/error_messages"
-require "nxt_schema/validators/validator"
-require "nxt_schema/validators/attribute"
-require "nxt_schema/validators/equality"
-require "nxt_schema/validators/optional_node"
-require "nxt_schema/validators/greater_than"
-require "nxt_schema/validators/greater_than_or_equal"
-require "nxt_schema/validators/less_than"
-require "nxt_schema/validators/less_than_or_equal"
-require "nxt_schema/validators/pattern"
-require "nxt_schema/validators/included"
-require "nxt_schema/validators/includes"
-require "nxt_schema/validators/excluded"
-require "nxt_schema/validators/excludes"
-require "nxt_schema/validators/query"
+require_relative 'nxt_schema/node/on_evaluator'
+require_relative 'nxt_schema/node/maybe_evaluator'
+require_relative 'nxt_schema/node/type_resolver'
+require_relative 'nxt_schema/node/type_system_resolver'
+require_relative 'nxt_schema/node/base'
+require_relative 'nxt_schema/node/sub_nodes'
+require_relative 'nxt_schema/node/has_sub_nodes'
+require_relative 'nxt_schema/node/any_of'
+require_relative 'nxt_schema/node/collection'
+require_relative 'nxt_schema/node/schema'
+require_relative 'nxt_schema/node/leaf'
 
-require "nxt_schema/node"
-require "nxt_schema/node/type_resolver"
-require "nxt_schema/node/maybe_evaluator"
-require "nxt_schema/node/default_value_evaluator"
-require "nxt_schema/node/base"
-require "nxt_schema/node/error"
-require "nxt_schema/node/has_subnodes"
-require "nxt_schema/node/template_store"
-require "nxt_schema/node/schema"
-require "nxt_schema/node/collection"
-require "nxt_schema/node/leaf"
-require "nxt_schema/dsl"
+require_relative 'nxt_schema/application/errors/schema_error'
+require_relative 'nxt_schema/application/errors/validation_error'
+require_relative 'nxt_schema/application/error_store'
+require_relative 'nxt_schema/application/base'
+require_relative 'nxt_schema/application/any_of'
+require_relative 'nxt_schema/application/leaf'
+require_relative 'nxt_schema/application/collection'
+require_relative 'nxt_schema/application/schema'
+require_relative 'nxt_schema/dsl'
 
 module NxtSchema
+  extend Dsl
+
+  def register_error_messages(*paths)
+    Validators::ErrorMessages.load(paths)
+  end
+
   def register_validator(validator, *keys)
-    keys.each do |key|
-      NxtSchema::Validators::Registry::VALIDATORS.register(key, validator)
-    end
+    keys.each { |key| NxtSchema::Validators::REGISTRY.register(key, validator) }
   end
 
   def register_type(key, type)
     NxtSchema::Types.const_set(key.to_s, type)
   end
 
-  def register_error_messages(*paths)
-    ErrorMessages.load(paths)
-  end
-
   # Load default messages
-  ErrorMessages.load
+  Validators::ErrorMessages.load
 
-  module_function :register_validator, :register_type, :register_error_messages
+  module_function :register_error_messages, :register_validator, :register_type
 end

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

@@ -1,5 +1,5 @@
 module NxtSchema
-  module Node
+  module Application
 
   end
 end

data/lib/nxt_schema/application/any_of.rb

@@ -0,0 +1,40 @@
+module NxtSchema
+  module Application
+    class AnyOf < Application::Base
+      def valid?
+        valid_application.present?
+      end
+
+      def call
+        # TODO: We should check that this is not empty!
+        child_applications.map(&:call)
+
+        if valid?
+          self.output = valid_application.output
+        else
+          child_applications.each do |application|
+            merge_errors(application)
+          end
+        end
+
+        self
+      end
+
+      private
+
+      delegate :[], to: :child_applications
+
+      def valid_application
+        child_applications.find(&:valid?)
+      end
+
+      def child_applications
+        @child_applications ||= nodes.map { |node| node.build_application(input: input, context: context, parent: self) }
+      end
+
+      def nodes
+        @nodes ||= node.sub_nodes.values
+      end
+    end
+  end
+end

data/lib/nxt_schema/application/base.rb

@@ -0,0 +1,116 @@
+module NxtSchema
+  module Application
+    class Base
+      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
+        @applied = false
+        @applied_nodes = parent&.applied_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
+
+        @index = error_key
+        resolve_error_key(error_key)
+      end
+
+      attr_accessor :output, :node, :input
+      attr_reader :parent, :context, :error_key, :applied, :applied_nodes, :root, :errors, :locale, :index
+
+      def call
+        raise NotImplementedError, 'Implement this in our sub class'
+      end
+
+      delegate :name, :options, to: :node
+
+      def root?
+        @is_root
+      end
+
+      def valid?
+        errors.empty?
+      end
+
+      def add_error(error)
+        errors.add_validation_error(message: error)
+      end
+
+      def add_schema_error(error)
+        errors.add_schema_error(message: error)
+      end
+
+      def merge_errors(application)
+        errors.merge_errors(application)
+      end
+
+      def run_validations
+        return false unless applied?
+
+        node.validations.each do |validation|
+          args = [self, input]
+          validation.call(*args.take(validation.arity))
+        end
+      end
+
+      def up(levels = 1)
+        0.upto(levels - 1).inject(self) do |acc, _|
+          parent = acc.send(:parent)
+          break acc unless parent
+
+          parent
+        end
+      end
+
+      private
+
+      attr_writer :applied, :root
+
+      def coerce_input
+        output = input.is_a?(MissingInput) && node.omnipresent? ? input : node.type[input]
+        self.output = output
+
+      rescue Dry::Types::CoercionError => error
+        add_schema_error(error.message)
+      end
+
+      def apply_on_evaluators
+        node.on_evaluators.each { |evaluator| evaluator.call(input, self, context) { |result| self.input = result } }
+      end
+
+      def maybe_evaluator_applies?
+        @maybe_evaluator_applies ||= node.maybe_evaluators.inject(false) do |acc, evaluator|
+          result = (acc || evaluator.call(input, self, context))
+
+          if result
+            self.output = input
+            break true
+          else
+            false
+          end
+        end
+      end
+
+      def register_as_applied_when_valid
+        return unless valid?
+
+        self.applied = true
+        applied_nodes << self
+      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 applied?
+        @applied
+      end
+    end
+  end
+end

data/lib/nxt_schema/application/collection.rb

@@ -0,0 +1,57 @@
+module NxtSchema
+  module Application
+    class Collection < Application::Base
+      def call
+        apply_on_evaluators
+        child_applications # build applications here so we can access them even when invalid
+        return self if maybe_evaluator_applies?
+
+        coerce_input
+        validate_filled
+        return self unless valid?
+
+        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_applied_when_valid
+        run_validations
+
+        self
+      end
+
+      delegate :[], to: :child_applications
+
+      private
+
+      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
+
+      def sub_node
+        @sub_node ||= node.sub_nodes.values.first
+      end
+    end
+  end
+end

data/lib/nxt_schema/application/error_store.rb

@@ -0,0 +1,57 @@
+module NxtSchema
+  module Application
+    class ErrorStore < ::Hash
+      def initialize(application)
+        super()
+        @application = application
+      end
+
+      attr_reader :application
+
+      def add_schema_error(message:)
+        add_error(
+          application,
+          NxtSchema::Application::Errors::SchemaError.new(
+            application: application,
+            message: message
+          )
+        )
+      end
+
+      def add_validation_error(message:)
+        add_error(
+          application,
+          NxtSchema::Application::Errors::ValidationError.new(
+            application: application,
+            message: message
+          )
+        )
+      end
+
+      def merge_errors(application)
+        merge!(application.errors)
+      end
+
+      def add_error(application, error)
+        self[application.error_key] ||= []
+        self[application.error_key] << error
+      end
+
+      # def schema_errors
+      #   inject({}) do |acc, (k, v)|
+      #     errors = v.select { |e| e.is_a?(NxtSchema::Application::Errors::SchemaError) }
+      #     acc[k] = errors if errors.any?
+      #     acc
+      #   end
+      # end
+      #
+      # def validation_errors
+      #   inject({}) do |acc, (k, v)|
+      #     errors = v.select { |e| e.is_a?(NxtSchema::Application::Errors::ValidationError) }
+      #     acc[k] = errors if errors.any?
+      #     acc
+      #   end
+      # end
+    end
+  end
+end

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

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

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

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

data/lib/nxt_schema/application/leaf.rb

@@ -0,0 +1,15 @@
+module NxtSchema
+  module Application
+    class Leaf < Application::Base
+      def call
+        apply_on_evaluators
+        return self if maybe_evaluator_applies?
+
+        coerce_input
+        register_as_applied_when_valid
+        run_validations
+        self
+      end
+    end
+  end
+end