activevalidation 0.1.0 → 1.0.0

data/lib/active_validation/configuration.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module ActiveValidation
+  class Configuration
+    attr_reader :verifiers_registry, :orm_adapters_registry, :method_name_values_registry
+
+    def initialize
+      @orm_adapters_registry = Registry.new("Orm adapters")
+      @verifiers_registry    = strict_registry name: "Verifiers", klass: Verifier
+      @method_name_values_registry = strict_registry name: "Validation methods", klass: Values::MethodName
+
+      @manifest_name_formatter = Formatters::ManifestNameFormatter
+      @validation_context_formatter = Formatters::ValidationContextFormatter
+    end
+
+    attr_accessor :manifest_name_formatter, :validation_context_formatter
+
+    attr_reader :orm_adapter
+
+    def orm_adapter=(name, retry_attempt: 0)
+      retry_attempt += 1
+      @orm_adapter = case name
+                     when BaseAdapter
+                       name
+                     when Class
+                       name.new
+                     when String, Symbol
+                       "ActiveValidation::OrmPlugins::#{name.to_s.classify}Plugin::Adapter".constantize.new
+                     else
+                       raise ArgumentError "ORM plugin not found"
+                     end
+    rescue NameError
+      raise if retry_attempt > 1
+
+      require_relative "orm_plugins/#{name}_plugin/adapter"
+      retry
+    end
+
+    def verifier_defaults(&block)
+      @verifier_defaults ||= ->(_config) {}
+      return @verifier_defaults unless block_given?
+
+      @verifier_defaults = block
+    end
+
+    private
+
+    def strict_registry(name:, klass:)
+      Decorators::ConsistentRegistry.new(klass, Decorators::DisallowsDuplicatesRegistry.new(Registry.new(name)))
+    end
+  end
+end

data/lib/active_validation/decorator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ActiveValidation
+  class Decorator < BasicObject
+    undef_method :==
+
+    def initialize(component)
+      @component = component
+    end
+
+    def method_missing(name, *args, &block) # rubocop:disable Style/MethodMissingSuper
+      @component.send(name, *args, &block)
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      @component.respond_to?(name, true) || super
+    end
+
+    def send(symbol, *args, &block)
+      __send__(symbol, *args, &block)
+    end
+
+    def self.const_missing(name)
+      ::Object.const_get(name)
+    end
+  end
+end

data/lib/active_validation/decorators/consistent_registry.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ActiveValidation
+  module Decorators
+    class ConsistentRegistry < Decorator
+      # All items in the registry must be ancestors of this Class
+      # @return [Class]
+      attr_reader :klass
+
+      def initialize(klass, registry)
+        super registry
+
+        @klass = klass.is_a?(Class) ? klass : klass.to_s.constantize
+      end
+
+      def find_or_build(name, &block)
+        return klass.new(name, &block) unless registered?(name)
+
+        found = find(name)
+        found.instance_exec(found, &block) if block
+        found
+      end
+
+      def find_or_add(name, &block)
+        record = find_or_build(name, &block)
+        registered?(name) ? record : register(name, record)
+      end
+
+      def register(name, item)
+        raise Errors::InconsistentRegistryError unless item.is_a? klass
+
+        super
+      end
+    end
+  end
+end

data/lib/active_validation/decorators/disallows_duplicates_registry.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActiveValidation
+  module Decorators
+    class DisallowsDuplicatesRegistry < Decorator
+      def register(name, item)
+        return @component.register(name, item) unless registered?(name)
+
+        raise Errors::DuplicateRegistryEntryError, "#{@component.name} already registered: #{name}"
+      end
+
+      def ==(other)
+        object_id == other.object_id
+      end
+    end
+  end
+end

