nxt_schema 0.1.2 → 1.0.0

data/lib/nxt_schema/application/schema.rb

@@ -0,0 +1,114 @@
+module NxtSchema
+  module Application
+    class Schema < 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
+        return self unless valid?
+
+        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_applied_when_valid
+        run_validations
+        self
+      end
+
+      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 input_has_key?(input, key)
+        input.respond_to?(:key?) && input.key?(key)
+      end
+    end
+  end
+end

data/lib/nxt_schema/callable.rb

@@ -1,74 +1,40 @@
 module NxtSchema
   class Callable
-    def initialize(callee)
-      @callee = callee
-
-      if callee.is_a?(Symbol)
-        self.type = :method
-      elsif callee.respond_to?(:call)
-        self.type = :proc
-        self.context = callee.binding
-      else
-        raise ArgumentError, "Callee is nor symbol nor a proc: #{callee}"
-      end
-    end
-
-    def bind!(execution_context)
-      self.context = execution_context
-      ensure_context_not_missing
-      self
+    def initialize(callable, target = nil, *args)
+      @callable = callable
+      @target = target
+      @args = args
     end
 
-    def bind(execution_context = nil)
-      return self if context
+    def call
+      return callable if value?
+      return callable.call(*args_from_arity) if proc?
 
-      self.context = execution_context
-      ensure_context_not_missing
-      self
+      target.send(callable, *args_from_arity)
     end
 
-    # NOTE: Currently we only allow arguments! Not keyword args or **options
-    # If we would allow **options and we would pass a hash as the only argument it would
-    # automatically be parsed as the options!
-    def call(*args)
-      ensure_context_not_missing
-
-      args = args.take(arity)
+    def method?
+      @method ||= callable.class.in?([Symbol, String]) && target.respond_to?(callable)
+    end
 
-      if method?
-        context.send(callee, *args)
-      else
-        context.instance_exec(*args, &callee)
-      end
+    def proc?
+      @proc ||= callable.respond_to?(:call)
     end
 
-    def arity
-      if proc?
-        callee.arity
-      elsif method?
-        method = context.send(:method, callee)
-        method.arity
-      else
-        raise ArgumentError, "Can't resolve arity from #{callee}"
-      end
+    def value?
+      !method? && !proc?
     end
 
     private
 
-    def proc?
-      type == :proc
-    end
+    attr_reader :callable, :target, :args
 
-    def method?
-      type == :method
+    def arity
+      proc? ? callable.arity : 0
     end
 
-    def ensure_context_not_missing
-      return if context
-
-      raise ArgumentError, "Missing context: #{context}"
+    def args_from_arity
+      @args_from_arity ||= ([target] + args).take(arity)
     end
-
-    attr_accessor :context, :callee, :type
   end
-end
+end

data/lib/nxt_schema/dsl.rb

@@ -1,38 +1,48 @@
 module NxtSchema
-  def schema(name = :root, **options, &block)
-    Node::Schema.new(name: name, parent_node: nil, **options, &block)
-  end
+  module Dsl
+    DEFAULT_OPTIONS = { type_system: NxtSchema::Types }.freeze
 
-  def collection(name = :roots, **options, &block)
-    Node::Collection.new(name: name, parent_node: nil, **options, &block)
-  end
+    def collection(name = :root, type: NxtSchema::Node::Collection::DEFAULT_TYPE, **options, &block)
+      NxtSchema::Node::Collection.new(
+        name: name,
+        type: type,
+        parent_node: nil,
+        **DEFAULT_OPTIONS.merge(options),
+        &block
+      )
+    end
 
-  def params(name = :root, **options, &block)
-    Node::Schema.new(
-      name: name,
-      parent_node: nil,
-      **options.merge(
-        type_system: NxtSchema::Types::Params,
-      ).reverse_merge(transform_keys: :to_sym),
-      &block
-    )
-  end
+    alias nodes collection
 
