nxt_schema 0.1.0

data/lib/nxt_schema/node/maybe_evaluator.rb

@@ -0,0 +1,23 @@
+module NxtSchema
+  module Node
+    class MaybeEvaluator
+      def initialize(node, evaluator, value)
+        @node = node
+        @evaluator = evaluator
+        @value = value
+      end
+
+      attr_reader :node, :evaluator, :value
+
+      def call
+        if evaluator.respond_to?(:call)
+          Callable.new(evaluator).call(node, value)
+        elsif value.is_a?(Symbol) && value.respond_to?(evaluator)
+          Callable.new(evaluator).bind(value).call(node, value)
+        else
+          value == evaluator
+        end
+      end
+    end
+  end
+end

data/lib/nxt_schema/node/schema.rb

@@ -0,0 +1,147 @@
+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
+
+
+
+            sanitized_keys.each do |key|
+              node = template_store[key]
+
+              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
+          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 optional(name, type, **options, &block)
+        raise_invalid_options_presence_options if options[:presence]
+
+        node(name, type, options.merge(optional: true), &block)
+      end
+
+      def present(name, type, **options, &block)
+        raise_invalid_options_presence_options if options[:optional]
+
+        node(name, type, options.merge(presence: true), &block)
+      end
+
+      private
+
+      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
+      end
+
+      def transform_keys(hash)
+        return hash unless key_transformer && hash.respond_to?(:transform_keys!)
+
+        hash.transform_keys! { |key| Callable.new(key_transformer).bind(key).call(key) }
+      end
+
+      def key_transformer
+        @key_transformer ||= root.options.fetch(:transform_keys) { false }
+      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?
+
+        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}"
+        end
+      end
+
+      def allowed_additional_key?(key)
+        additional_keys_from_input.include?(key)
+      end
+
+      def additional_keys_from_input
+        (input&.keys || [])  - template_store.keys
+      end
+
+      def additional_keys_allowed?
+        additional_keys_strategy.to_s == 'allow'
+      end
+
+      def ignore_additional_keys?
+        additional_keys_strategy.to_s == 'ignore'
+      end
+
+      def restrict_additional_keys?
+        additional_keys_strategy.to_s == 'restrict'
+      end
+
+      def raise_invalid_options_presence_options
+        raise InvalidOptionsError, 'Options :presence and :optional exclude each other'
+      end
+    end
+  end
+end

data/lib/nxt_schema/node/template_store.rb

@@ -0,0 +1,15 @@
+module NxtSchema
+  module Node
+    class TemplateStore < ::Hash
+      def push(node)
+        node_name = node.name
+        raise_key_error(node_name) if key?(node_name)
+        self[node_name] = node
+      end
+
+      def raise_key_error(key)
+        raise KeyError, "Node with name '#{key}' already registered! Node names must be unique!"
+      end
+    end
+  end
+end

data/lib/nxt_schema/node/type_resolver.rb

@@ -0,0 +1,24 @@
+module NxtSchema
+  module Node
+    class TypeResolver
+      def resolve(type_system, type)
+        @resolve ||= {}
+        @resolve[type] ||= begin
+          if type.is_a?(Dry::Types::Type)
+            type
+          else
+            # Try to resolve in type system
+            type = type_system.const_get(type.to_s.classify)
+
+            if type.is_a?(Dry::Types::Type)
+              type
+            else
+              # in case it does not exist fallback to Types::Nominal
+              "NxtSchema::Types::Nominal::#{type.to_s.classify}".constantize
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nxt_schema/node/validate_with_proxy.rb

@@ -0,0 +1,41 @@
+module NxtSchema
+  module Node
+    class ValidateWithProxy
+      def initialize(node)
+        @node = node
+        @aggregated_errors = []
+      end
+
+      attr_reader :node
+
+      delegate_missing_to :node
+
+      def validate(&block)
+        result = instance_exec(&block)
+        return if result
+
+        copy_aggregated_errors_to_node
+      end
+
+      def add_error(error)
+        aggregated_errors << error
+        false
+      end
+
+      def copy_aggregated_errors_to_node
+        aggregated_errors.each do |error|
+          node.add_error(error)
+        end
+      end
+
+      private
+
+      attr_reader :aggregated_errors
+
+      def validator(key, *args)
+        validator = node.validator(key, *args)
+        validator.call(self, node.value)
+      end
+    end
+  end
+end

data/lib/nxt_schema/node.rb

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

data/lib/nxt_schema/registry.rb

