nxt_schema 0.1.0 → 1.0.2

data/lib/nxt_schema/registry.rb

@@ -1,85 +1,23 @@
 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}"
+  module Registry
+    module ClassMethods
+      def schemas
+        @schemas ||= NxtSchema::Registry::Proxy.new(self)
       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
+      def inherited(subclass)
+        schemas.each do |key, schema|
+          subclass.schemas.register(key, schema)
         end
-      end
-    end
-
-    def namespaced_key_parts(key)
-      key.downcase.split(namespace_separator)
-    end
 
-    def flat_key(key)
-      namespaced_key_parts(key).last
+        super
+      end
     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 self.included(base)
+      base.extend(ClassMethods)
 
-    def to_s
-      identifier = 'NxtSchema::Registry'
-      identifier << "#{namespace_separator}#{namespace}" unless namespace.blank?
-      identifier
+      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/any_of.rb

@@ -0,0 +1,50 @@
+module NxtSchema
+  module Template
+    class AnyOf < Base
+      include HasSubNodes
+
+      def initialize(name:, type: nil, parent_node:, **options, &block)
+        super
+        ensure_sub_nodes_present
+      end
+
+      def collection(name = sub_nodes.count, type = NxtSchema::Template::Collection::DEFAULT_TYPE, **options, &block)
+        super
+      end
+
+      def schema(name = sub_nodes.count, type = NxtSchema::Template::Schema::DEFAULT_TYPE, **options, &block)
+        super
+      end
+
+      def node(name = sub_nodes.count, node_or_type_of_node = nil, **options, &block)
+        super
+      end
+
+      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/template/base.rb

@@ -0,0 +1,220 @@
+module NxtSchema
+  module Template
+    class Base
+      def initialize(name:, type:, parent_node:, **options, &block)
+        resolve_name(name)
+
+        @parent_node = parent_node
+        @options = options
+        @is_root_node = parent_node.nil?
+        @root_node = parent_node.nil? ? self : parent_node.root_node
+        @path = resolve_path
+        @on_evaluators = []
+        @maybe_evaluators = []
+        @validations = []
+        @configuration = block
+
+        resolve_key_transformer
+        resolve_context
+        resolve_optional_option
+        resolve_omnipresent_option
+        resolve_type_system
+        resolve_type(type)
+        resolve_additional_keys_strategy
+        node_class # memoize
+        configure(&block) if block_given?
+      end
+
+      attr_accessor :name,
+        :parent_node,
+        :options,
+        :type,
+        :root_node,
+        :additional_keys_strategy
+
+      attr_reader :type_system,
+        :path,
+        :context,
+        :meta,
+        :on_evaluators,
+        :maybe_evaluators,
+        :validations,
+        :configuration,
+        :key_transformer
+
+      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: 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) if result.errors.any?
+
+        result.output
+      end
+
+      def build_node(input: Undefined.new, context: self.context, parent: nil, error_key: nil)
+        node_class.new(
+          node: self,
+          input: input,
+          parent: parent,
+          context: context,
+          error_key: error_key
+        )
+      end
+
+      def root_node?
+        @is_root_node
+      end
+
+      def optional?
+        @optional
+      end
+
+      def omnipresent?
+        @omnipresent
+      end
+
+      def default(value = NxtSchema::Undefined.new, &block)
+        value = missing_input?(value) ? block : value
+        condition = ->(input) { missing_input?(input) || input.nil? }
+        on(condition, value)
+
+        self
+      end
+
+      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::Undefined.new, &block)
+        value = missing_input?(value) ? block : value
+        maybe_evaluators << MaybeEvaluator.new(value: value)
+
+        self
+      end
+
+      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::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)
+
+        self
+      end
+
+      def validate_with(&block)
+        proxy = ->(node) { NxtSchema::Validator::ValidateWithProxy.new(node).validate(&block) }
+        register_validator(proxy)
+      end
+
+      private
+
+      attr_writer :path, :meta, :context, :on_evaluators, :maybe_evaluators
+
+      def validator(key, *args)
+        Validators::REGISTRY.resolve!(key).new(*args).build
+      end
+
+      def register_validator(validator)
+        validations << validator
+      end
+
+      def resolve_type(name_or_type)
+        @type = root_node.send(:type_resolver).resolve(type_system, name_or_type)
+      end
+
+      def resolve_type_system
+        @type_system = TypeSystemResolver.new(node: self).call
+      end
+
+      def type_resolver
+        @type_resolver ||= begin
+          root_node? ? TypeResolver.new : (raise NoMethodError, 'type_resolver is only available on root node')
+        end
+      end
+
+      def node_class
+        @node_class ||= "NxtSchema::Node::#{self.class.name.demodulize}".constantize
+      end
+
+      def configure(&block)
+        if block.arity == 1
+          block.call(self)
+        else
+          instance_exec(&block)
+        end
+      end
+
+      def resolve_additional_keys_strategy
+        @additional_keys_strategy = options.fetch(:additional_keys) do
+          parent_node&.send(:additional_keys_strategy) || :allow
+        end
+      end
+
+      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
+          @optional = optional
+        end
+      end
+
+      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
+
+        @omnipresent = omnipresent
+      end
+
+      def resolve_path
+        self.path = root_node? ? name : "#{parent_node.path}.#{name}"
+      end
+
+      def resolve_context
+        self.context = options.fetch(:context) { parent_node&.send(:context) }
+      end
+
+      def missing_input?(value)
+        value.is_a? Undefined
+      end
+
+      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
+end

data/lib/nxt_schema/template/collection.rb

@@ -0,0 +1,23 @@
+module NxtSchema
+  module Template
+    class Collection < Template::Base
+      include HasSubNodes
+
+      DEFAULT_TYPE = NxtSchema::Types::Strict::Array
+
+      def initialize(name:, type: DEFAULT_TYPE, parent_node:, **options, &block)
+        super
+        ensure_sub_nodes_present
+      end
+
+      private
+
+      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?
+
+        super
+      end
+    end
+  end
+end

data/lib/nxt_schema/template/has_sub_nodes.rb

@@ -0,0 +1,87 @@
+module NxtSchema
+  module Template
+    module HasSubNodes
+      def collection(name, type = NxtSchema::Template::Collection::DEFAULT_TYPE, **options, &block)
+        node = NxtSchema::Template::Collection.new(
+          name: name,
+          type: type,
+          parent_node: self,
+          **options,
+          &block
+        )
+
+        add_sub_node(node)
+      end
+
+      alias nodes collection
+
+      def schema(name, type = NxtSchema::Template::Schema::DEFAULT_TYPE, **options, &block)
+        node = NxtSchema::Template::Schema.new(
+          name: name,
+          type: type,
+          parent_node: self,
+          **options,
+          &block
+        )
+
+        add_sub_node(node)
+      end
+
+      def any_of(name, **options, &block)
+        node = NxtSchema::Template::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::Template::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),
+            &node_or_type_of_node.configuration
+          )
+        else
+          NxtSchema::Template::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 ||= Template::SubNodes.new
+      end
+
+      def [](key)
+        sub_nodes[key]
+      end
+
+      def ensure_sub_nodes_present
+        return if sub_nodes.any?
+
+        raise NxtSchema::Errors::InvalidOptions, "#{self.class.name} must have sub nodes"
+      end
+    end
+  end
+end