mv-core 1.0.1 → 2.0.0

data/lib/migration_validators/adapters/routing.rb

@@ -1,102 +0,0 @@
-module MigrationValidators
-  module Adapters
-    module Routing
-      extend ActiveSupport::Concern
-
-      ###################################################################
-      ## UNIQUENESS
-      ###################################################################
-      def validate_uniqueness_index validators
-        add_index validators.first
-        [validators.first]
-      end
-
-      def remove_validate_uniqueness_index validators
-        remove_index(validators.first)
-        [validators.first]
-      end
-
-      def validate_uniqueness validators
-        validate_uniqueness_index validators
-      end
-
-      def remove_validate_uniqueness validators
-        remove_validate_uniqueness_index validators
-      end
-
-      private 
-
-      def compose_index_name validator
-        if validator.options.blank? || (index_name = validator.options[:index_name]).blank? 
-          "idx_mgr_validates_#{validator.table_name}_#{validator.column_name}_#{validator.validator_name}"
-        else
-          index_name
-        end
-      end
-
-      def add_index validator
-        ::ActiveRecord::Base.connection.add_index validator.table_name, 
-                     validator.column_name, 
-                     :name => compose_index_name(validator),
-                     :unique => true
-      end
-
-      def remove_index validator
-        ::ActiveRecord::Base.connection.remove_index validator.table_name, 
-                        :name => compose_index_name(validator)
-      end
-
-      def execute statements
-        statements = [statements] if statements.kind_of?(String) 
-
-        statements.each {|stmt| ::ActiveRecord::Base.connection.execute(stmt) }
-      end
-
-      module ClassMethods
-        def routers to = nil
-          @routers ||= {}
-        end
-
-
-        def router validator_name, container_type, &block
-          router = routers["#{validator_name}_#{container_type}"] ||= MigrationValidators::Core::ValidatorRouter.new(containers)
-          router.instance_eval(&block) if block
-          router
-        end
-
-        def route validator_name, container_type, opts = {}, &block
-          router validator_name, container_type, &block
-
-          default = opts.delete(:default)
-          remove = opts.delete(:remove)
-          remove = true if remove.nil?
-
-          if (to = opts[:to])
-            to = [to] unless to.kind_of?(Array)
-            to.each {|container_name| router(validator_name, container_type).to container_name}
-          end
-
-          define_method :"validate_#{validator_name}_#{container_type}" do |validators|
-            execute(self.class.router(validator_name, container_type).add_validators(validators))
-            validators
-          end
-          alias_method(:"validate_#{validator_name}", :"validate_#{validator_name}_#{container_type}") if default
-
-          if remove 
-            define_method :"remove_validate_#{validator_name}_#{container_type}" do |validators|
-              execute(self.class.router(validator_name, container_type).remove_validators(validators))
-              validators
-            end
-            alias_method(:"remove_validate_#{validator_name}", :"remove_validate_#{validator_name}_#{container_type}") if default
-          end
-        end
-
-        def clear_routing
-          public_instance_methods.grep(/^remove_validate_/) { |method_name| undef_method method_name }
-          public_instance_methods.grep(/^validate_/) { |method_name| undef_method method_name }
-        end
-      end
-
-    end
-  end
-end

data/lib/migration_validators/adapters/syntax.rb