-  def json(name = :root, **options, &block)
-    Node::Schema.new(
-      name: name,
-      parent_node: nil,
-      **options.merge(
-        type_system: NxtSchema::Types::JSON,
-      ).reverse_merge(transform_keys: :to_sym),
-      &block
-    )
-  end
+    def schema(name = :roots, type: NxtSchema::Node::Schema::DEFAULT_TYPE, **options, &block)
+      NxtSchema::Node::Schema.new(
+        name: name,
+        type: type,
+        parent_node: nil,
+        **DEFAULT_OPTIONS.merge(options),
+        &block
+      )
+    end
+
+    def any_of(name = :roots, **options, &block)
+      NxtSchema::Node::AnyOf.new(
+        name: name,
+        parent_node: nil,
+        **DEFAULT_OPTIONS.merge(options),
+        &block
+      )
+    end
 
-  alias_method :node, :schema
-  alias_method :root, :schema
-  alias_method :nodes, :collection
-  alias_method :roots, :collection
+    # schema root with NxtSchema::Types::Params type system
 
-  module_function :root, :roots, :node, :nodes, :collection, :schema, :params
+    def params(name = :params, type: NxtSchema::Node::Schema::DEFAULT_TYPE, **options, &block)
+      NxtSchema::Node::Schema.new(
+        name: name,
+        type: type,
+        parent_node: nil,
+        **options.merge(type_system: NxtSchema::Types::Params),
+        &block
+      )
+    end
+  end
 end

data/lib/nxt_schema/error.rb

@@ -0,0 +1,4 @@
+module NxtSchema
+  class Error < StandardError
+  end
+end

data/lib/nxt_schema/errors/invalid.rb

@@ -0,0 +1,16 @@
+module NxtSchema
+  module Errors
+    class Invalid < NxtSchema::Error
+      def initialize(node)
+        @node = node
+        super(build_message)
+      end
+
+      attr_reader :node
+
+      def build_message
+        node.errors
+      end
+    end
+  end
+end

data/lib/nxt_schema/errors/{error.rb → invalid_options.rb}

@@ -1,7 +1,6 @@
 module NxtSchema
   module Errors
-    class Error < StandardError
-
+    class InvalidOptions < NxtSchema::Error
     end
   end
 end

data/lib/nxt_schema/missing_input.rb

@@ -0,0 +1,9 @@
+module NxtSchema
+  class MissingInput
+    def inspect
+      self.class.name
+    end
+
+    alias to_s inspect
+  end
+end

data/lib/nxt_schema/node/any_of.rb

@@ -0,0 +1,51 @@
+module NxtSchema
+  module Node
+    class AnyOf < Base
+      include HasSubNodes
+
+      def initialize(name:, type: nil, parent_node:, **options, &block)
+        super
+      end
+
+      def collection(name = sub_nodes.count, type = NxtSchema::Node::Collection::DEFAULT_TYPE, **options, &block)
+        super
+      end
+
+      def schema(name = sub_nodes.count, type = NxtSchema::Node::Schema::DEFAULT_TYPE, **options, &block)
+        super
+      end
+
+      def node(name = sub_nodes.count, node_or_type_of_node = nil, **options, &block)
+        super
+      end
+
+      # TODO: Maybe overwrite sub node methods to not have to provide a name here and use node count instead
+
+      def on(*args)
+        raise NotImplementedError
+      end
+
+      def maybe(*args)
+        raise NotImplementedError
+      end
+
+      private
+
+      def resolve_type(name_or_type)
+        nil
+      end
+
+      def resolve_optional_option
+        return unless options.key?(:optional)
+
+        raise InvalidOptions, "The optional option is not available for nodes of type #{self.class.name}"
+      end
+
+      def resolve_omnipresent_option
+        return unless options.key?(:omnipresent)
+
+        raise InvalidOptions, "The omnipresent option is not available for nodes of type #{self.class.name}"
+      end
+    end
+  end
+end

data/lib/nxt_schema/node/base.rb

