nxt_schema 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d1aba2ccbd135921f48a84de3e51d11b0592522b8d9e9e9fd3a5ff188117ffae
-  data.tar.gz: 1c67ef1beda4a6e6a33bd67bc7a9294c7bfbc14ccf72be3b621748212192c8c0
+  metadata.gz: a4076ec4518cc51176684f4bb04fca5bcff3554835016f57cce322debf3e9b8c
+  data.tar.gz: 336acbce68af2023b714b2b023d732575138968279efebc74b984b51ff33de13
 SHA512:
-  metadata.gz: 34cd6cdacddb969ac3532dc8f52150dc16e8be80b12bf8ceaec9cd147df93547cc02e655eaff1d05eee359b660e1143187adb704fbac91a3f09d4a18ebd28087
-  data.tar.gz: 5f77d02ed8b601aa255a4b9be082c48f1da0e7fa157561547e7c99a726c8a9d2f34a4c76be78cbd60ec529bce719e0b06e42d6645cbbe18e65facf7de9e7a1fc
+  metadata.gz: 4947f05400dd492a8bed83ae2b0c42110c75ebd6fd495bdcdcef10871f7715c6d69797ab95291006df759945551c0f92869e29f5b03f0343af49f4bcf6aa3497
+  data.tar.gz: 8ed842b8144aacd64f880e3ff7c74c64a9ae218f598522a60f26fb7a0aa2829fb3deaaf93ea0b8600a6346adb6f921d2e56e2249d1ab18e4b5c6427d25bf8759

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    nxt_schema (1.0.1)
+    nxt_schema (1.0.2)
       activesupport
       dry-types
       nxt_init
@@ -10,47 +10,43 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (6.0.3.4)
+    activesupport (6.1.3)
       concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (>= 0.7, < 2)
-      minitest (~> 5.1)
-      tzinfo (~> 1.1)
-      zeitwerk (~> 2.2, >= 2.2.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
     coderay (1.1.3)
-    concurrent-ruby (1.1.7)
+    concurrent-ruby (1.1.8)
     diff-lcs (1.4.4)
-    dry-configurable (0.11.6)
+    dry-configurable (0.12.1)
       concurrent-ruby (~> 1.0)
-      dry-core (~> 0.4, >= 0.4.7)
-      dry-equalizer (~> 0.2)
+      dry-core (~> 0.5, >= 0.5.0)
     dry-container (0.7.2)
       concurrent-ruby (~> 1.0)
       dry-configurable (~> 0.1, >= 0.1.3)
-    dry-core (0.4.10)
+    dry-core (0.5.0)
       concurrent-ruby (~> 1.0)
-    dry-equalizer (0.3.0)
     dry-inflector (0.2.0)
-    dry-logic (1.0.8)
+    dry-logic (1.1.0)
       concurrent-ruby (~> 1.0)
-      dry-core (~> 0.2)
-      dry-equalizer (~> 0.2)
-    dry-types (1.4.0)
+      dry-core (~> 0.5, >= 0.5)
+    dry-types (1.5.1)
       concurrent-ruby (~> 1.0)
       dry-container (~> 0.3)
-      dry-core (~> 0.4, >= 0.4.4)
-      dry-equalizer (~> 0.3)
+      dry-core (~> 0.5, >= 0.5)
       dry-inflector (~> 0.1, >= 0.1.2)
       dry-logic (~> 1.0, >= 1.0.2)
     hirb (0.7.3)
-    i18n (1.8.5)
+    i18n (1.8.9)
       concurrent-ruby (~> 1.0)
     method_profiler (2.0.1)
       hirb (>= 0.6.0)
     method_source (1.0.0)
-    minitest (5.14.2)
+    minitest (5.14.4)
     nxt_init (0.1.5)
       activesupport
-    nxt_registry (0.3.3)
+    nxt_registry (0.3.9)
       activesupport
     pry (0.13.1)
       coderay (~> 1.1)
@@ -69,9 +65,8 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.10.0)
     rspec-support (3.10.0)