@@ -1,51 +0,0 @@
-module MigrationValidators
-  module Adapters
-    module Syntax
-      extend ActiveSupport::Concern
-
-      module ClassMethods
-        def define_base_syntax
-          syntax do
-            operation(:db_name)
-            operation(:db_value)
-            operation(:wrap) {|value| "(#{value})"}
-            operation(:and) {|stmt, value| "#{stmt} AND #{value}"}
-            operation(:or) {|stmt, value| "#{stmt} OR #{value}"}
-            operation(:length) {|value| "LENGTH(#{stmt})"}
-            operation(:trim) {|value| "TRIM(#{stmt})"}
-            operation(:coalesce) {|value| "COALESCE(#{stmt}, '')"}
-            operation(:if) {|if_stmt, then_stmt| "IF #{if_stmt} THEN #{then_stmt} ENDIF"}
-            operation(:regexp) {|stmt, value| "#{stmt} REGEXP #{value}"}
-            operation(:greater_than) {|stmt, value| "#{stmt} > #{value}"}
-            operation(:greater_or_equal_to) {|stmt, value| "#{stmt} >= #{value}"}
-            operation(:less_than) {|stmt, value| "#{stmt} < #{value}"}
-            operation(:less_or_equal_to) {|stmt, value| "#{stmt} <= #{value}"}
-            operation(:equal_to) {|stmt, value| "#{stmt} = #{value}"}
-            operation(:between) do |stmt, range| 
-              "#{@stmt} >= #{compile(range.first).db_value} AND #{@stmt} <#{range.exclude_end? ? '' : '='} #{compile(range.last).db_value}"
-            end
-            operation(:in) do |stmt, array| 
-              "#{@stmt} IN (#{array.collect{|value| compile(value).db_value}.join(', ')})"
-            end
-            operation(:not_in) do |stmt, array| 
-              "#{@stmt} NOT IN (#{array.collect{|value| compile(value).db_value}.join(', ')})"
-            end
-            operation(:not_null) {|value| "#{value} IS NOT NULL"}
-            operation(:null) {|value| "#{value} IS NULL"}
-            operation(:not) {|value| "NOT #{value}"}
-            operation(:exists) {|value| "EXISTS #{value}"}
-            operation(:select) {|value| "SELECT #{value}"}
-            operation(:from) {|value| " FROM #{value}"}
-            operation(:where) {|value| "WHERE #{value}"}
-          end
-        end
-
-        def syntax &block
-          @builder ||= MigrationValidators::Core::StatementBuilder.new
-          @builder.instance_eval(&block) if block
-          @builder
-        end
-      end
-    end
-  end
-end

data/lib/migration_validators/adapters/validator_definitions.rb

@@ -1,132 +0,0 @@
-module MigrationValidators
-  module Adapters
-    module ValidatorDefinitions
-      extend ActiveSupport::Concern
-
-      module ClassMethods
-        def validators
-          @validators ||= {}
-        end
-
-        def validator name, opts = {}, &block
-          validator = validators[name]
-
-          unless validator
-            validator = validators[name] = MigrationValidators::Core::ValidatorDefinition.new(syntax)
-
-            validator.post :allow_nil => true do
-              self.wrap.or(column.db_name.null)
-            end if opts[:allow_nil] || !opts.key?(:allow_nil)
-
-            validator.post :allow_blank => true do
-              self.wrap.or(column.db_name.coalesce.trim.length.equal_to(0))
-            end if opts[:allow_blank] || !opts.key?(:allow_blank)
-          end
-
-
-          validator.instance_eval(&block) if block
-        end 
-
-        def define_base_validators
-          validator :inclusion  do
-            property :in do |value|
-              if value.kind_of?(Array)
-                column.db_name.not_null.and(column.db_name.in(value)) 
-              elsif value.kind_of?(Range)
-                column.db_name.not_null.and(db_name.between(value))
-              else
-                column.db_name.not_null.and(column.db_name.equal_to(compile(value).db_value))
-              end
-            end
-          end
-
-          validator :exclusion  do
-            property :in do |value|
-              if value.kind_of?(Array)
-                column.db_name.not_in(value)
-              elsif value.kind_of?(Range)
-                column.db_name.between(value).wrap.not 
-              else
-                column.db_name.equal_to(compile(value).db_value).not
-              end
-            end
-          end
-
-          validator :format  do
-            property :with do |value| 
-              column.db_name.not_null.and(column.db_name.regexp(compile(value).db_value))
-            end
-          end
-
-          validator :length  do
-            property :is, :message => :wrong_length do |value| 
-              column.db_name.coalesce.length.equal_to(compile(value).db_value) 
-            end
-            property :maximum, :message => :too_long do |value| 
-              column.db_name.coalesce.length.less_or_equal_to(compile(value).db_value) 
-            end
-            property :minimum, :message => :too_short do |value| 
-              column.db_name.coalesce.length.greater_or_equal_to(compile(value).db_value) 
-            end
-
-            property :in do |value|
-              case value.class.name 
-                when "Array" then column.db_name.coalesce.length.in(value)
-                when "Range" then column.db_name.coalesce.length.between(value)
-                else column.db_name.coalesce.length.equal_to(compile(value).db_value)
-              end
-            end
-
-            property :within do |value|
-              case value.class.name 
-                when "Array" then column.db_name.coalesce.length.in(value)
-                when "Range" then column.db_name.coalesce.length.between(value)
-                else column.db_name.coalesce.length.equal_to(compile(value).db_value)
-              end
-            end
-          end
-
-          validator :size  do
-            property :is, :message => :wrong_length do |value| 
-              column.db_name.coalesce.length.equal_to(compile(value).db_value) 
-            end
-            property :maximum, :message => :too_long do |value| 
-              column.db_name.coalesce.length.less_or_equal_to(compile(value).db_value) 
-            end
-            property :minimum, :message => :too_short do |value| 
-              column.db_name.coalesce.length.greater_or_equal_to(compile(value).db_value) 
-            end
-
-            property :in do |value|
-              case value.class.name 
-                when "Array" then column.db_name.coalesce.length.in(value)
-                when "Range" then column.db_name.coalesce.length.between(value)
-                else column.db_name.coalesce.length.equal_to(compile(value).db_value)
-              end
-            end
-
-            property :within do |value|
-              case value.class.name 
-                when "Array" then column.db_name.coalesce.length.in(value)
-                when "Range" then column.db_name.coalesce.length.between(value)
-                else column.db_name.coalesce.length.equal_to(compile(value).db_value)
-              end
-            end
-          end
-
-          validator :presence  do
-            property do |value| 
-              column.db_name.not_null.and(column.db_name.trim.length.greater_than(0))
-            end
-          end
-
-          validator :uniqueness do
-            property do |value|
-              "NOT EXISTS(SELECT #{column.to_s} FROM #{validator.table_name} tbl WHERE (#{column.db_name} = #{column.to_s}))"
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/migration_validators/core/adapter_wrapper.rb