@@ -0,0 +1,85 @@
+module NxtSchema
+  class Registry
+    def initialize(namespace_separator: '::', namespace: '')
+      @store = ActiveSupport::HashWithIndifferentAccess.new
+      @namespace_separator = namespace_separator
+      @namespace = namespace
+    end
+
+    delegate_missing_to :store
+
+    # register('strict::string')
+    # Registry[:strict].register
+
+    def register(key, value)
+      key = key.to_s
+      ensure_key_not_registered_already(key)
+      namespaced_store(key)[flat_key(key)] = value
+    end
+
+    def resolve(key, *args)
+      value = resolve_value(key)
+      return value unless value.respond_to?(:call)
+
+      value.call(*args)
+    end
+
+    def resolve_value(key)
+      key = key.to_s
+      parts = namespaced_key_parts(key)[0..-2]
+
+      namespaced_store = parts.inject(store) do |acc, key|
+        acc.fetch(key)
+      rescue KeyError
+        raise KeyError, "No registry found at #{key} in #{acc}"
+      end
+
+      begin
+        namespaced_store.fetch(flat_key(key))
+      rescue KeyError
+        raise KeyError, "Could not find #{flat_key(key)} in #{namespaced_store}"
+      end
+    end
+
+    private
+
+    attr_reader :store, :namespace_separator, :namespace
+
+    def namespaced_store(key)
+      parts = namespaced_key_parts(key)
+
+      current_parts = []
+
+      parts[0..-2].inject(store) do |acc, namespace|
+        current_parts << namespace
+        current_namespace = current_parts.join(namespace_separator)
+
+        acc.fetch(namespace) do
+          acc[namespace] = Registry.new(namespace: current_namespace)
+          acc = acc[namespace]
+          acc
+        end
+      end
+    end
+
+    def namespaced_key_parts(key)
+      key.downcase.split(namespace_separator)
+    end
+
+    def flat_key(key)
+      namespaced_key_parts(key).last
+    end
+
+    def ensure_key_not_registered_already(key)
+      return unless namespaced_store(key).key?(flat_key(key))
+
+      raise KeyError, "Key: #{flat_key(key)} already registered in #{namespaced_store(key)}"
+    end
+
+    def to_s
+      identifier = 'NxtSchema::Registry'
+      identifier << "#{namespace_separator}#{namespace}" unless namespace.blank?
+      identifier
+    end
+  end
+end

data/lib/nxt_schema/types.rb

@@ -0,0 +1,10 @@
+module NxtSchema
+  module Types
+    include Dry.Types()
+
+    StrippedString = Strict::String.constructor(->(string) { string&.strip })
+    StrippedNonBlankString = StrippedString.constrained(min_size: 1)
+    Enums = -> (*values) { Strict::String.enum(*values) } # Use as NxtSchema::Types::Enums[*ROLES]
+    SymbolizedEnums = -> (*values) { Coercible::Symbol.enum(*values) } # Use as NxtSchema::Types::SymboleEnums[*ROLES]
+  end
+end

data/lib/nxt_schema/undefined.rb

@@ -0,0 +1,7 @@
+module NxtSchema
+  class Undefined
+    def inspect
+      'undefined'
+    end
+  end
+end

data/lib/nxt_schema/validators/attribute.rb