-    thread_safe (0.3.6)
-    tzinfo (1.2.8)
-      thread_safe (~> 0.1)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
     zeitwerk (2.4.2)
 
 PLATFORMS

data/README.md

@@ -128,7 +128,7 @@ end
 
 result = schema.apply(input: {})
 result.errors # => {}
-result.output # => {:email=>NxtSchema::MissingInput}
+result.output # => {:email=>NxtSchema::Undefined}
 ```
 
 ```ruby
@@ -225,10 +225,42 @@ This is suitable to validate and coerce your query params.
 NxtSchema.params do
   required(:effective_at, :DateTime) # would resolve to Types::Params::DateTime 
   required(:test, :String) # The :String will resolve to NxtSchema::Types::Nominal::String
-  required(:advanced, NxtSchema::Types::Params::Bool) # long version of required(:advanced, :Bool)
+  required(:advanced, NxtSchema::Types::Registry::Bool) # long version of required(:advanced, :Bool)
 end
 ```
 
+#### NxtSchema::Registry
+
+To make use of NxtSchema.params in your controller you can simply include the `NxtSchema::Registry` to easily register 
+and apply schemas: 
+
+```ruby
+class UsersController < ApplicationController
+  include NxtSchema::Registry
+  
+  # register the schema for the :create action
+  schemas.register(
+    :create, 
+    NxtSchema.params do
+      required(:first_name, :String)
+      required(:last_name, :String)
+    end
+  )
+  
+  def create
+    User.create!(**create_params) 
+  end
+  
+  private
+
+  def create_params
+    # apply the registered schema  
+    schemas.apply!(:create, params.fetch(:user))
+  end
+end
+
+```
+
 #### Custom types
 
 You can also register custom types. In order to check out all the cool things you can do with dry types you should 
@@ -486,16 +518,5 @@ The gem is available as open source under the terms of the [MIT License](https:/
     --> Would be cool to register things for the schema only
     --> Would be cool if this was extendable 
 - Do we need all off in order to combine multiple schemas?
-- Think about a good implementation of params framework for controllers
-
-```ruby
-PARAMS = NxtRegistry::Registry.new do
-      register(:create) do
-        NxtSchema.params do
-
-        end
-      end
-    end
-
-PARAMS.resolve(:create).apply(input: params)
-```
+- Allow custom errors
+- Spec inheritance of params

data/lib/nxt_schema.rb

@@ -8,10 +8,11 @@ require 'yaml'
 require_relative 'nxt_schema/types'
 require_relative 'nxt_schema/callable'
 require_relative 'nxt_schema/node'
-require_relative 'nxt_schema/missing_input'
+require_relative 'nxt_schema/undefined'
 require_relative 'nxt_schema/error'
 require_relative 'nxt_schema/errors/invalid'
 require_relative 'nxt_schema/errors/invalid_options'
+require_relative 'nxt_schema/errors/coercion_error'
 
 require_relative 'nxt_schema/validators/registry'
 require_relative 'nxt_schema/validators/validate_with_proxy'
@@ -52,6 +53,8 @@ require_relative 'nxt_schema/node/leaf'
 require_relative 'nxt_schema/node/collection'
 require_relative 'nxt_schema/node/schema'
 require_relative 'nxt_schema/dsl'
+require_relative 'nxt_schema/registry/proxy'
+require_relative 'nxt_schema/registry'
 
 module NxtSchema
   extend Dsl
@@ -65,7 +68,7 @@ module NxtSchema
   end
 
   def register_type(key, type)
-    NxtSchema::Types.const_set(key.to_s, type)
+    NxtSchema::Types.registry(:types).register(key, type)
   end
 
   # Load default messages

data/lib/nxt_schema/errors/coercion_error.rb

@@ -0,0 +1,6 @@
+module NxtSchema
+  module Errors
+    class CoercionError < Error
+    end
+  end
+end

data/lib/nxt_schema/node/any_of.rb

@@ -2,17 +2,17 @@ module NxtSchema
   module Node
     class AnyOf < Node::Base
       def valid?
-        valid_application.present?
+        valid_node.present?
       end
 
       def call
-        child_applications.map(&:call)
+        child_nodes.map(&:call)
 
         if valid?
-          self.output = valid_application.output
+          self.output = valid_node.output
         else
-          child_applications.each do |application|
-            merge_errors(application)
+          child_nodes.each do |node|
+            merge_errors(node)
           end
         end
 
@@ -21,14 +21,14 @@ module NxtSchema
 
       private
 
-      delegate :[], to: :child_applications
+      delegate :[], to: :child_nodes
 
-      def valid_application
-        child_applications.find(&:valid?)
+      def valid_node
+        child_nodes.find(&:valid?)
       end
 
-      def child_applications
-        @child_applications ||= nodes.map { |node| node.build_application(input: input, context: context, parent: self) }
+      def child_nodes
+        @child_nodes ||= nodes.map { |node| node.build_node(input: input, context: context, parent: self) }
       end
 
       def nodes

data/lib/nxt_schema/node/base.rb

@@ -1,7 +1,7 @@
 module NxtSchema
   module Node
     class Base
-      def initialize(node:, input: MissingInput.new, parent:, context:, error_key:)
+      def initialize(node:, input: Undefined.new, parent:, context:, error_key:)
         @node = node
         @input = input
         @parent = parent
@@ -44,8 +44,8 @@ module NxtSchema
         errors.add_schema_error(message: error)
       end
 
-      def merge_errors(application)
-        errors.merge_errors(application)
+      def merge_errors(node)
+        errors.merge_errors(node)
       end
 
       def run_validations
@@ -71,10 +71,10 @@ module NxtSchema
       attr_writer :coerced, :root
 
       def coerce_input
-        output = input.is_a?(MissingInput) && node.omnipresent? ? input : node.type[input]
+        output = input.is_a?(Undefined) && node.omnipresent? ? input : node.type.call(input)
         self.output = output
 
-      rescue Dry::Types::CoercionError => error
+      rescue Dry::Types::CoercionError, NxtSchema::Errors::CoercionError => error
         add_schema_error(error.message)
       end
 

data/lib/nxt_schema/node/collection.rb

@@ -3,20 +3,20 @@ module NxtSchema
     class Collection < Node::Base
       def call
         apply_on_evaluators
-        child_applications # build applications here so we can access them even when invalid
+        child_nodes # build nodes 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
+        child_nodes.each_with_index do |item, index|
+          child_node = item.call
 
-          if !current_application.valid?
-            merge_errors(current_application)
+          if !child_node.valid?
+            merge_errors(child_node)
           else
-            output[index] = current_application.output
+            output[index] = child_node.output
           end
         end
 
@@ -26,7 +26,7 @@ module NxtSchema
         self
       end
 
-      delegate :[], to: :child_applications
+      delegate :[], to: :child_nodes
 
       private
 
@@ -34,19 +34,19 @@ module NxtSchema
         add_schema_error('is not allowed to be empty') if input.blank? && !maybe_evaluator_applies?
       end
 
-      def child_applications
-        @child_applications ||= begin
+      def child_nodes
+        @child_nodes ||= begin
           return [] unless input.respond_to?(:each_with_index)
 
           input.each_with_index.map do |item, index|
-            build_child_application(item, index)
+            build_child_node(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)
+      def build_child_node(item, error_key)
+        sub_node.build_node(input: item, context: context, parent: self, error_key: error_key)
       end
 
       def sub_node

data/lib/nxt_schema/node/error_store.rb

@@ -1,18 +1,18 @@
 module NxtSchema
   module Node
     class ErrorStore < ::Hash
-      def initialize(application)
+      def initialize(node)
         super()
-        @application = application
+        @node = node
       end
 
-      attr_reader :application
+      attr_reader :node
 
       def add_schema_error(message:)
         add_error(
-          application,
+          node,
           NxtSchema::Node::Errors::SchemaError.new(
-            application: application,
+            node: node,
             message: message
           )
         )
@@ -20,38 +20,22 @@ module NxtSchema
 
       def add_validation_error(message:)
         add_error(
-          application,
+          node,
           NxtSchema::Node::Errors::ValidationError.new(
-            application: application,
+            node: node,
             message: message
           )
         )
       end
 
-      def merge_errors(application)
-        merge!(application.errors)
+      def merge_errors(node)
+        merge!(node.errors)
       end
 
-      def add_error(application, error)
-        self[application.error_key] ||= []
-        self[application.error_key] << error
+      def add_error(node, error)
+        self[node.error_key] ||= []
+        self[node.error_key] << error
       end
-
-      # def schema_errors
-      #   inject({}) do |acc, (k, v)|
-      #     errors = v.select { |e| e.is_a?(NxtSchema::Node::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::Node::Errors::ValidationError) }
-      #     acc[k] = errors if errors.any?
-      #     acc
-      #   end
-      # end
     end
   end
 end

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

@@ -2,12 +2,12 @@ module NxtSchema
   module Node
     module Errors
       class SchemaError < ::String
-        def initialize(application:, message:)
+        def initialize(node:, message:)
           super(message)
-          @application = application
+          @node = node
         end
 
-        attr_reader :application
+        attr_reader :node
       end
     end
   end

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

@@ -2,12 +2,12 @@ module NxtSchema
   module Node
     module Errors
       class ValidationError < ::String
-        def initialize(application:, message:)
+        def initialize(node:, message:)
           super(message)
-          @application = application
+          @node = node
         end
 
-        attr_reader :application
+        attr_reader :node
       end
     end
   end

data/lib/nxt_schema/node/schema.rb

@@ -3,7 +3,7 @@ module NxtSchema
     class Schema < Node::Base
       def call
         apply_on_evaluators
-        child_applications # build applications here so we can access them even when invalid
+        child_nodes # build nodes here so we can access them even when invalid
         return self if maybe_evaluator_applies?
 
         coerce_input
@@ -12,13 +12,13 @@ module NxtSchema
         flag_missing_keys
         apply_additional_keys_strategy
 
-        child_applications.each do |key, child|
-          current_application = child.call
+        child_nodes.each do |key, child|
+          current_node = child.call
 
-          if !current_application.valid?
-            merge_errors(current_application)
+          if !current_node.valid?
+            merge_errors(current_node)
           else
-            output[key] = current_application.output
+            output[key] = current_node.output
           end
         end
 
@@ -28,7 +28,7 @@ module NxtSchema
         self
       end
 
-      delegate :[], to: :child_applications
+      delegate :[], to: :child_nodes
 
       private
 
@@ -88,22 +88,22 @@ module NxtSchema
         node.additional_keys_strategy == :restrict
       end
 
-      def child_applications
-        @child_applications ||= begin
+      def child_nodes
+        @child_nodes ||= begin
           keys.inject({}) do |acc, key|
-            child_application = build_child_application(key)
-            acc[key] = child_application if child_application.present?
+            child_node = build_child_node(key)
+            acc[key] = child_node if child_node.present?
             acc
           end
         end
       end
 
-      def build_child_application(key)
+      def build_child_node(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)
+        value = input_has_key?(input, key) ? input[key] : Undefined.new
+        sub_node.build_node(input: value, context: context, parent: self)
       end
 
       def input_has_key?(input, key)

data/lib/nxt_schema/registry.rb

@@ -0,0 +1,23 @@
+module NxtSchema
+  module Registry
+    module ClassMethods
+      def schemas
+        @schemas ||= NxtSchema::Registry::Proxy.new(self)
+      end
+
+      def inherited(subclass)
+        schemas.each do |key, schema|
+          subclass.schemas.register(key, schema)
+        end
+
+        super
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+
+      delegate :schemas, to: :class
+    end
+  end
+end

data/lib/nxt_schema/registry/proxy.rb

@@ -0,0 +1,21 @@
+module NxtSchema
+  module Registry
+    class Proxy
+      def initialize(namespace)
+        @registry = ::NxtRegistry::Registry.new(namespace, call: false)
+      end
+
+      attr_reader :registry
+
+      delegate_missing_to :registry
+
+      def apply(key, input)
+        resolve!(key).apply(input: input)
+      end
+
+      def apply!(key, input)
+        resolve!(key).apply!(input: input)
+      end
+    end
+  end
+end

data/lib/nxt_schema/template/base.rb

@@ -21,40 +21,42 @@ module NxtSchema
         resolve_type_system
         resolve_type(type)
         resolve_additional_keys_strategy
-        application_class # memoize
+        node_class # memoize
         configure(&block) if block_given?
       end
 
       attr_accessor :name,
-                    :parent_node,
-                    :options,
-                    :type,
-                    :root_node,
-                    :additional_keys_strategy
+        :parent_node,
+        :options,
+        :type,
+        :root_node,
+        :additional_keys_strategy
 
       attr_reader :type_system,
-                  :path,
-                  :context,
-                  :meta,
-                  :on_evaluators,
-                  :maybe_evaluators,
-                  :validations,
-                  :configuration,
-                  :key_transformer
+        :path,
+        :context,
+        :meta,
+        :on_evaluators,
+        :maybe_evaluators,
+        :validations,
+        :configuration,
+        :key_transformer
 
-      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
+      def apply(input: Undefined.new, context: self.context, parent: nil, error_key: nil)
+        build_node(input: input, context: context, parent: parent, error_key: error_key).call
       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 apply!(input: Undefined.new, context: self.context, parent: nil, error_key: nil)
+        result = build_node(input: input, context: context, parent: parent, error_key: error_key).call
+        return result if parent
 
-        raise NxtSchema::Errors::Invalid.new(result)
+        raise NxtSchema::Errors::Invalid.new(result) if result.errors.any?
+
+        result.output
       end
 
-      def build_application(input: MissingInput.new, context: self.context, parent: nil, error_key: nil)
-        application_class.new(
+      def build_node(input: Undefined.new, context: self.context, parent: nil, error_key: nil)
+        node_class.new(
           node: self,
           input: input,
           parent: parent,
@@ -75,7 +77,7 @@ module NxtSchema
         @omnipresent
       end
 
-      def default(value = NxtSchema::MissingInput.new, &block)
+      def default(value = NxtSchema::Undefined.new, &block)
         value = missing_input?(value) ? block : value
         condition = ->(input) { missing_input?(input) || input.nil? }
         on(condition, value)
@@ -83,36 +85,36 @@ module NxtSchema
         self
       end
 
-      def on(condition, value = NxtSchema::MissingInput.new, &block)
+      def on(condition, value = NxtSchema::Undefined.new, &block)
         value = missing_input?(value) ? block : value
         on_evaluators << OnEvaluator.new(condition: condition, value: value)
 
         self
       end
 
-      def maybe(value = NxtSchema::MissingInput.new, &block)
+      def maybe(value = NxtSchema::Undefined.new, &block)
         value = missing_input?(value) ? block : value
         maybe_evaluators << MaybeEvaluator.new(value: value)
 
         self
       end
 
-      def validate(key = NxtSchema::MissingInput.new, *args, &block)
+      def validate(key = NxtSchema::Undefined.new, *args, &block)
         # TODO: This does not really work with all kinds of chaining combinations yet!
 
         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
+          validator(key, *args)
+        elsif key.respond_to?(:call)
+          key
+        elsif block_given?
+          if key.is_a?(NxtSchema::Undefined)
+            block
+          else
+            configure(&block)
+          end
+        else
+          raise ArgumentError, "Don't know how to resolve validator from: #{key} with: #{args} #{block}"
+        end
 
         register_validator(validator)
 
@@ -150,8 +152,8 @@ module NxtSchema
         end
       end
 
-      def application_class
-        @application_class ||= "NxtSchema::Node::#{self.class.name.demodulize}".constantize
+      def node_class
+        @node_class ||= "NxtSchema::Node::#{self.class.name.demodulize}".constantize
       end
 
       def configure(&block)
@@ -201,7 +203,7 @@ module NxtSchema
       end
 
       def missing_input?(value)
-        value.is_a? MissingInput
+        value.is_a? Undefined
       end
 
       def resolve_key_transformer

data/lib/nxt_schema/template/type_resolver.rb

@@ -4,21 +4,36 @@ module NxtSchema
       def resolve(type_system, type)
         @resolve ||= {}
         @resolve[type] ||= begin
-          if type.is_a?(Dry::Types::Type)
+          if type.is_a?(Symbol)
+            resolve_type_from_symbol(type, type_system)
+          elsif type.respond_to?(:call)
             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
+            raise_type_not_resolvable_error(type)
           end
+        rescue NxtRegistry::Errors::KeyNotRegisteredError => error
+          raise_type_not_resolvable_error(type)
         end
       end
+
+      private
+
+      def resolve_type_from_symbol(type, type_system)
+        classified_type = type.to_s.classify
+
+        return type_system.const_get(classified_type) if type_defined_in_type_system?(type, type_system)
+        return NxtSchema::Types::Nominal.const_get(classified_type) if type_defined_in_type_system?(type, NxtSchema::Types::Nominal)
+
+        NxtSchema::Types.registry(:types).resolve!(type)
+      end
+
+      def type_defined_in_type_system?(type, type_system)
+        type_system.constants.include?(type)
+      end
+
+      def raise_type_not_resolvable_error(type)
+        raise ArgumentError, "Can't resolve type: #{type}"
+      end
     end
   end
 end

data/lib/nxt_schema/types.rb

@@ -1,10 +1,13 @@
 module NxtSchema
   module Types
     include Dry.Types()
+    extend NxtRegistry
 
-    StrippedString = Strict::String.constructor(->(string) { string&.strip })
-    LengthyStrippedString = 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]
+    registry(:types, call: false) do
+      register(:StrippedString, Strict::String.constructor(->(string) { string&.strip }))
+      register(:LengthyStrippedString, resolve!(:StrippedString).constrained(min_size: 1))
+      register(:Enum, -> (*values) { Strict::String.enum(*values) })
+      register(:SymbolizedEnum, -> (*values) { Coercible::Symbol.enum(*values) })
+    end
   end
 end

data/lib/nxt_schema/{missing_input.rb → undefined.rb}

@@ -1,5 +1,5 @@
 module NxtSchema
-  class MissingInput
+  class Undefined
     def inspect
       self.class.name
     end

data/lib/nxt_schema/validators/attribute.rb

@@ -12,15 +12,15 @@ module NxtSchema
       # Query any attribute on a value with validator(:attribute, :size, ->(s) { s < 7 })
 
       def build
-        lambda do |application, value|
+        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
-            application.add_error(
+            node.add_error(
               translate_error(
-                application.locale,
+                node.locale,
                 attribute: value,
                 attribute_name: method,
                 value: value.send(method)

data/lib/nxt_schema/validators/equal_to.rb

@@ -12,15 +12,15 @@ module NxtSchema
       # Query for equality validator(:eql, -> { 3 * 3 * 60 })
 
       def build
-        lambda do |application, value|
+        lambda do |node, value|
           expected_value = Callable.new(expectation, nil, value).call
 
           if value == expected_value
             true
           else
-            application.add_error(
+            node.add_error(
               translate_error(
-                application.locale,
+                node.locale,
                 actual: value,
                 expected: expected_value
               )

data/lib/nxt_schema/validators/excluded_in.rb

@@ -9,12 +9,12 @@ module NxtSchema
       attr_reader :target
 
       def build
-        lambda do |application, value|
+        lambda do |node, value|
           if target.exclude?(value)
             true
           else
-            message = translate_error(application.locale, target: target, value: value)
-            application.add_error(message)
+            message = translate_error(node.locale, target: target, value: value)
+            node.add_error(message)
           end
         end
       end

data/lib/nxt_schema/validators/excludes.rb

@@ -9,12 +9,12 @@ module NxtSchema
       attr_reader :target
 
       def build
-        lambda do |application, value|
+        lambda do |node, value|
           if value.exclude?(target)
             true
           else
-            message = translate_error(application.locale, target: target, value: value)
-            application.add_error(message)
+            message = translate_error(node.locale, target: target, value: value)
+            node.add_error(message)
           end
         end
       end

data/lib/nxt_schema/validators/greater_than.rb

@@ -9,12 +9,12 @@ module NxtSchema
       attr_reader :threshold
 
       def build
-        lambda do |application, value|
+        lambda do |node, value|
           if value > threshold
             true
           else
-            message = translate_error(application.locale, value: value, threshold: threshold)
-            application.add_error(message)
+            message = translate_error(node.locale, value: value, threshold: threshold)
+            node.add_error(message)
           end
         end
       end

data/lib/nxt_schema/validators/greater_than_or_equal.rb

@@ -9,12 +9,12 @@ module NxtSchema
       attr_reader :threshold
 
       def build
-        lambda do |application, value|
+        lambda do |node, value|
           if value >= threshold
             true
           else
-            message = translate_error(application.locale, value: value, threshold: threshold)
-            application.add_error(message)
+            message = translate_error(node.locale, value: value, threshold: threshold)
+            node.add_error(message)
           end
         end
       end

data/lib/nxt_schema/validators/included_in.rb

@@ -9,12 +9,12 @@ module NxtSchema
       attr_reader :target
 
       def build
-        lambda do |application, value|
+        lambda do |node, value|
           if target.include?(value)
             true
           else
-            message = translate_error(application.locale, value: value, target: target)
-            application.add_error(message)
+            message = translate_error(node.locale, value: value, target: target)
+            node.add_error(message)
           end
         end
       end

data/lib/nxt_schema/validators/includes.rb

@@ -9,12 +9,12 @@ module NxtSchema
       attr_reader :target
 
       def build
-        lambda do |application, value|
+        lambda do |node, value|
           if value.include?(target)
             true
           else
-            message = translate_error(application.locale, value: value, target: target)
-            application.add_error(message)
+            message = translate_error(coerced?.locale, value: value, target: target)
+            node.add_error(message)
           end
         end
       end

data/lib/nxt_schema/validators/less_than.rb

@@ -9,12 +9,12 @@ module NxtSchema
       attr_reader :threshold
 
       def build
-        lambda do |application, value|
+        lambda do |node, value|
           if value < threshold
             true
           else
-            message = translate_error(application.locale, value: value, threshold: threshold)
-            application.add_error(message)
+            message = translate_error(node.locale, value: value, threshold: threshold)
+            node.add_error(message)
           end
         end
       end

data/lib/nxt_schema/validators/less_than_or_equal.rb

@@ -9,12 +9,12 @@ module NxtSchema
       attr_reader :threshold
 
       def build
-        lambda do |application, value|
+        lambda do |node, value|
           if value <= threshold
             true
           else
-            message = translate_error(application.locale, value: value, threshold: threshold)
-            application.add_error(message)
+            message = translate_error(node.locale, value: value, threshold: threshold)
+            node.add_error(message)
           end
         end
       end

data/lib/nxt_schema/validators/optional_node.rb

@@ -10,20 +10,20 @@ module NxtSchema
       attr_reader :conditional, :missing_key
 
       def build
-        lambda do |application, value|
-          args = [application, value]
+        lambda do |node, value|
+          args = [node, value]
 
           return if conditional.call(*args.take(conditional.arity))
-          return if application.send(:keys).include?(missing_key.to_sym)
+          return if node.send(:keys).include?(missing_key.to_sym)
 
           message = ErrorMessages.resolve(
-            application.locale,
+            node.locale,
             :required_key_missing,
             key: missing_key,
-            target: application.input
+            target: node.input
           )
 
-          application.add_error(message)
+          node.add_error(message)
         end
       end
     end

data/lib/nxt_schema/validators/pattern.rb

@@ -9,12 +9,12 @@ module NxtSchema
       attr_reader :pattern
 
       def build
-        lambda do |application, value|
+        lambda do |node, value|
           if value.match(pattern)
             true
           else
-            message = translate_error(application.locale, value: value, pattern: pattern)
-            application.add_error(message)
+            message = translate_error(node.locale, value: value, pattern: pattern)
+            node.add_error(message)
             false
           end
         end

data/lib/nxt_schema/validators/query.rb

@@ -8,18 +8,18 @@ module NxtSchema
       register_as :query
       attr_reader :method
 
-      # Query a boolean method on you value => application(:test, :String).validate(:query, :good_enough?)
+      # Query a boolean method on you value => node(:test, :String).validate(:query, :good_enough?)
       # => Would be valid if value.good_enough? is truthy
 
       def build
-        lambda do |application, value|
+        lambda do |node, value|
           raise ArgumentError, "#{value} does not respond to query: #{method}" unless value.respond_to?(method)
 
           if value.send(method)
             true
           else
-            message = translate_error(application.locale, value: value, actual: value.send(method), query: method)
-            application.add_error(message)
+            message = translate_error(node.locale, value: value, actual: value.send(method), query: method)
+            node.add_error(message)
           end
         end
       end

data/lib/nxt_schema/validators/validate_with_proxy.rb

@@ -1,14 +1,14 @@
 module NxtSchema
   module Validator
     class ValidateWithProxy
-      def initialize(application)
-        @application = application
+      def initialize(node)
+        @node = node
         @aggregated_errors = []
       end
 
-      attr_reader :application
+      attr_reader :node
 
-      delegate_missing_to :application
+      delegate_missing_to :node
 
       def validate(&block)
         result = instance_exec(&block)
@@ -24,7 +24,7 @@ module NxtSchema
 
       def copy_aggregated_errors_to_node
         aggregated_errors.each do |error|
-          application.add_error(error)
+          node.add_error(error)
         end
       end
 
@@ -33,8 +33,8 @@ module NxtSchema
       attr_reader :aggregated_errors
 
       def validator(key, *args)
-        validator = application.node.send(:validator, key, *args)
-        validator.call(self, application.input)
+        validator = node.node.send(:validator, key, *args)
+        validator.call(self, node.input)
       end
     end
   end

data/lib/nxt_schema/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nxt_schema
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Andreas Robecke
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-12-03 00:00:00.000000000 Z
+date: 2021-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -158,9 +158,9 @@ files:
 - lib/nxt_schema/callable.rb
 - lib/nxt_schema/dsl.rb
 - lib/nxt_schema/error.rb
+- lib/nxt_schema/errors/coercion_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
@@ -170,6 +170,8 @@ files:
 - lib/nxt_schema/node/errors/validation_error.rb
 - lib/nxt_schema/node/leaf.rb
 - lib/nxt_schema/node/schema.rb
+- lib/nxt_schema/registry.rb
+- lib/nxt_schema/registry/proxy.rb
 - lib/nxt_schema/template/any_of.rb
 - lib/nxt_schema/template/base.rb
 - lib/nxt_schema/template/collection.rb
@@ -182,6 +184,7 @@ files:
 - lib/nxt_schema/template/type_resolver.rb
 - lib/nxt_schema/template/type_system_resolver.rb
 - lib/nxt_schema/types.rb
+- lib/nxt_schema/undefined.rb
 - lib/nxt_schema/validators/attribute.rb
 - lib/nxt_schema/validators/equal_to.rb
 - lib/nxt_schema/validators/error_messages.rb