smart_schema 0.12.1 → 0.12.2

data/lib/smart_core/schema/checker/rules/verifier.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+# @version 0.3.0
+module SmartCore::Schema::Checker::Rules::Verifier
+  require_relative 'verifier/result'
+
+  class << self
+    # @param rule [SmartCore::Schema::Checker::Rules::Base]
+    # @param matcher_options [SmartCore::Schema::Checker::Reconciler::Matcher::Options]
+    # @param verifiable_hash [SmartCore::Schema::Checker::VerifiableHash]
+    # @return [SmartCore::Schema::Checker::Rules::Verifier::Result]
+    #
+    # @api private
+    # @since 0.1.0
+    # @version 0.3.0
+    def verify!(rule, matcher_options, verifiable_hash)
+      SmartCore::Schema::Checker::Rules::Verifier::Result.new(rule).tap do |result|
+        requirement = result << check_requirement(rule, verifiable_hash)
+        next result if requirement.required? && requirement.failure?
+        next result if requirement.optional? && requirement.success? && !requirement.key_exists?
+        result << check_type(rule, verifiable_hash)
+        filled = result << check_filled(rule, verifiable_hash)
+        result << check_nested(rule, verifiable_hash) if filled.success?
+      end
+    end
+
+    private
+
+    # @param rule [SmartCore::Schema::Checker::Rules::Base]
+    # @param verifiable_hash [SmartCore::Schema::Checker::VerifiableHash]
+    # @return [SmartCore::Schema::Checker::Rules::Requirement::Result]
+    #
+    # @api private
+    # @since 0.1.0
+    def check_requirement(rule, verifiable_hash)
+      rule.requirement.validate(verifiable_hash)
+    end
+
+    # @param rule [SmartCore::Schema::Checker::Rules::Base]
+    # @param verifiable_hash [SmartCore::Schema::Checker::VerifiableHash]
+    # @return [SmartCore::Schema::Checker::Rules::Result::Success]
+    # @return [SmartCore::Schema::Checker::Rules::Result::Failure]
+    #
+    # @api private
+    # @since 0.1.0
+    def check_type(rule, verifiable_hash)
+      rule.options.type.validate(verifiable_hash)
+    end
+
+    # @param rule [SmartCore::Schema::Checker::Rules::Base]
+    # @param verifiable_hash [SmartCore::Schema::Checker::VerifiableHash]
+    # @return [SmartCore::Schema::Checker::Rules::Result::Success]
+    # @return [SmartCore::Schema::Checker::Rules::Result::Failure]
+    #
+    # @api private
+    # @since 0.1.0
+    def check_filled(rule, verifiable_hash)
+      rule.options.filled.validate(verifiable_hash)
+    end
+
+    # @param rule [SmartCore::Schema::Checker::Rules::Base]
+    # @param verifiable_hash [SmartCore::Schema::Checker::VerifiableHash]
+    # @return [NilClass, SmartCore::Schema::Checker::Reconciler::Matcher::Result]
+    #
+    # @api private
+    # @since 0.1.0
+    def check_nested(rule, verifiable_hash)
+      return unless rule.nested_reconciler
+      rule.nested_reconciler.__match!(verifiable_hash.extract(rule.schema_key))
+    end
+  end
+end

data/lib/smart_core/schema/checker/rules.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+# @version 0.8.0
+class SmartCore::Schema::Checker::Rules
+  require_relative 'rules/type_aliases'
+  require_relative 'rules/base'
+  require_relative 'rules/result'
+  require_relative 'rules/optional'
+  require_relative 'rules/required'
+  require_relative 'rules/extra_keys'
+  require_relative 'rules/options'
+  require_relative 'rules/requirement'
+  require_relative 'rules/verifier'
+
+  # @since 0.1.0
+  include Enumerable
+
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  # @version 0.8.0
+  def initialize
+    @rules = {}
+    @cache = SmartCore::Engine::Cache.new
+  end
+
+  # @param schema_key [String]
+  # @param rule [SmartCore::Schema::Checker::Rules::Base]
+  # @return [SmartCore::Schema::Checker::Rules::Base]
+  #
+  # @api private
+  # @since 0.1.0
+  # @version 0.8..0
+  def []=(schema_key, rule)
+    cache.clear
+    rules[schema_key] = rule
+  end
+
+  # @param block [Block]
+  # @yield [schema_key, rule]
+  # @yieldparam schema_key [String]
+  # @yieldparam rule [SmartCore::Schema::Checker::Rules::Base]
+  # @return [Enumerable]
+  #
+  # @api private
+  # @since 0.1.0
+  # @version 0.8.0
+  def each(&block)
+    block_given? ? rules.each_pair(&block) : rules.each_pair
+  end
+
+  # @param block [Block]
+  # @yield [rule]
+  # @yieldparam rule [SmartCore::Schema::Checker::Rules::Base]
+  # @return [Enumerable]
+  #
+  # @api private
+  # @since 0.1.0
+  # @version 0.8.0
+  def each_rule(&block)
+    block_given? ? rules.each_value(&block) : rules.each_value
+  end
+
+  # @return [Array<String>]
+  #
+  # @api private
+  # @since 0.1.0
+  # @version 0.8.0
+  def keys
+    cache.read(:keys) { rules.keys }
+  end
+
+  private
+
+  # @return [Hash<String,SmartCore::Schema::Checker::Rules::Base>]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :rules
+
+  # @return [SmartCore::Engine::Cache]
+  #
+  # @api private
+  # @since 0.8.0
+  attr_reader :cache
+end

