activevalidation 0.1.0 → 1.0.0

data/lib/active_validation/orm_plugins/active_record_plugin/models/active_validation/concerns/protect_from_mutable_instance_methods.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ActiveValidation
+  module Concerns
+    module ProtectFromMutableInstanceMethods
+      MUTABLE_INSTANCE_METHODS = %i[
+        touch
+        update
+        update!
+        update_all
+        update_attribute
+        update_attributes
+        update_column
+        update_columns
+      ].freeze
+
+      RESTRICTED_INSTANCE_METHODS = (MUTABLE_INSTANCE_METHODS + %i[delete destroy destroy_all]).freeze
+
+      def restricted_instance_methods
+        RESTRICTED_INSTANCE_METHODS
+      end
+
+      # By design all records must be immutable. I do not recommend to avoid
+      # this restriction
+
+      MUTABLE_INSTANCE_METHODS.each do |name|
+        define_method(name) { |*| raise Errors::ImmutableError }
+      end
+    end
+  end
+end

data/lib/active_validation/orm_plugins/active_record_plugin/models/active_validation/manifest.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ActiveValidation
+  class Manifest < ActiveRecord::Base
+    prepend ActiveValidation::Concerns::ProtectFromMutableInstanceMethods
+
+    self.table_name = :active_validation_manifests
+
+    attribute :version, :version
+
+    has_many :checks
+    accepts_nested_attributes_for :checks, allow_destroy: false
+
+    def to_internal_manifest
+      json_options = { include: { checks: { methods: %i[method_name] } }, root: false }
+      ActiveValidation::Internal::Models::Manifest.new as_json(json_options).to_options!
+    end
+  end
+end
+
+::ActiveRecord::Type.register(:version, ActiveValidation::Type::Version)

data/lib/active_validation/orm_plugins/active_record_plugin/types/active_validation/type/version.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActiveValidation
+  module Type
+    class Version < ActiveModel::Type::Integer
+      def serialize(value)
+        value.to_i
+      end
+
+      def deserialize(value)
+        return unless value
+
+        ActiveValidation::Values::Version.new value
+      end
+    end
+  end
+end