data/lib/active_validation/errors.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ActiveValidation
+  module Errors
+    class ImmutableError < StandardError
+      def initialize(msg = "Object can not be changed in lifetime")
+        super
+      end
+    end
+
+    class DuplicateRegistryEntryError < RuntimeError; end
+
+    class InconsistentRegistryError < ArgumentError; end
+
+    class UnsupportedMethodError < ArgumentError
+      attr_reader :value, :allowed_methods
+      def initialize(value:, allowed_methods:)
+        super
+        @value = value
+        @allowed_methods = allowed_methods
+      end
+
+      def to_s
+        "You provided #{value.inspect} while supported are only #{allowed_methods.inspect}"
+      end
+    end
+  end
+end

data/lib/active_validation/ext/add_active_validation_context_check.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ActiveValidation
+  module Ext
+    module AddActiveValidationContextCheck
+      def valid?(*_args)
+        result = super
+        return result unless ActiveValidation.config.verifiers_registry.registered?(self.class)
+
+        av_context = try(:manifest).try(:context) ||
+                     ActiveValidation.config.verifiers_registry[self.class].current_manifest.try(:context)
+        return result unless av_context
+
+        self.validation_context = av_context
+        run_validations!
+      end
+
+      alias validate valid?
+    end
+  end
+end

data/lib/active_validation/formatters/manifest_name_formatter.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActiveValidation
+  module Formatters
+    class ManifestNameFormatter
+      class << self
+        def call(base_klass)
+          "Manifest for #{base_klass}"
+        end
+      end
+    end
+  end
+end

data/lib/active_validation/formatters/validation_context_formatter.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ActiveValidation
+  module Formatters
+    class ValidationContextFormatter
+      class << self
+        def call(*args)
+          new(*args).call
+        end
+      end
+
+      def initialize(manifest)
+        @manifest = manifest
+      end
+
+      attr_reader :manifest
+
+      delegate :options, :id, :name, to: :manifest
+
+      def call
+        ["active_validation", "id#{id}"].tap do |base|
+          base << "on_#{options[:on]}" if options[:on]
+          base << name.to_s.underscore unless name.blank?
+        end.join("_")
+      end
+    end
+  end
+end

data/lib/active_validation/frameworks/rspec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "rspec/core"
+require "rspec/matchers"
+require "active_validation/frameworks/rspec/helpers"
+
+RSpec.configure do |config|
+  config.include ::ActiveValidation::RSpec::Helpers::InstanceMethods
+  config.extend  ::ActiveValidation::RSpec::Helpers::ClassMethods
+end

data/lib/active_validation/frameworks/rspec/helpers.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveValidation
+  module RSpec
+    module Helpers
+      # Included in the RSpec configuration in `frameworks/rspec.rb`
+      module InstanceMethods
+      end
+
+      # Extended by the RSpec configuration in `frameworks/rspec.rb`
+      module ClassMethods
+      end
+    end
+  end
+end

data/lib/active_validation/internal/models/check.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module ActiveValidation
+  module Internal
+    module Models
+      class Check
+        attr_reader :method_name, :argument, :options, :created_at
+        def initialize(method_name:, argument:, options: {}, created_at: nil, **_other)
+          @method_name = registry.find_or_add method_name
+          @argument = argument
+          @options = options.to_h.deep_symbolize_keys
+          @created_at = created_at
+        end
+
+        def ==(other)
+          method_name == other.method_name &&
+            argument    == other.argument &&
+            options     == other.options
+        end
+
+        def to_hash
+          as_json
+        end
+
+        def as_json(only: %i[method_name argument options], **_options)
+          only.each_with_object({}) { |el, acc| acc[el.to_sym] = public_send(el).as_json }
+        end
+
+        def to_internal_check
+          self
+        end
+
+        def normalized_argument
+          method_name.to_sym == :validates_with ? argument.to_s.constantize : argument.to_sym
+        end
+
+        def to_validation_arguments(context: nil)
+          [method_name.to_sym,
+           normalized_argument,
+           options.merge(on: context) { |_, old, new| Array(new) + Array(old) }]
+        end
+
+        private
+
+        def registry
+          ActiveValidation.config.method_name_values_registry
+        end
+      end
+    end
+  end
+end