@@ -1,315 +1,217 @@
 module NxtSchema
   module Node
     class Base
-      def initialize(name: name_from_index, type:, parent_node:, **options, &block)
-        @name = name
+      def initialize(name:, type:, parent_node:, **options, &block)
+        resolve_name(name)
+
         @parent_node = parent_node
         @options = options
-        @type_system = resolve_type_system
-        @additional_keys_strategy = resolve_additional_keys_strategy
-        @type = type
-        @schema_errors_key = options.fetch(:schema_errors_key, :itself)
+        @is_root_node = parent_node.nil?
+        @root_node = parent_node.nil? ? self : parent_node.root_node
+        @path = resolve_path
+        @on_evaluators = []
+        @maybe_evaluators = []
         @validations = []
-        @level = parent_node ? parent_node.level + 1 : 0
-        @all_nodes = parent_node ? (parent_node.all_nodes || {}) : {}
-        @is_root = parent_node.nil?
-        @root = parent_node.nil? ? self : parent_node.root
-        @errors = {}
-        @context = options.fetch(:context, nil)
-        @applied = false
-        @input = nil
-        @value = NxtSchema::Undefined.new
-        @locale = options.fetch(:locale) { parent_node&.locale || 'en' }
-
-        # Note that it is not possible to use present? on an instance of NxtSchema::Schema since it inherits from Hash
-        evaluate_block(block) if block_given?
+        @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
 
       attr_accessor :name,
                     :parent_node,
                     :options,
                     :type,
-                    :schema_errors,
-                    :namespace,
-                    :errors,
-                    :validations,
-                    :schema_errors_key,
-                    :level,
-                    :validation_errors,
-                    :all_nodes,
-                    :value,
-                    :type_system,
-                    :root,
-                    :context,
-                    :applied,
-                    :input,
-                    :additional_keys_strategy,
-                    :locale
-
-
-      alias_method :types, :type_system
-
-      def parent(level = 1)
-        level.times.inject(self) { |acc| acc.parent_node }
-      end
+                    :root_node,
+                    :additional_keys_strategy
 
-      alias_method :up, :parent
+      attr_reader :type_system,
+                  :path,
+                  :context,
+                  :meta,
+                  :on_evaluators,
+                  :maybe_evaluators,
+                  :validations,
+                  :configuration,
+                  :key_transformer
 
-      def default(default_value, &block)
-        options.merge!(default: default_value)
-        evaluate_block(block) if block_given?
-        self
+      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
       end
 
-      def meta(value = NxtSchema::Undefined.new)
-        if value.is_a?(NxtSchema::Undefined)
-          @meta
-        else
-          @meta = value
-          self
-        end
-      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?
 
-      def value_or_default_value(value)
-        if !value && options.key?(:default)
-          DefaultValueEvaluator.new(self, options.fetch(:default)).call
-        else
-          value
-        end
+        raise NxtSchema::Errors::Invalid.new(result)
       end
 
-      def maybe(maybe_value, &block)
-        options.merge!(maybe: maybe_value)
-        evaluate_block(block) if block_given?
-        self
+      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
 
-      def optional(optional_value = nil, &block)
-        raise ArgumentError, 'Optional nodes can only exist within schemas' unless parent.is_a?(NxtSchema::Node::Schema)
-
-        options.merge!(optional: optional_value || block)
-        self
+      def root_node?
+        @is_root_node
       end
 
-      def presence(presence_value = nil, &block)
-        raise ArgumentError, 'Present nodes can only exist within schemas' unless parent.is_a?(NxtSchema::Node::Schema)
-
-        options.merge!(presence: presence_value || block)
-        self
+      def optional?
+        @optional
       end
 
-      def presence?
-        @presence ||= begin
-          presence_option = options[:presence]
-
-          options[:presence] = if presence_option.respond_to?(:call)
-            Callable.new(presence_option).call(self, value)
-          else
-            presence_option
-          end
-        end
+      def omnipresent?
+        @omnipresent
       end
 