data/lib/active_validation/registry.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module ActiveValidation
+  class Registry
+    include Enumerable
+
+    attr_reader :name
+
+    def initialize(name)
+      @name  = name
+      @items = Concurrent::Map.new
+    end
+
+    def clear
+      @items.clear
+    end
+
+    def each(&block)
+      @items.values.uniq.each(&block)
+    end
+
+    def find(item_name)
+      @items.fetch(normalize_name(item_name))
+    rescue KeyError => e
+      raise key_error_with_custom_message(e, item_name)
+    end
+
+    alias [] find
+
+    def register(name, item)
+      @items[normalize_name(name)] = item
+    end
+
+    def registered?(name)
+      @items.key?(normalize_name(name))
+    end
+
+    def delete(name)
+      @items.delete(normalize_name(name))
+    end
+
+    private
+
+    def key_error_with_custom_message(key_error, item_name)
+      message = key_error.message.sub("key not found", %(#{@name} not registered: "#{item_name}"))
+      error = KeyError.new(message)
+      error.set_backtrace(key_error.backtrace)
+      error
+    end
+
+    def normalize_name(key)
+      key.respond_to?(:to_sym) ? key.to_sym : key.to_s.to_sym
+    end
+  end
+end

data/lib/active_validation/values/base.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ActiveValidation
+  module Values
+    class Base
+      BAD_VALUES = [nil, true, false].freeze
+
+      attr_reader :value
+
+      def initialize(value)
+        raise ArgumentError, "Value of #{self.class} can not be #{value.inspect}" if BAD_VALUES.include? value
+
+        @value = value.freeze
+      end
+
+      def <=>(other)
+        raise ArgumentError, "Inconcictent classes #{self.class} and #{other.class}" unless self.class == other.class
+
+        value <=> other.value
+      end
+
+      def ==(other)
+        value == (other.class == self.class ? other.value : other)
+      end
+
+      def to_s
+        value.to_s
+      end
+
+      def to_sym
+        value.to_sym
+      end
+
+      def as_json(*)
+        value
+      end
+    end
+  end
+end

data/lib/active_validation/values/method_name.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ActiveValidation
+  module Values
+    class MethodName < Base
+      # @param value [#to_i, #to_s]
+      def initialize(value)
+        unless allowed_methods.include? value.to_s
+          raise ActiveValidation::Errors::UnsupportedMethodError.new value: value, allowed_methods: allowed_methods
+        end
+
+        super value.to_s
+      end
+
+      private
+
+      def allowed_methods
+        %w[validates validates_with validate].freeze
+      end
+    end
+  end
+end

data/lib/active_validation/values/version.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActiveValidation
+  module Values
+    class Version < Base
+      # @param value [#to_i, #to_s]
+      def initialize(value)
+        super
+        @value = value.respond_to?(:to_int) ? value.to_i : Integer(value.to_s.sub(/\AV/, ""))
+      end
+
+      def to_i
+        value
+      end
+    end
+  end
+end

data/lib/active_validation/verifier.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module ActiveValidation
+  class Verifier
+    class << self
+      # Shortcut for the global verifiers registry instance
+      # @return [Registry]
+      def registry
+        ActiveValidation.config.verifiers_registry
+      end
+
+      delegate :find_or_build, to: :registry
+    end
+    delegate :config, to: :ActiveValidation
+
+    # Name of the folder, where all validations method should be scoped.
+    # Inside, in corresponding sub-folder with version name shall be
+    # stored validation related methods
+    attr_accessor :validations_module_name
+
+    # @note The corresponding model class
+    attr_reader :base_klass
+
+    # @note Orm adapter for exactly this verifier instance
+    attr_accessor :orm_adapter
+
+    # @note Custom name formatter for Manifests
+    attr_accessor :manifest_name_formatter
+
+    # Stick manifest to specific version
+    # @return [Internal::Manifest]
+    attr_accessor :manifest
+
+    # Contains Internal::Observers::Manifest, which store everything about used
+    # manifests
+    #
+    # @return [Internal::Observers::Manifest]
+    attr_reader :observer
+
+    # Main switch for this class. After switch, all installed validators
+    # remain in place, while new installations will be turned off.
+    #
+    # @return [TrueClass, FalseClass]
+    attr_accessor :enabled
+    def enabled?; !!enabled; end
+
+    # If something go wrong or there is no any Manifests for selected class yet,
+    # to prevent DB flooding we just until the situation resolves.
+    # Here we can specify the period between the attempts
+    #
+    attr_accessor :failed_attempt_retry_time
+
+    delegate :install, to: :observer
+
+    def initialize(base_klass)
+      config.verifier_defaults.call self
+      @base_klass = base_klass.to_s
+      @orm_adapter ||= config.orm_adapter
+      @manifest_name_formatter ||= config.manifest_name_formatter
+      @validations_module_name ||= "Validations"
+      @enabled ||= true
+      @failed_attempt_retry_time ||= 1.day
+
+      yield self if block_given?
+
+      @observer = Internal::Observers::Manifest.new self
+      self.class.registry.register base_klass, self
+    end
+
+    # @return [Array<Value::Version>] Sorted list of versions.
+    def versions
+      base_class.const_get(validations_module_name)
+                .constants.map { |k| ActiveValidation::Values::Version.new(k) }.sort
+    rescue NameError
+      []
+    end
+
+    # @!group Manual version lock
+    def version
+      @version ||= versions.last
+    end
+
+    def version=(other)
+      @version = versions.detect { |a| a == ActiveValidation::Values::Version.new(other) } or
+        raise ArgumentError, "Version #{other} not found"
+    end
+
+    # @!endgroup
+
+    # @return [Internal::Manifest]
+    def current_manifest
+      manifest or find_manifests.first
+    end
+
+    # @return [Class]
+    def base_class
+      base_klass.is_a?(Class) ? base_klass : base_klass.constantize
+    end
+
+    # Return the list af parents with active_validation
+    # @return [Array]
+    def descendants_with_active_validation
+      [].tap do |descendants|
+        k = base_class.superclass
+        while k.respond_to?(:active_validation) && k.instance_methods.include?(:manifest)
+          descendants << k
+          k = k.superclass
+        end
+      end
+    end
+
+    # Install parent models and self
+    #
+    # Return Symbol Installation status
+    def install!(*args)
+      descendants_with_active_validation.each { |klass| klass.active_validation.install }
+      install(*args)
+    end
+
+    # Forward the normalized request to ORM mapper
+    # For the name field we calculate default value
+    #
+    # param [Hash]
+    # @return [Internal::Manifest, Array<Internal::Manifest>]
+
+    def add_manifest(**hash)
+      add_defaults_for_orm_adapter(hash) do |**h|
+        h[:name] ||= manifest_name_formatter.call(base_klass)
+        orm_adapter.public_send :add_manifest, h
+      end
+    end
+
+    # Forward the normalized request to ORM mapper
+    #
+    # param [Hash]
+    # @return [Internal::Manifest, Array<Internal::Manifest>]
+
+    %i[find_manifest find_manifests].each do |m|
+      define_method(m) { |**hash| add_defaults_for_orm_adapter(hash) { |**h| orm_adapter.public_send m, h } }
+    end
+
+    private
+
+    def add_defaults_for_orm_adapter(**hash)
+      hash[:base_klass] ||= base_klass
+      hash[:version]    ||= version if version
+      block_given? ? yield(hash) : hash
+    end
+  end
+end

data/lib/active_validation/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ActiveValidation
+  VERSION = "1.0.0"
+end

data/spec/active_validation/base_adapter_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+describe ActiveValidation::BaseAdapter do
+  context "global configuration" do
+    subject { ActiveValidation.config }
+
+    it "is in the registry" do
+      expect(subject.orm_adapters_registry).not_to be_registered(:base)
+    end
+  end
+
+  it "has 'base' plugin name" do
+    expect(described_class.plugin_name).to eq "base"
+  end
+
+  it "has 'base' adapter name" do
+    expect(described_class.adapter_name).to eq "base"
+  end
+
+  it "contains '(abstract)' suffix" do
+    expect(described_class.to_s).to match(/\(abstract\)\z/)
+  end
+end

data/spec/active_validation/configuration_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+describe ActiveValidation::Configuration do
+  it "has verifiers registry" do
+    expect(subject.verifiers_registry).to be_a ActiveValidation::Registry
+  end
+
+  it "has ORM adapters registry" do
+    expect(subject.orm_adapters_registry).to be_a ActiveValidation::Registry
+  end
+
+  it "has method name values registry" do
+    expect(subject.method_name_values_registry).to be_a ActiveValidation::Registry
+  end
+
+  context "manifest name formatter" do
+    it "has value" do
+      expect(subject.manifest_name_formatter).to eq ActiveValidation::Formatters::ManifestNameFormatter
+    end
+
+    it "has value" do
+      expect(subject.manifest_name_formatter).to respond_to(:call)
+    end
+  end
+
+  context "orm_adapter=" do
+    let(:config) { ActiveValidation.config }
+
+    context "with fake" do
+      around do |tst|
+        adapter = config.orm_adapter
+        module ActiveValidation::OrmPlugins::FakePlugin; class Adapter < ActiveValidation::BaseAdapter; end; end
+        tst.call
+        ActiveValidation::OrmPlugins.send :remove_const, :FakePlugin
+        config.orm_adapters_registry.delete "fake"
+        config.orm_adapter = adapter
+      end
+
+      after do
+      end
+
+      it "setup correctly loaded adapter" do
+        config.orm_adapter = "fake"
+        expect(config.orm_adapter.to_s).to eq "fake_plugin"
+      end
+    end
+
+    it "raise if plugin not found" do
+      expect { config.orm_adapter = "not_exist" }.to raise_error LoadError
+    end
+  end
+end