nxt_schema 0.1.2 → 1.0.0

data/lib/nxt_schema/node/collection.rb

@@ -1,76 +1,21 @@
 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)
-
-            current_node_store = {}
+      include HasSubNodes
 
-            # if value.empty?
-            #   message = ErrorMessages.resolve(locale, :emptiness, value: value)
-            #   add_error(message)
-            # end
+      DEFAULT_TYPE = NxtSchema::Types::Strict::Array
 
-            value.each_with_index do |item, index|
-              item_schema_errors = schema_errors[index] ||= { schema_errors_key => [] }
-              validation_errors[index] ||= { schema_errors_key => [] }
-
-              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
-
-                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
-
-                  break
-                else
-                  schema_errors[index][node_name] = current_node.schema_errors
-                  validation_errors[index][node_name] = current_node.validation_errors
-                end
-              end
+      def initialize(name:, type: DEFAULT_TYPE, parent_node:, **options, &block)
+        super
+      end
 
-              item_schema_errors.reject! { |_, v| v.empty? }
-            end
+      private
 
-            # Once we collected all values ensure type by casting again
-            self.value_store = coerce_value(value_store)
-            self.value = value_store
-          end
-        end
+      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?
 
-        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
+        super
       end
     end
   end

data/lib/nxt_schema/node/has_sub_nodes.rb

@@ -0,0 +1,81 @@
+module NxtSchema
+  module Node
+    module HasSubNodes
+      def collection(name, type = NxtSchema::Node::Collection::DEFAULT_TYPE, **options, &block)
+        node = NxtSchema::Node::Collection.new(
+          name: name,
+          type: type,
+          parent_node: self,
+          **options,
+          &block
+        )
+
+        add_sub_node(node)
+      end
+
+      alias nodes collection
+
+      def schema(name, type = NxtSchema::Node::Schema::DEFAULT_TYPE, **options, &block)
+        node = NxtSchema::Node::Schema.new(
+          name: name,
+          type: type,
+          parent_node: self,
+          **options,
+          &block
+        )
+
+        add_sub_node(node)
+      end
+
+      def any_of(name, **options, &block)
+        node = NxtSchema::Node::AnyOf.new(
+          name: name,
+          parent_node: self,
+          **options,
+          &block
+        )
+
+        add_sub_node(node)
+      end
+
+      def node(name, node_or_type_of_node, **options, &block)
+        node = if node_or_type_of_node.is_a?(NxtSchema::Node::Base)
+          raise ArgumentError, "Can't provide a block along with a node" if block.present?
+
+          node_or_type_of_node.class.new(
+            name: name,
+            type: node_or_type_of_node.type,
+            parent_node: self,
+            **node_or_type_of_node.options.merge(options), # Does this make sense to merge options here?
+            &node_or_type_of_node.configuration
+          )
+        else
+          NxtSchema::Node::Leaf.new(
+            name: name,
+            type: node_or_type_of_node,
+            parent_node: self,
+            **options,
+            &block
+          )
+        end
+
+        add_sub_node(node)
+      end
+
+      alias required node
+
+      def add_sub_node(node)
+        sub_nodes.add(node)
+        node
+      end
+
+      def sub_nodes
+        @sub_nodes ||= Node::SubNodes.new
+      end
+
+      def [](key)
+        sub_nodes[key]
+      end
+    end
+  end
+end

data/lib/nxt_schema/node/leaf.rb

@@ -1,43 +1,13 @@
 module NxtSchema
   module Node
     class Leaf < Node::Base
-      def initialize(name:, type:, parent_node:, **options, &block)
+      def initialize(name:, type: :String, 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)
-      end
     end
   end
 end

data/lib/nxt_schema/node/maybe_evaluator.rb

@@ -1,23 +1,28 @@
 module NxtSchema
   module Node
     class MaybeEvaluator
-      def initialize(node, evaluator, value)
-        @node = node
-        @evaluator = evaluator
+      def initialize(value:)
         @value = value
       end
 
-      attr_reader :node, :evaluator, :value
+      def call(target = nil, *args)
+        evaluator = evaluator(target, *args)
 
-      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)
+        if evaluator.value?
+          # When a value was given we check if this equals to the input
+          evaluator.call == target
         else
-          value == evaluator
+          evaluator.call
         end
       end
+
+      private
+
+      def evaluator(target, *args)
+        Callable.new(value, target, *args)
+      end
+
+      attr_reader :value
     end
   end
 end

data/lib/nxt_schema/node/on_evaluator.rb

@@ -0,0 +1,25 @@
+module NxtSchema
+  module Node
+    class OnEvaluator
+      def initialize(condition:, value:)
+        @condition = condition
+        @value = value
+      end
+
+      def call(target = nil, *args, &block)
+        return unless condition_applies?(target, *args)
+
+        result = Callable.new(value, target, *args).call
+        block.yield(result)
+      end
+
+      private
+
+      def condition_applies?(target, *args)
+        Callable.new(condition, target, *args).call
+      end
+
+      attr_reader :condition, :value
+    end
+  end
+end

data/lib/nxt_schema/node/schema.rb

@@ -1,146 +1,20 @@
 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
+      include HasSubNodes
 
-      def evaluate_optional_option(node, hash, key)
-        optional_option = node.options[:optional]
+      DEFAULT_TYPE = NxtSchema::Types::Strict::Hash
 
-        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'
+      def initialize(name:, type: DEFAULT_TYPE, parent_node:, **options, &block)
+        super
       end
 
-      def restrict_additional_keys?
-        additional_keys_strategy.to_s == 'restrict'
+      def optional(name, node_or_type_of_node, **options, &block)
+        node(name, node_or_type_of_node, **options.merge(optional: true), &block)
       end
 
-      def raise_invalid_options_presence_options
-        raise InvalidOptionsError, 'Options :presence and :optional exclude each other'
+      def omnipresent(name, node_or_type_of_node, **options, &block)
+        node(name, node_or_type_of_node, **options.merge(omnipresent: true), &block)
       end
     end
   end

data/lib/nxt_schema/node/sub_nodes.rb

@@ -0,0 +1,22 @@
+module NxtSchema
+  module Node
+    class SubNodes < ::Hash
+      def initialize
+        super
+        transform_keys { |k| k.to_sym }
+      end
+
+      def add(node)
+        node_name = node.name
+        ensure_node_name_free(node_name)
+        self[node_name] = node
+      end
+
+      def ensure_node_name_free(name)
+        return unless key?(name)
+
+        raise KeyError, "Node with name '#{name}' already exists! Node names must be unique!"
+      end
+    end
+  end
+end