-      def validate(key, *args, &block)
-        if key.is_a?(Symbol)
-          validator = validator(key, *args)
-        elsif key.respond_to?(:call)
-          validator = key
-        else
-          raise ArgumentError, "Don't know how to resolve validator from: #{key}"
-        end
+      def default(value = NxtSchema::MissingInput.new, &block)
+        value = missing_input?(value) ? block : value
+        condition = ->(input) { missing_input?(input) || input.nil? }
+        on(condition, value)
 
-        add_validators(validator)
-        evaluate_block(block) if block_given?
         self
       end
 
-      def add_error(error, index = schema_errors_key)
-        validation_errors[index] ||= []
-        validation_errors[index] << error
-        false
-      end
-
-      def validate_all_nodes
-        sorted_nodes = all_nodes.values.sort do |node, other_node|
-          [node.level, (!node.leaf?).to_s] <=> [other_node.level, (!other_node.leaf?).to_s]
-        end
-
-        # we have to start from the bottom, leafs before others on the same level
-        sorted_nodes.reverse_each(&:apply_validations)
-      end
-
-      def apply_validations
-        # We don't run validations in case there are schema errors
-        # to avoid weird errors
-        # First reject empty schema_errors
-        schema_errors.reject! { |_, v| v.empty? }
-
-        # TODO: Is this correct? - Do not apply validations when maybe criteria applies?
-        unless schema_errors[schema_errors_key]&.any? && !maybe_criteria_applies?(value)
-          build_validations
-
-          validations.each do |validation|
-            args = [self, value]
-            validation.call(*args.take(validation.arity))
-          end
-        end
-
-        if self.is_a?(NxtSchema::Node::Collection) && value.respond_to?(:each)
-          value.each_with_index do |item, index|
-            validation_errors[index]&.reject! { |_, v| v.empty? }
-          end
-        end
-
-        validation_errors.reject! { |_, v| v.empty? }
+      def on(condition, value = NxtSchema::MissingInput.new, &block)
+        value = missing_input?(value) ? block : value
+        on_evaluators << OnEvaluator.new(condition: condition, value: value)
 
         self
       end
 
-      def build_validations
-        validations_from_options = Array(options.fetch(:validate, []))
-        self.validations = validations_from_options
-      end
-
-      def schema_errors?
-        schema_errors.reject! { |_, v| v.empty? }
-        schema_errors.any?
-      end
+      def maybe(value = NxtSchema::MissingInput.new, &block)
+        value = missing_input?(value) ? block : value
+        maybe_evaluators << MaybeEvaluator.new(value: value)
 
-      def validation_errors?
-        validation_errors.reject! { |_, v| v.empty? }
-        validation_errors.any?
-      end
-
-      def root?
-        @is_root
+        self
       end
 
-      def leaf?
-        false
-      end
+      def validate(key = NxtSchema::MissingInput.new, *args, &block)
+        # TODO: This does not really work with all kinds of chaining combinations yet!
 
-      def valid?
-        raise SchemaNotAppliedError, 'Schema was not applied yet' unless applied?
+        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
 
-        validation_errors.empty?
-      end
+        register_validator(validator)
 
-      def add_validators(validator)
-        options[:validate] ||= []
-        options[:validate] = Array(options.fetch(:validate, []))
-        options[:validate] << validator
-      end
-
-      def validator(key, *args)
-        Validators::Registry::VALIDATORS.resolve(key).new(*args).build
+        self
       end
 
       def validate_with(&block)
-        add_validators(
-          ->(node) { NxtSchema::Node::ValidateWithProxy.new(node).validate(&block) }
-        )
+        proxy = ->(node) { NxtSchema::Validator::ValidateWithProxy.new(node).validate(&block) }
+        register_validator(proxy)
       end
 
       private
 
-      def register_node(current_context = context)
-        return if all_nodes.key?(object_id)
+      attr_writer :path, :meta, :context, :on_evaluators, :maybe_evaluators
 