data/lib/smart_core/schema/checker/verifiable_hash.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+# @version 0.8.0
+class SmartCore::Schema::Checker::VerifiableHash
+  # @return [Hash<String|Symbol,Any>]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :source
+
+  # @param source [Hash<String|Symbol,Any>]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def initialize(source)
+    @source = source
+  end
+
+  # @param key [String]
+  # @return [SmartCore::Schema::Checker::VerifiableHash]
+  #
+  # @api private
+  # @since 0.8.0
+  def extract(key)
+    SmartCore::Schema::Checker::VerifiableHash.new(fetch(key))
+  end
+
+  # @return [Array<String>]
+  #
+  # @api private
+  # @since 0.1.0
+  # @version 0.8.0
+  def keys
+    SmartCore::Schema::KeyControl.normalize_list(source.keys)
+  end
+
+  # @param key [String]
+  # @return [Boolean]
+  #
+  # @api private
+  # @since 0.1.0
+  # @version 0.8.0
+  def key?(key)
+    source.key?(key) || source.key?(key.to_sym)
+  end
+
+  # @param key [String]
+  # @return [Any]
+  #
+  # @api private
+  # @since 0.1.0
+  # @version 0.8.0
+  def fetch(key)
+    # @note
+    #   Previously we used exceptional flow "hash.fetch(key) rescue hash.fetch(key.to_sym)".
+    #   This flow can generate a lot of useless objects during rescuable `KeyError` exception
+    #   (useless error messages, backtraces, etc, object that was silently suppressed).
+    #   So, the "if"-#key?-oriented flow is better (generates fewer number of objects statistically)
+    source.key?(key) ? source.fetch(key) : source.fetch(key.to_sym)
+  end
+  alias_method :[], :fetch
+end

data/lib/smart_core/schema/checker.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+# @version 0.9.0
+class SmartCore::Schema::Checker
+  require_relative 'checker/verifiable_hash'
+  require_relative 'checker/rules'
+  require_relative 'checker/reconciler'
+
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  # @version 0.9.0
+  def initialize
+    @reconciler = Reconciler::Constructor.create
+    @lock = SmartCore::Engine::ReadWriteLock.new
+  end
+
+  # @param verifiable_hash [Hash<String|Symbol,Any>]
+  # @return [SmartCore::Schema::Result]
+  #
+  # @api private
+  # @since 0.1.0
+  # @version 0.9.0
+  def check!(verifiable_hash)
+    @lock.read_sync do
+      raise(SmartCore::Schema::ArgumentError, <<~ERROR_MESSAGE) unless verifiable_hash.is_a?(Hash)
+        Verifiable hash should be a type of ::Hash
+      ERROR_MESSAGE
+
+      reconciler.__match!(VerifiableHash.new(verifiable_hash)).complete!
+    end
+  end
+
+  # @param checker_invokations [Block]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.3.0
+  # @version 0.9.0
+  def invoke_in_pipe(&checker_invokations)
+    @lock.write_sync { instance_eval(&checker_invokations) }
+  end
+
+  # @param strict_mode [NilClass, String, Symbol]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.3.0
+  # @version 0.9.0
+  def set_strict_mode(strict_mode)
+    @lock.write_sync { apply_strict_mode(strict_mode) }
+  end
+
+  # @param definitions [Block]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  # @version 0.9.0
+  def append_schema_definitions(&definitions)
+    @lock.write_sync { add_schema_definitions(&definitions) }
+  end
+
+  # @param another_checker [SmartCore::Schema::Checker]
+  # @return [SmartCore::Schema::Checker]
+  #
+  # @api private
+  # @since 0.1.0
+  # @version 0.9.0
+  def combine_with(another_checker)
+    @lock.write_sync { self } # TODO (0.x.0): merge the definitions and return self
+  end
+
+  private
+
+  # @return [SmartCore::Schema::Checker::Reconciler]
+  #
+  # @api private
+  # @since 0.1.0
+  attr_reader :reconciler
+
+  # @param definitions [Block]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.1.0
+  def add_schema_definitions(&definitions)
+    raise(SmartCore::Schema::ArgumentError, <<~ERROR_MESSAGE) unless block_given?
+      Schema definitions is not provided (you should provide Block argument)
+    ERROR_MESSAGE
+
+    Reconciler::Constructor.append_definitions(reconciler, &definitions)
+  end
+
+  # @param strict_mode [NilClass, String, Symbol]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.3.0
+  def apply_strict_mode(strict_mode)
+    Reconciler::Constructor.set_strict_mode(reconciler, strict_mode)
+  end
+end