@@ -0,0 +1,34 @@
+module NxtSchema
+  module Validators
+    class Attribute < Validator
+      def initialize(method, expectation)
+        @method = method
+        @expectation = expectation
+      end
+
+      register_as :attribute, :attr
+      attr_reader :method, :expectation
+
+      # Query any attribute on a value with validator(:attribute, :size, ->(s) { s < 7 })
+
+      def build
+        lambda do |node, value|
+          raise ArgumentError, "#{value} does not respond to query: #{method}" unless value.respond_to?(method)
+
+          if expectation.call(value.send(method))
+            true
+          else
+            node.add_error(
+              translate_error(
+                node.locale,
+                attribute: value,
+                attribute_name: method,
+                value: value.send(method)
+              )
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nxt_schema/validators/equality.rb

@@ -0,0 +1,33 @@
+module NxtSchema
+  module Validators
+    class Equality < Validator
+      def initialize(expectation)
+        @expectation = expectation
+      end
+
+      register_as :equality, :eql
+      attr_reader :expectation
+
+      # Query for equality validator(:equality, 3)
+      # Query for equality validator(:eql, -> { 3 * 3 * 60 })
+
+      def build
+        lambda do |node, value|
+          expected_value = expectation.respond_to?(:call) ? Callable.new(expectation).call(node, value) : expectation
+
+          if value == expected_value
+            true
+          else
+            node.add_error(
+              translate_error(
+                node.locale,
+                actual: value,
+                expected: expected_value
+              )
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nxt_schema/validators/excluded.rb

@@ -0,0 +1,23 @@
+module NxtSchema
+  module Validators
+    class Excluded < Validator
+      def initialize(target)
+        @target = target
+      end
+
+      register_as :excluded
+      attr_reader :target
+
+      def build
+        lambda do |node, value|
+          if target.exclude?(value)
+            true
+          else
+            message = translate_error(node.locale, target: target, value: value)
+            node.add_error(message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nxt_schema/validators/excludes.rb

@@ -0,0 +1,23 @@
+module NxtSchema
+  module Validators
+    class Excludes < Validator
+      def initialize(target)
+        @target = target
+      end
+
+      register_as :excludes
+      attr_reader :target
+
+      def build
+        lambda do |node, value|
+          if value.exclude?(target)
+            true
+          else
+            message = translate_error(node.locale, target: target, value: value)
+            node.add_error(message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nxt_schema/validators/greater_than.rb

@@ -0,0 +1,23 @@
+module NxtSchema
+  module Validators
+    class GreaterThan < Validator
+      def initialize(threshold)
+        @threshold = threshold
+      end
+
+      register_as :greater_than
+      attr_reader :threshold
+
+      def build
+        lambda do |node, value|
+          if value > threshold
+            true
+          else
+            message = translate_error(node.locale, value: value, threshold: threshold)
+            node.add_error(message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nxt_schema/validators/greater_than_or_equal.rb

@@ -0,0 +1,23 @@
+module NxtSchema
+  module Validators
+    class GreaterThanOrEqual < Validator
+      def initialize(threshold)
+        @threshold = threshold
+      end
+
+      register_as :greater_than_or_equal, :gt_or_eql
+      attr_reader :threshold
+
+      def build
+        lambda do |node, value|
+          if value >= threshold
+            true
+          else
+            message = translate_error(node.locale, value: value, threshold: threshold)
+            node.add_error(message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nxt_schema/validators/included.rb

@@ -0,0 +1,23 @@
+module NxtSchema
+  module Validators
+    class Included < Validator
+      def initialize(target)
+        @target = target
+      end
+
+      register_as :included
+      attr_reader :target
+
+      def build
+        lambda do |node, value|
+          if target.include?(value)
+            true
+          else
+            message = translate_error(node.locale, value: value, target: target)
+            node.add_error(message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nxt_schema/validators/includes.rb

@@ -0,0 +1,23 @@
+module NxtSchema
+  module Validators
+    class Includes < Validator
+      def initialize(target)
+        @target = target
+      end
+
+      register_as :includes
+      attr_reader :target
+
+      def build
+        lambda do |node, value|
+          if value.include?(target)
+            true
+          else
+            message = translate_error(node.locale, value: value, target: target)
+            node.add_error(message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nxt_schema/validators/less_than.rb

@@ -0,0 +1,23 @@
+module NxtSchema
+  module Validators
+    class LessThan < Validator
+      def initialize(threshold)
+        @threshold = threshold
+      end
+
+      register_as :less_than
+      attr_reader :threshold
+
+      def build
+        lambda do |node, value|
+          if value < threshold
+            true
+          else
+            message = translate_error(node.locale, value: value, threshold: threshold)
+            node.add_error(message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nxt_schema/validators/less_than_or_equal.rb

@@ -0,0 +1,23 @@
+module NxtSchema
+  module Validators
+    class LessThanOrEqual < Validator
+      def initialize(threshold)
+        @threshold = threshold
+      end
+
+      register_as :less_than_or_equal, :lt_or_eql
+      attr_reader :threshold
+
+      def build
+        lambda do |node, value|
+          if value <= threshold
+            true
+          else
+            message = translate_error(node.locale, value: value, threshold: threshold)
+            node.add_error(message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nxt_schema/validators/optional_node.rb

@@ -0,0 +1,26 @@
+module NxtSchema
+  module Validators
+    class OptionalNode < Validator
+      def initialize(conditional, missing_key)
+        @conditional = conditional
+        @missing_key = missing_key
+      end
+
+      register_as :optional_node
+      attr_reader :conditional, :missing_key
+
+      def build
+        lambda do |node, value|
+          args = [node, value]
+
+          if conditional.call(*args.take(conditional.arity))
+            true
+          else
+            message = ErrorMessages.resolve(node.locale, :required_key_missing, key: missing_key, target: node.value)
+            node.add_error(message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nxt_schema/validators/pattern.rb

@@ -0,0 +1,24 @@
+module NxtSchema
+  module Validators
+    class Pattern < Validator
+      def initialize(pattern)
+        @pattern = pattern
+      end
+
+      register_as :pattern, :format
+      attr_reader :pattern
+
+      def build
+        lambda do |node, value|
+          if value.match(pattern)
+            true
+          else
+            message = translate_error(node.locale, value: value, pattern: pattern)
+            node.add_error(message)
+            false
+          end
+        end
+      end
+    end
+  end
+end