activevalidation 0.1.0 → 1.0.0

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+using ActiveValidation::Internal::Models::Concerns::ToInternal::Check
+
+module ActiveValidation
+  module Internal
+    module Models
+      class Manifest
+        class Installer
+          attr_reader :base_class, :installed_callbacks, :checks, :context
+
+          def initialize(base_class:, checks: [], context:)
+            @base_class = base_class
+            @checks = checks
+            @context = context
+            @installed_callbacks = []
+          end
+
+          # Add all checks (validations) to base_class
+          #
+          # @note we have to use the hack with
+          # `callbacks_chain.each.to_a # => chain` since `chain` method is
+          # protected.
+          #
+          # @return [TrueClass]
+          def install
+            @installed_callbacks = chain_mutex.synchronize do
+              before = callbacks_chain_elements
+              checks.each { |check| base_class.public_send(*check.to_validation_arguments(context: context)) }
+              callbacks_chain_elements - before
+            end
+            true
+          end
+
+          # Remove all checks (validations) from base_class
+          #
+          # we can not use ActiveSupport provided methods, since we already have
+          # our installed callbacks.
+          #
+          # @return [FalseClass]
+          def uninstall
+            installed_validators = installed_callbacks.map(&:filter).select { |f| f.is_a? ActiveModel::Validator }
+
+            ([base_class] + ActiveSupport::DescendantsTracker.descendants(base_class)).reverse_each do |target|
+              uninstall! target: target, installed_validators: installed_validators
+            end
+            installed_callbacks.clear
+            false
+          end
+
+          def callbacks_chain
+            base_class._validate_callbacks
+          end
+
+          private
+
+          # We cannot call `chain` method directly, so we have to use this hack
+          #
+          # @return [Array<ActiveSupport::Callbacks>]
+          def callbacks_chain_elements
+            callbacks_chain.each.to_a
+          end
+
+          # Mutex from ActiveSupport::Callbacks::CallbackChain for `base_class`
+          #
+          # @return [Mutex]
+          def chain_mutex
+            callbacks_chain.instance_variable_get(:@mutex)
+          end
+
+          def uninstall!(target:, installed_validators:)
+            chain = target._validate_callbacks
+
+            chain.instance_variable_get(:@mutex).synchronize do
+              target._validators
+                    .each_value { |v| v.reject! { |el| installed_validators.include?(el) } }
+                    .delete_if { |_, v| v.empty?  }
+
+              installed_callbacks.each { |callback| chain.delete(callback) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module ActiveValidation
+  module Internal
+    module Observers
+      class Manifest
+        DISABLED_VERIFIER = :verifier_is_not_enabled
+        RECENT_FAILURE = :it_was_failed_too_recently
+        NOT_FOUND = :not_found
+        ALREADY_INSTALLED = :already_installed
+        INSTALLED = :installed
+        UNINSTALLED = :uninstalled
+
+        attr_reader :verifier, :installed_manifests, :last_failed_attempt_time
+
+        delegate :manifest, :failed_attempt_retry_time, :enabled?, to: :verifier
+
+        def initialize(verifier)
+          @verifier = verifier
+          @installed_manifests = Concurrent::Set.new
+          @lock = Concurrent::ReadWriteLock.new
+          @last_failed_attempt_time = nil
+        end
+
+        # Install manifest and store the result. Load priority:
+        #   * `manifest_id` from the arguments
+        #   * `verifier.manifest` - defined by user in verifier block
+        #   * `current_manifest` - the latest manifest with current version
+        #
+        # The process will be skipped if:
+        #   - `verifier` not `enabled?`
+        #   - The last failed attempt was too recent.
+        #
+        # @return Symbol
+        def install(manifest_id: nil)
+          return DISABLED_VERIFIER unless enabled?
+          return RECENT_FAILURE if attempt_to_was_failed_recently?
+
+          found = lock.with_read_lock { find(manifest_id: manifest_id) } || current_manifest
+          return  NOT_FOUND unless found
+          return ALREADY_INSTALLED if found.installed?
+
+          install! internal_manifest: found
+        end
+
+        # Uninstall the manifest.
+        #
+        # @return Symbol
+        def uninstall(manifest_id:)
+          lock.with_write_lock do
+            internal_manifest = find(manifest_id: manifest_id)
+            return NOT_FOUND unless internal_manifest&.installed?
+
+            internal_manifest.uninstall
+            installed_manifests.delete internal_manifest
+          end
+          UNINSTALLED
+        end
+
+        # We omit the error and only save the error time to prevent
+        # DB flooding, when there is no any manifest.
+        #
+        # We do not know all possible errors so we can not be more
+        # specific here.
+        #
+        # @return [Internal::Manifest]
+        def current_manifest
+          verifier.current_manifest.to_internal_manifest
+        rescue StandardError => _e
+          @last_failed_attempt_time = Time.now
+          nil
+        end
+
+        # We need this method for been able to restore manifest lookup
+        #
+        # @return nil
+        def reset_last_failed_attempt_time
+          @last_failed_attempt_time = nil
+        end
+
+        # The actual install process
+        #
+        # @return Symbol
+        def install!(internal_manifest:)
+          lock.with_write_lock do
+            return ALREADY_INSTALLED if find(manifest_id: internal_manifest.id)&.installed?
+
+            internal_manifest.install
+            installed_manifests << internal_manifest
+          end
+          INSTALLED
+        end
+
+        private
+
+        attr_reader :lock
+
+        def find(manifest_id: nil)
+          return unless manifest_id
+
+          @installed_manifests.detect do |manifest|
+            manifest.id == manifest_id
+          end
+        end
+
+        def attempt_to_was_failed_recently?
+          return unless last_failed_attempt_time
+
+          Time.now < @last_failed_attempt_time + failed_attempt_retry_time
+        end
+      end
+    end
+  end
+end

data/lib/active_validation/model_extension_base.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module ActiveValidation
+  module ModelExtensionBase
+    extend ActiveSupport::Concern
+    module ClassMethods
+      # This is entry point, which setup or return existed Verifier.
+      #
+      # @return Verifier
+      def active_validation(&block)
+        register_active_validation_relations unless ActiveValidation::Verifier.registry.registered? self
+        ::ActiveValidation::Verifier.find_or_build self, &block
+      end
+
+      private
+
+      # Invoke the checks that validations are in place. Should be overwritten in ORM
+      # adapter
+      #
+      # @return nil
+      def register_active_validation_relations; end
+    end
+
+    protected
+
+    # We need to be sure, that all validation call backs are in place before validation
+    #
+    # @return nil
+    def process_active_validation
+      ::ActiveValidation::Verifier.find_or_build(self.class).install!(manifest_id: manifest_id)
+    end
+  end
+end

data/lib/active_validation/orm_plugins/active_record_plugin/adapter.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module ActiveValidation
+  module OrmPlugins
+    module ActiveRecordPlugin
+      class Adapter < ActiveValidation::BaseAdapter
+        loading_paths << "models"
+        loading_paths << "types"
+        loading_paths << "internals"
+        loading_paths << "model_extension"
+
+        def initialize
+          setup unless self.class.initialised
+          self.class.initialised = true
+        end
+
+        # @return [true]
+        def setup
+          return installer if defined?(::ActiveRecord::Base)
+
+          ::ActiveSupport.on_load(:active_record_adapter, &method(:installer))
+        end
+
+        # @see BaseAdapter
+        def add_manifest(manifest)
+          Manifest.create manifest.as_json(checks: { only: %i[type argument options], as: :checks_attributes })
+          manifest
+        end
+
+        # @see BaseAdapter
+        def find_manifests(wheres)
+          search(wheres)
+        end
+
+        # @see BaseAdapter
+        def find_manifest(wheres)
+          search(wheres, &:first!)
+        end
+
+        private
+
+        # @api internal
+        def search(wheres)
+          relation = Manifest.includes(:checks).where(wheres).order(created_at: :desc, id: :desc)
+          relation = yield relation if block_given?
+          relation.is_a?(ActiveRecord::Base) ? relation.to_internal_manifest : relation.map(&:to_internal_manifest)
+        end
+
+        # @return [true]
+        def installer
+          ActiveValidation::OrmPlugins::ActiveRecordPlugin::Adapter.loader
+          ActiveValidation::Internal::Models::Check.include(ActiveValidation::InternalModelExtensions::Check)
+          ::ActiveRecord::Base.include ActiveValidation::ActiveRecordModelExtension
+          true
+        end
+      end
+    end
+  end
+end

data/lib/active_validation/orm_plugins/active_record_plugin/internals/active_validation/internal_model_extensions/check.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ActiveValidation
+  module InternalModelExtensions
+    module Check
+      def type
+        method_name.to_s.camelcase.concat "Method"
+      end
+    end
+  end
+end

data/lib/active_validation/orm_plugins/active_record_plugin/model_extension/active_validation/active_record_model_extension.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveValidation
+  module ActiveRecordModelExtension
+    extend ActiveSupport::Concern
+    include ModelExtensionBase
+
+    module ClassMethods
+      private
+
+      def register_active_validation_relations
+        before_validation :process_active_validation
+
+        belongs_to :manifest, class_name: "::ActiveValidation::Manifest", dependent: :destroy
+
+        ActiveValidation::Manifest.has_many realtion_plural_name
+        nil
+      end
+
+      def realtion_plural_name
+        name.underscore.pluralize.to_sym
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ActiveValidation
+  class Check < ActiveRecord::Base
+    prepend ActiveValidation::Concerns::ProtectFromMutableInstanceMethods
+
+    serialize :options
+
+    self.table_name = :active_validation_checks
+    self.store_full_sti_class = false
+
+    belongs_to :manifest, inverse_of: :checks
+
+    validates :argument, presence: true
+
+    def method_name
+      raise NotImplementedError, "abstract" unless self.class < Check
+
+      self.class.name.demodulize.sub(/Method\z/, "").underscore
+    end
+
+    def method_name=(other)
+      self.type = other.camelcase + "Method"
+    end
+
+    def to_internal_check
+      json_options = { methods: %i[method_name], root: false }
+      ActiveValidation::Internal::Models::Check.new as_json(json_options).to_options!
+    end
+  end
+end

data/lib/active_validation/orm_plugins/active_record_plugin/models/active_validation/check/concerns/method_must_be_allowed.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ActiveValidation
+  class Check < ActiveRecord::Base
+    module Concerns
+      module MethodMustBeAllowed
+        extend ActiveSupport::Concern
+
+        included do
+          validate :method_must_be_allowed
+        end
+
+        private
+
+        def method_must_be_allowed
+          verify_options
+          verify_argument
+        end
+
+        def verify_options
+          return unless options
+
+          danger_values = options.slice([:if, :unless, "if", "unless"]).values
+          return if (danger_values & restricted_instance_methods).empty?
+
+          errors.add :options, "Options contain dangerous checks"
+        end
+
+        def verify_argument
+          return unless argument && manifest.try(:base_klass)
+          return unless restricted_instance_methods.include?(argument.to_sym)
+
+          errors.add :argument, "method #{argument} is restricted for usage in validation"
+        end
+      end
+    end
+  end
+end

data/lib/active_validation/orm_plugins/active_record_plugin/models/active_validation/check/validate_method.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ActiveValidation
+  class Check < ActiveRecord::Base
+    class ValidateMethod < Check
+      include Concerns::MethodMustBeAllowed
+    end
+  end
+end

data/lib/active_validation/orm_plugins/active_record_plugin/models/active_validation/check/validates_method.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ActiveValidation
+  class Check < ActiveRecord::Base
+    class ValidatesMethod < Check
+      include Concerns::MethodMustBeAllowed
+    end
+  end
+end

data/lib/active_validation/orm_plugins/active_record_plugin/models/active_validation/check/validates_with_method.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ActiveValidation
+  class Check < ActiveRecord::Base
+    class ValidatesWithMethod < Check
+      validate :validator_must_be_defined
+
+      private
+
+      def validator_must_be_defined
+        return if argument.blank?
+
+        argument.constantize.is_a? ActiveModel::Validator
+      rescue NameError
+        errors.add :argument, "Validator not exist"
+      end
+    end
+  end
+end