nxt_schema 0.1.2 → 1.0.0

data/lib/nxt_schema/callable_or_value.rb

@@ -1,72 +0,0 @@
-module NxtSchema
-  class CallableOrValue
-    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
-        self.type = :value
-      end
-    end
-
-    def bind(execution_context = nil)
-      self.context = execution_context
-      ensure_context_not_missing
-      self
-    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)
-      return callee if value?
-
-      ensure_context_not_missing
-
-      args = args.take(arity)
-
-      if method?
-        context.send(callee, *args)
-      else
-        context.instance_exec(*args, &callee)
-      end
-    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
-    end
-
-    private
-
-    def proc?
-      type == :proc
-    end
-
-    def method?
-      type == :method
-    end
-
-    def value?
-      type == :value
-    end
-
-    def ensure_context_not_missing
-      return if context
-
-      raise ArgumentError, "Missing context: #{context}"
-    end
-
-    attr_accessor :context, :callee, :type
-  end
-end

data/lib/nxt_schema/error_messages.rb

@@ -1,40 +0,0 @@
-module NxtSchema
-  class ErrorMessages
-    class << self
-      def values
-        @values ||= {}
-      end
-
-      def values=(value)
-        @values = value
-      end
-
-      def load(paths = files)
-        Array(paths).each do |path|
-          new_values = YAML.load(ERB.new(File.read(path)).result).with_indifferent_access
-          self.values = values.deep_merge!(new_values)
-        end
-      end
-
-      def resolve(locale, key, **options)
-        message = begin
-          values.fetch(locale).fetch(key)
-        rescue KeyError
-          raise "Could not resolve error message for #{locale}->#{key}"
-        end
-
-        message % options
-      end
-
-      def files
-        @files ||= begin
-          files = Dir.entries(File.expand_path('../error_messages/', __FILE__)).map do |filename|
-            File.expand_path("../error_messages/#{filename}", __FILE__)
-          end
-
-          files.select { |f| !File.directory? f }
-        end
-      end
-    end
-  end
-end

data/lib/nxt_schema/errors.rb

@@ -1,4 +0,0 @@
-module NxtSchema
-  module Errors
-  end
-end

data/lib/nxt_schema/errors/invalid_options_error.rb

@@ -1,5 +0,0 @@
-module NxtSchema
-  module Errors
-    InvalidOptionsError = Class.new(Error)
-  end
-end

data/lib/nxt_schema/errors/schema_not_applied_error.rb

@@ -1,5 +0,0 @@
-module NxtSchema
-  module Errors
-    SchemaNotAppliedError = Class.new(Error)
-  end
-end

data/lib/nxt_schema/node/constructor.rb

@@ -1,9 +0,0 @@
-module NxtSchema
-  module Node
-    class Constructor < Node::Schema
-      def initialize(name:, type: NxtSchema::Types::Constructor(::OpenStruct), parent_node:, **options, &block)
-        super
-      end
-    end
-  end
-end

data/lib/nxt_schema/node/default_value_evaluator.rb

@@ -1,20 +0,0 @@
-module NxtSchema
-  module Node
-    class DefaultValueEvaluator
-      def initialize(node, evaluator_or_value)
-        @node = node
-        @evaluator_or_value = evaluator_or_value
-      end
-
-      attr_reader :node, :evaluator_or_value
-
-      def call
-        if evaluator_or_value.respond_to?(:call)
-          Callable.new(evaluator_or_value).call(node)
-        else
-          evaluator_or_value
-        end
-      end
-    end
-  end
-end

data/lib/nxt_schema/node/error.rb

@@ -1,13 +0,0 @@
-module NxtSchema
-  module Node
-    class Error
-      def initialize(path, value, message)
-        @path = path
-        @value = value
-        @message = message
-      end
-
-      attr_reader :path, :value, :message
-    end
-  end
-end

data/lib/nxt_schema/node/has_subnodes.rb

