nxt_schema 1.0.0 → 1.0.1

data/lib/nxt_schema/version.rb

@@ -1,3 +1,3 @@
 module NxtSchema
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nxt_schema
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Andreas Robecke
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-11-23 00:00:00.000000000 Z
+date: 2020-12-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -155,32 +155,32 @@ files:
 - bin/console
 - bin/setup
 - lib/nxt_schema.rb
-- lib/nxt_schema/application.rb
-- lib/nxt_schema/application/any_of.rb
-- lib/nxt_schema/application/base.rb
-- lib/nxt_schema/application/collection.rb
-- lib/nxt_schema/application/error_store.rb
-- lib/nxt_schema/application/errors/schema_error.rb
-- lib/nxt_schema/application/errors/validation_error.rb
-- lib/nxt_schema/application/leaf.rb
-- lib/nxt_schema/application/schema.rb
 - lib/nxt_schema/callable.rb
 - lib/nxt_schema/dsl.rb
 - lib/nxt_schema/error.rb
 - lib/nxt_schema/errors/invalid.rb
 - lib/nxt_schema/errors/invalid_options.rb
 - lib/nxt_schema/missing_input.rb
+- lib/nxt_schema/node.rb
 - lib/nxt_schema/node/any_of.rb
 - lib/nxt_schema/node/base.rb
 - lib/nxt_schema/node/collection.rb
-- lib/nxt_schema/node/has_sub_nodes.rb
+- lib/nxt_schema/node/error_store.rb
+- lib/nxt_schema/node/errors/schema_error.rb
+- lib/nxt_schema/node/errors/validation_error.rb
 - lib/nxt_schema/node/leaf.rb
-- lib/nxt_schema/node/maybe_evaluator.rb
-- lib/nxt_schema/node/on_evaluator.rb
 - lib/nxt_schema/node/schema.rb
-- lib/nxt_schema/node/sub_nodes.rb
-- lib/nxt_schema/node/type_resolver.rb
-- lib/nxt_schema/node/type_system_resolver.rb
+- lib/nxt_schema/template/any_of.rb
+- lib/nxt_schema/template/base.rb
+- lib/nxt_schema/template/collection.rb
+- lib/nxt_schema/template/has_sub_nodes.rb
+- lib/nxt_schema/template/leaf.rb
+- lib/nxt_schema/template/maybe_evaluator.rb
+- lib/nxt_schema/template/on_evaluator.rb
+- lib/nxt_schema/template/schema.rb
+- lib/nxt_schema/template/sub_nodes.rb
+- lib/nxt_schema/template/type_resolver.rb
+- lib/nxt_schema/template/type_system_resolver.rb
 - lib/nxt_schema/types.rb
 - lib/nxt_schema/validators/attribute.rb
 - lib/nxt_schema/validators/equal_to.rb

data/lib/nxt_schema/application/any_of.rb

@@ -1,40 +0,0 @@
-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

@@ -1,116 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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/leaf.rb

@@ -1,15 +0,0 @@
-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

data/lib/nxt_schema/application/schema.rb

@@ -1,114 +0,0 @@
-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