@@ -1,88 +0,0 @@
-module MigrationValidators
-  module Core
-    class AdapterWrapper
-      class AdapterCaller
-        def initialize adapter, action
-          @adapter = adapter
-          @action = action
-        end
-        
-        def process validators
-          return if validators.blank?
-
-          check_validators(validators)
-
-          validators.group_by{|validator| [validator.table_name, compose_method_name(validator)]}.each do |group_id, group|
-            
-            until group.blank?
-              handled_validators = @adapter.send(group_id.last, group)
-
-              break if handled_validators.blank?
-
-              group = group - handled_validators
-            end
-          end
-        end
-
-        private
-
-        def compose_method_name validator
-          method_suffix = validator.options.blank? || validator.options[:as].blank? ? "" : "_#{validator.options[:as]}"
-          :"#{@action}_#{validator.validator_name}#{method_suffix}"
-        end
-
-        def grep_public_instance_methods expr
-          @adapter.class.public_instance_methods.collect{|method| method.to_s.match(expr)}.compact.collect{|match| match[1]}
-        end
-
-        def supported_validators 
-          grep_public_instance_methods(/^#{@action}_([a-z]*)/).uniq
-        end
-
-        def supported_db_forms validator_name
-          grep_public_instance_methods(/^#{@action}_#{validator_name}_([a-z]*)/).uniq
-        end
-
-        def default_db_form_supported? validator_name
-          @adapter.class.method_defined? :"#{@action}_#{validator_name}"
-        end
-
-        def array2str array
-          "[" + array.collect {|elem| "'#{elem}'"}.join(',') + "]"
-        end
-
-        def check_validators validators
-          validators.each do |validator|
-
-            unless supported_validators.include?(validator.validator_name.to_s) 
-              raise MigrationValidatorsException.new("Adapter '#{@adapter.name}'. 'Action '#{@action}' for '#{validator.validator_name}' is not supported. Available validators: #{array2str(supported_validators)}")
-            end
-
-            if validator.options && (db_form = validator.options[:as]) 
-              unless supported_db_forms(validator.validator_name).include?(db_form.to_s)
-                raise MigrationValidatorsException.new("Adapter '#{@adapter.name}'. Action '#{@action}' for db form '#{db_form}' for validator '#{validator.validator_name}' is not supported. Available db forms: #{array2str(supported_db_forms(validator.validator_name))}")
-              end
-            else
-              unless default_db_form_supported?(validator.validator_name.to_s)
-                raise MigrationValidatorsException.new("Adapter '#{@adapter.name}'. 'Action '#{@action}' for '#{validator.validator_name}' with default db form is not supported")
-              end
-            end
-          end
-        end
-      end
-
-      def initialize adapter
-        @creator = AdapterCaller.new adapter, :validate
-        @remover = AdapterCaller.new adapter, :remove_validate
-      end
-
-      def create_validators validators
-        @creator.process validators
-      end
-
-      def remove_validators validators
-        @remover.process validators
-      end
-    end
-  end
-end

data/lib/migration_validators/core/db_validator.rb

@@ -1,131 +0,0 @@
-module MigrationValidators
-  module Core
-    class DbValidator < ::ActiveRecord::Base
-      @@validators_to_remove = []
-      @@validators_to_add = []
-
-
-      self.table_name = MigrationValidators.migration_validators_table_name
-
-      validates_presence_of :table_name
-      validates_length_of :table_name, :maximum => 255
-      validates_length_of :column_name, :maximum => 255
-
-      validates_presence_of :validator_name
-      validates_length_of :validator_name, :maximum => 255
-
-      validate do |validator|
-        unless ::ActiveRecord::Base.connection.table_exists?(validator.table_name)
-          validator.errors[:table_name] << "table '#{table_name}' does not exist" 
-        else 
-          unless ::ActiveRecord::Base.connection.columns(validator.table_name).any?{|col| col.name == validator.column_name.to_s}
-            validator.errors[:column_name] << "column '#{column_name}' does not exist in the table '#{table_name}'" 
-          end
-        end
-      end 
-
-      before_save :prepare_options
-
-      serialize :options, Hash
-      serialize :constraints, ValidatorConstraintsList
-
-      scope :on_table, -> (table_name) { where table_name: table_name }
-      scope :on_column, -> (column_name) { where column_name: column_name }
-      scope :with_name, -> (validator_name) { where validator_name: validator_name }
-
-      def options
-        attributes['options'] ||= {}
-      end
-
-      def name
-        "#{table_name}_#{column_name}_#{validator_name}"
-      end
-
-      def error_message
-        unless (options.blank? || (message = options[:message]).blank?)
-          message
-        else
-          "#{validator_name} violated for #{table_name} field #{column_name}"
-        end
-      end
-
-      def satisfies opts
-        return true if opts.blank?
-
-        opts.collect do |property_name, property_value| 
-          [property_name, [property_value].flatten]
-        end.all? do |property_name, property_value| 
-          property_value.include?(options[property_name])
-        end
-      end
-
-      def delayed_destroy 
-        @@validators_to_remove << self unless @@validators_to_remove.include?(self)
-      end
-
-      def delayed_save
-        DbValidator.on_table(table_name)
-                   .on_column(column_name)
-                   .with_name(validator_name)
-                   .delayed_destroy
-                   
-        @@validators_to_add << self unless @@validators_to_add.include?(self)
-      end
-
-      private
-
-      def prepare_options
-        options = options.inject({}) do |res, (key, value)|
-          res[key.to_s] = value
-          res
-        end unless options.blank?
-
-        true
-      end
-
-      class << self 
-
-      def satisfies opts
-        all.select{|validator| validator.satisfies(opts) }
-      end
-
-      def delayed_destroy
-        all.each(&:delayed_destroy)
-      end
-
-      def constraint_validators constraint
-        (DbValidator.where("constraints LIKE ?", "%#{constraint}%").all + @@validators_to_add - @@validators_to_remove).select{|validator| validator.constraints.include?(constraint)}
-      end
-
-      def rename_column table_name, old_column_name, new_column_name
-        all.on_table(table_name).on_column(old_column_name).update_all(column_name: new_column_name)
-      end
-
-      def rename_table old_table_name, new_table_name
-        all.on_table(old_table_name).update_all(table_name: new_table_name)
-      end
-
-      def commit adapter = nil
-        adapter.remove_validators(@@validators_to_remove.select{|validator| ::ActiveRecord::Base.connection.table_exists?(validator.table_name)}) if adapter
-        @@validators_to_remove.each(&:destroy) 
-        @@validators_to_remove.clear
-
-        adapter.create_validators(@@validators_to_add) if adapter
-        @@validators_to_add.each(&:save!)
-        @@validators_to_add.clear
-      end
-
-      def rollback
-        @@validators_to_remove.clear
-        @@validators_to_add.clear
-      end
-
-      def clear_all
-        rollback
-        DbValidator.delete_all
-      end
-
-      end
-    end
-  end
-end