data/lib/active_validation/internal/models/concerns/to_internal.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ActiveValidation
+  module Internal
+    module Models
+      module Concerns
+        module ToInternal
+          module Check
+            refine Hash do
+              def to_internal_check
+                ActiveValidation::Internal::Models::Check.new to_options!
+              end
+            end
+          end
+
+          module Manifest
+            refine Hash do
+              def to_internal_manifest
+                ActiveValidation::Internal::Models::Manifest.new to_options!
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_validation/internal/models/manifest.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+using ActiveValidation::Internal::Models::Concerns::ToInternal::Check
+
+module ActiveValidation
+  module Internal
+    module Models
+      class Manifest
+        attr_reader :version, :base_klass, :created_at, :checks, :options, :other, :id, :name
+
+        delegate :installed_callbacks, to: :installer
+
+        # @param [Hash] Manifest options hash
+        # @option manifest_hash [String] :name Human readable name, by default build with selected
+        #         formatter for current manifest
+        # @option manifest_hash [String, #to_s] :base_klass (base_klass) Base klass for the Manifest
+        # @option manifest_hash [String, Symbol, Integer, Values::Version] :version (:current) Version
+        #         of the current manifest
+        # @option manifest_hash [Internal::Check] :checks ([])
+        #
+        # @example Add new manifest:
+        #     new({  name: 'Cool Manifest',
+        #        version: 42,
+        #        base_klass: 'Bar',
+        #        checks: [
+        #           { method_name: "validates", argument: "name", options: { presence: true } }
+        #        ]})
+        def initialize(version:, base_klass:, checks: [], options: {}, **other)
+          @version = ActiveValidation::Values::Version.new version
+          @base_klass = base_klass.to_s
+          @checks = Array(checks).map(&:to_internal_check)
+          @other = ActiveSupport::OrderedOptions.new other
+
+          @id = other[:id]
+          @name = other[:name]
+          @created_at = other[:created_at]
+          @options = options.to_h.to_options!
+        end
+
+        def ==(other)
+          return true if id == other.id
+
+          version == other.version &&
+            base_klass == other.base_klass &&
+            options     == other.options &&
+            checks      == other.checks
+        end
+
+        def base_class
+          base_klass.constantize
+        end
+
+        def to_hash
+          as_json
+        end
+
+        # rubocop:disable Naming/MemoizedInstanceVariableName
+        def install
+          @installed ||= installer.install
+        end
+        # rubocop:enable Naming/MemoizedInstanceVariableName
+
+        def uninstall
+          return false unless installed?
+
+          @installed = installer.uninstall
+        end
+
+        # Are the callbacks installed to the `base_class`?
+        #
+        # @return [TrueClass, FalseClass]
+        def installed?
+          !!@installed
+        end
+
+        # ActiveSupport#as_json interface
+        # Supported options:
+        #   :only [Array<Symbol>, Symbol] select only listed elements
+        #
+        # Nested elements accept options:
+        #   :only [Array<Symbol>, Symbol] select only listed elements
+        #   :as   [Symbol, String] in place rename for the column
+        #
+        # @example
+        #     as_json(only: :version, checks: { as: :checks_attributes,
+        #                                       only: [:argument] })
+        #
+        # @return [Hash]
+        def as_json(only: %i[version base_klass checks name id], **options)
+          only = Array(only)
+          {}.tap do |acc|
+            options.each_pair do |k, v|
+              only.delete(k)
+              as = v.delete(:as)
+              key_name = (as || k).to_sym
+              acc[key_name] = public_send(k).as_json(v)
+            end
+            only.each { |el| acc[el.to_sym] = public_send(el).as_json }
+          end
+        end
+
+        def to_internal_manifest
+          self
+        end
+
+        # Formatted context, as it will be stored on `on` option with the
+        # validations
+        #
+        # @return [String]
+        def context
+          @context ||= ActiveValidation.config.validation_context_formatter.call self
+        end
+
+        private
+
+        def installer
+          @installer ||= Installer.new(base_class: base_class, checks: checks, context: context)
+        end
+      end
+    end
+  end
+end