@@ -1,97 +0,0 @@
-require_relative 'schema'
-require_relative 'collection'
-require_relative 'constructor'
-require_relative 'leaf'
-
-module NxtSchema
-  module Node
-    module HasSubNodes
-      attr_accessor :template_store, :value_store
-
-      # TODO: Would be cool if we could register custom node types!
-      def node(name, type_or_node, **options, &block)
-        child_node = case type_or_node.to_s.to_sym
-        when :Schema
-          NxtSchema::Node::Schema.new(name: name, type: NxtSchema::Types::Strict::Hash, parent_node: self, **options, &block)
-        when :Collection
-          NxtSchema::Node::Collection.new(name: name, type: NxtSchema::Types::Strict::Array, parent_node: self, **options, &block)
-        when :Struct
-          NxtSchema::Node::Constructor.new(
-            name: name,
-            type: NxtSchema::Types::Constructor(::Struct) { |hash| ::Struct.new(*hash.keys).new(*hash.values) },
-            parent_node: self,
-            **options,
-            &block
-          )
-        when :OpenStruct
-          NxtSchema::Node::Constructor.new(
-            name: name,
-            type: NxtSchema::Types::Constructor(::OpenStruct),
-            parent_node: self,
-            **options,
-            &block
-          )
-        else
-          if type_or_node.is_a?(NxtSchema::Node::Base)
-            node = type_or_node.clone
-            node.options.merge!(options)
-            node.name = name
-            node.parent_node = self
-            node
-          else
-            NxtSchema::Node::Leaf.new(name: name, type: type_or_node, parent_node: self, **options)
-          end
-        end
-
-        # TODO: Should we check if there is a
-        raise KeyError, "Duplicate registration for key: #{name}" if template_store.key?(name)
-        template_store.push(child_node)
-
-        child_node
-      end
-
-      def required(name, type, **options, &block)
-        node(name, type, options, &block)
-      end
-
-      alias_method :requires, :required
-
-      def nodes(name, **options, &block)
-        node(name, :Collection, options, &block)
-      end
-
-      alias_method :array, :nodes
-
-      def schema(name, **options, &block)
-        node(name, :Schema, options, &block)
-      end
-
-      alias_method :hash, :schema
-
-      def struct(name, **options, &block)
-        node(name, NxtSchema::Types::Constructor(::OpenStruct), options, &block)
-      end
-
-      def dup
-        result = super
-        result.template_store = template_store.deep_dup
-        result.options = options.deep_dup
-        result
-      end
-
-      delegate_missing_to :value_store
-
-      private
-
-      def value_violates_emptiness?(value)
-        return true unless value.respond_to?(:empty?)
-
-        value.empty?
-      end
-    end
-  end
-end
-
-NxtSchema::Node::Schema.include(::NxtSchema::Node::HasSubNodes)
-NxtSchema::Node::Collection.include(::NxtSchema::Node::HasSubNodes)
-NxtSchema::Node::Constructor.include(::NxtSchema::Node::HasSubNodes)

data/lib/nxt_schema/node/template_store.rb

@@ -1,15 +0,0 @@
-module NxtSchema
-  module Node
-    class TemplateStore < ::Hash
-      def push(node)
-        node_name = node.name
-        raise_key_error(node_name) if key?(node_name)
-        self[node_name] = node
-      end
-
-      def raise_key_error(key)
-        raise KeyError, "Node with name '#{key}' already registered! Node names must be unique!"
-      end
-    end
-  end
-end

data/lib/nxt_schema/registry.rb

@@ -1,85 +0,0 @@
-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}"
-      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
-        end
-      end
-    end
-
-    def namespaced_key_parts(key)
-      key.downcase.split(namespace_separator)
-    end
-
-    def flat_key(key)
-      namespaced_key_parts(key).last
-    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 to_s
-      identifier = 'NxtSchema::Registry'
-      identifier << "#{namespace_separator}#{namespace}" unless namespace.blank?
-      identifier
-    end
-  end
-end

data/lib/nxt_schema/undefined.rb

@@ -1,7 +0,0 @@
-module NxtSchema
-  class Undefined
-    def inspect
-      'undefined'
-    end
-  end
-end