-        self.context = current_context
-        all_nodes[object_id] = self
+      def validator(key, *args)
+        Validators::REGISTRY.resolve!(key).new(*args).build
       end
 
-      def applied?
-        @applied
+      def register_validator(validator)
+        validations << validator
       end
 
-      def mark_as_applied
-        self.applied = true
+      def resolve_type(name_or_type)
+        @type = root_node.send(:type_resolver).resolve(type_system, name_or_type)
       end
 
-      def add_schema_error(error, index = schema_errors_key)
-        schema_errors[index] ||= []
-        schema_errors[index] << error
-
-        add_error(error, index)
+      def resolve_type_system
+        @type_system = TypeSystemResolver.new(node: self).call
       end
 
-      def maybe_criteria_applies?(value)
-        @maybe_criteria_applies ||= begin
-          options.key?(:maybe) && MaybeEvaluator.new(self, options.fetch(:maybe), value).call
+      def type_resolver
+        @type_resolver ||= begin
+          root_node? ? TypeResolver.new : (raise NoMethodError, 'type_resolver is only available on root node')
         end
       end
 
-      def self_without_empty_schema_errors
-        schema_errors.reject! { |_, v| v.empty? }
-        validate_all_nodes if root?
-        self.errors = flat_validation_errors(validation_errors, name)
-        self
+      def application_class
+        @application_class ||= "NxtSchema::Application::#{self.class.name.demodulize}".constantize
       end
 
-      def flat_validation_errors(errors, namespace, acc = {})
-        errors.each_with_object(acc) do |(key, val), acc|
-          current_namespace = [namespace, key].reject { |namespace| namespace == schema_errors_key }.compact.join('.')
-
-          if val.is_a?(::Hash)
-            flat_validation_errors(val, current_namespace, acc)
-          else
-            acc[current_namespace] ||= []
-            acc[current_namespace] += Array(val)
-          end
+      def configure(&block)
+        if block.arity == 1
+          block.call(self)
+        else
+          instance_exec(&block)
         end
       end
 
-      def name_from_index
-        if parent_node
-          if parent_node.is_a?(NxtSchema::Node::Collection)
-            size + 1
-          else
-            raise ArgumentError, "Nodes with parent_node: #{parent_node} cannot be anonymous"
-          end
-        else
-          :root
+      def resolve_additional_keys_strategy
+        @additional_keys_strategy = options.fetch(:additional_keys) do
+          parent_node&.send(:additional_keys_strategy) || :allow
         end
       end
 
-      def evaluate_block(block)
-        if block.arity.zero?
-          instance_exec(&block)
+      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
-          evaluator_args = [self, value]
-          block.call(*evaluator_args.take(block.arity))
+          @optional = optional
         end
       end
 
-      def resolve_type_system
-        type_system = options.fetch(:type_system) { parent_node&.type_system }
+      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
 
-        self.type_system = if type_system.is_a?(Module)
-          type_system
-        elsif type_system.is_a?(Symbol) || type_system.is_a?(String)
-          "NxtSchema::Types::#{type_system.to_s.classify}".constantize
-        else
-          NxtSchema::Types
-        end
+        @omnipresent = omnipresent
       end
 
-      def resolve_additional_keys_strategy
-        options.fetch(:additional_keys) { parent_node&.send(:resolve_additional_keys_strategy) || :ignore }
+      def resolve_path
+        self.path = root_node? ? name : "#{parent_node.path}.#{name}"
       end
 
-      def type_resolver
-        @type_resolver ||= begin
-          if root?
-            TypeResolver.new
-          else
-            raise NoMethodError, 'type_resolver is only available on root node'
-          end
-        end
+      def resolve_context
+        self.context = options.fetch(:context) { parent_node&.send(:context) }
+      end
+
+      def missing_input?(value)
+        value.is_a? MissingInput
       end
 
-      def coerce_value(value)
-        type[value]
+      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
       end
     end
   end