data/lib/smart_core/schema/configuration.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'qonfig'
+
+# @api public
+# @since 0.12.0
+module SmartCore::Schema::Configuration
+  # @since 0.12.0
+  include Qonfig::Configurable
+
+  # @api public
+  # @since 0.12.0
+  extend SmartCore::Schema::Plugins::AccessMixin
+
+  class << self
+    # @param setting_key [String, Symbol]
+    # @return [Qonfig::Settings, Any]
+    #
+    # @api private
+    # @since 0.12.0
+    def [](setting_key)
+      config[setting_key]
+    end
+  end
+
+  # @since 0.12.0
+  configuration do
+    setting :type_system, :smart_types
+    validate :default_type_system do |value|
+      SmartCore::Schema::TypeSystem.resolve(value) rescue false
+    end
+  end
+end

data/lib/smart_core/schema/dsl.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+module SmartCore::Schema::DSL
+  class << self
+    # @param base_klass [Class]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def included(base_klass)
+      base_klass.instance_variable_set(:@__schema_checker__, SmartCore::Schema::Checker.new)
+      base_klass.extend(ClassMethods)
+      base_klass.singleton_class.prepend(ClassInheritance)
+    end
+  end
+
+  # @api private
+  # @since 0.1.0
+  module ClassInheritance
+    # @param child_klass [Class]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def inherited(child_klass)
+      child_klass.instance_variable_set(
+        :@__schema_checker__,
+        SmartCore::Schema::Checker.new.combine_with(__schema_checker__)
+      )
+      child_klass.singleton_class.prepend(ClassInheritance)
+      super
+    end
+  end
+
+  # @api private
+  # @since 0.1.0
+  # @version 0.3.0
+  module ClassMethods
+    # @return [SmartCore::Schema::Checker]
+    #
+    # @api private
+    # @since 0.1.0
+    def __schema_checker__
+      @__schema_checker__
+    end
+
+    # @param strict_mode [NilClass, String, Symbol]
+    # @param definitions [Block]
+    # @return [void]
+    #
+    # @note nil strict mode means `do not change current mode`
+    #
+    # @api public
+    # @since 0.1.0
+    # @version 0.3.0
+    def schema(strict_mode = nil, &definitions)
+      __schema_checker__.invoke_in_pipe do
+        set_strict_mode(strict_mode)
+        append_schema_definitions(&definitions)
+      end
+    end
+
+    # @return [void]
+    #
+    # @api public
+    # @since 0.3.0
+    def strict!
+      __schema_checker__.set_strict_mode(:strict)
+    end
+
+    # @return [void]
+    #
+    # @api public
+    # @since 0.3.0
+    def non_strict!
+      __schema_checker__.set_strict_mode(:non_strict)
+    end
+  end
+end

data/lib/smart_core/schema/errors.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/StaticClass
+class SmartCore::Schema
+  # @api public
+  # @since 0.1.0
+  Error = Class.new(SmartCore::Error)
+
+  # @api public
+  # @since 0.1.0
+  ArgumentError = Class.new(SmartCore::ArgumentError)
+
+  # @api public
+  # @since 0.12.0
+  NoTypeAliasError = Class.new(Error)
+
+  # @api public
+  # @since 0.12.0
+  PluginError = Class.new(Error)
+
+  # @api public
+  # @since 0.12.0
+  UnresolvedPluginDependencyError = Class.new(PluginError)
+
+  # @api public
+  # @since 0.12.0
+  AlreadyRegisteredPluginError = Class.new(PluginError)
+
+  # @api public
+  # @since 0.12.0
+  UnregisteredPluginError = Class.new(PluginError)
+
+  # @api public
+  # @since 0.12.0
+  TypeSystemError = Class.new(Error)
+
+  # @api public
+  # @since 0.5.1
+  IncorrectTypeError = Class.new(TypeSystemError)
+
+  # @api public
+  # @since 0.12.0
+  TypeAliasNotFoundError = Class.new(TypeSystemError)
+
+  # @api public
+  # @since 0.12.0
+  IncorrectTypeSystemInteropError = Class.new(TypeSystemError)
+
+  # @api public
+  # @since 0.12.0
+  IncorrectTypeObjectError = Class.new(TypeSystemError)
+
+  # @api public
+  # @since 0.12.0
+  UnsupportedTypeSystemError = Class.new(TypeSystemError)
+
+  # @api public
+  # @since 0.12.0
+  UnsupportedTypeOperationError = Class.new(TypeSystemError)
+
+  # @api public
+  # @since 0.12.0
+  TypeCastingUnsupportedError = Class.new(UnsupportedTypeOperationError)
+end
+# rubocop:enable Style/StaticClass

data/lib/smart_core/schema/key_control.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.1.0
+module SmartCore::Schema::KeyControl
+  class << self
+    # @param key [String, Symbol]
+    # @return [String]
+    #
+    # @api private
+    # @since 0.1.0
+    def normalize(key)
+      prevent_incompatible!(key)
+      key.to_s
+    end
+
+    # @param keys [Array<String,Symbol>]
+    # @return [Array<String>]
+    #
+    # @api private
+    # @since 0.1.0
+    def normalize_list(keys)
+      keys.map { |key| normalize(key) }
+    end
+
+    # @param key [String, Symbol]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def prevent_incompatible!(key)
+      unless key.is_a?(String) || key.is_a?(Symbol)
+        raise(SmartCore::Schema::ArgumentError, <<~ERROR_MESSAGE)
+          Schema keys should be a type of string or symbol
+        ERROR_MESSAGE
+      end
+    end
+  end
+end

data/lib/smart_core/schema/plugins/abstract.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.12.0
+class SmartCore::Schema::Plugins::Abstract
+  class << self
+    # @param child_klass [Class]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.12.0
+    def inherited(child_klass)
+      child_klass.instance_variable_set(:@__loaded__, false)
+      child_klass.instance_variable_set(:@__lock__, SmartCore::Engine::Lock.new)
+      super
+    end
+
+    # @return [void]
+    #
+    # @api private
+    # @since 0.12.0
+    def load!
+      __thread_safe__ do
+        unless @__loaded__
+          @__loaded__ = true
+          install!
+        end
+      end
+    end
+
+    # @return [Boolean]
+    #
+    # @api private
+    # @since 0.12.0
+    def loaded?
+      __thread_safe__ { @__loaded__ }
+    end
+
+    private
+
+    # @return [void]
+    #
+    # @api private
+    # @since 0.12.0
+    def install!; end
+
+    # @return [Any]
+    #
+    # @api private
+    # @since 0.12.0
+    def __thread_safe__(&block)
+      @__lock__.synchronize(&block)
+    end
+  end
+end

data/lib/smart_core/schema/plugins/access_mixin.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.12.0
+module SmartCore::Schema::Plugins::AccessMixin
+  # @param plugin_name [Symbol, String]
+  # @return [void]
+  #
+  # @see SmartCore::Schema::Plugins
+  #
+  # @api public
+  # @since 0.12.0
+  def plugin(plugin_name)
+    SmartCore::Schema::Plugins.load(plugin_name)
+  end
+
+  # @return [Array<String>]
+  #
+  # @see SmartCore::Schema::Plugins
+  #
+  # @api public
+  # @since 0.12.0
+  def plugins
+    SmartCore::Schema::Plugins.names
+  end
+
+  # @return [Hash<String,Class<SmartCore::Schema::Plugins::Abstract>>]
+  #
+  # @api private
+  # @since 0.12.0
+  def loaded_plugins
+    SmartCore::Schema::Plugins.loaded_plugins
+  end
+  alias_method :enabled_plugins, :loaded_plugins
+
+  # @param plugin_name [String, Symbol]
+  # @param plugin_klass [Class<SmartCore::Schema::Plugins::Abstract>]
+  # @return [void]
+  #
+  # @see SmartCore::Schema::Plugins
+  #
+  # @api public
+  # @since 0.12.0
+  def register_plugin(plugin_name, plugin_klass)
+    SmartCore::Schema::Plugins.register_plugin(plugin_name, plugin_klass)
+  end
+end