mv-core 0.1.0

data/lib/migration_validators/adapters/routing.rb

@@ -0,0 +1,104 @@
+module MigrationValidators
+  module Adapters
+    module Routing
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      ###################################################################
+      ## 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

@@ -0,0 +1,53 @@
+module MigrationValidators
+  module Adapters
+    module Syntax
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      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

@@ -0,0 +1,131 @@
+module MigrationValidators
+  module Adapters
+    module ValidatorDefinitions
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        def validators
+          @validators ||= {}
+        end
+
+        def validator name, opts = {}, &block
+          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)
+
+          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 :presense  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}  
+                            FROM #{validator.table_name}
+                           WHERE (#{column.db_name} = #{column}))"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/migration_validators/core/adapter_wrapper.rb

@@ -0,0 +1,88 @@
+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

@@ -0,0 +1,178 @@
+module MigrationValidators
+  module Core
+    class DbValidator < ::ActiveRecord::Base
+      set_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, Array
+
+      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.kind_of?(Array) ? property_value : [property_value]]
+        end.all? do |property_name, property_value| 
+          property_value.include?(options[property_name])
+        end
+      end
+
+      def save_to_constraint constraint_name
+        self.constraints ||= []
+        self.constraints << constraint_name.to_s unless self.constraints.include?(constraint_name.to_s)
+      end
+
+      def remove_from_constraint constraint_name
+        self.constraints.delete(constraint_name.to_s) if self.constraints
+      end
+
+      def in_constraint? constraint_name
+        self.constraints && self.constraints.include?(constraint_name.to_s)
+      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 add_column_validator table_name, column_name, validator_name, opts
+          remove_validators(:table_name => table_name.to_s,
+                            :column_name => column_name.to_s,
+                            :validator_name => validator_name.to_s)
+
+          add_new_validator(:table_name => table_name.to_s,
+                            :column_name => column_name.to_s,
+                            :validator_name => validator_name.to_s, 
+                            :options => opts)
+        end
+
+        def remove_column_validator table_name, column_name, validator_name
+          remove_validators :table_name => table_name.to_s, :column_name => column_name.to_s, :validator_name => validator_name.to_s
+        end
+
+        def remove_column_validators table_name, column_name
+          remove_validators :table_name => table_name.to_s, :column_name => column_name.to_s
+        end
+
+        def table_validators table_name, opts = {}
+          with_options opts do
+            DbValidator.find(:all, :conditions => { :table_name => table_name.to_s })
+          end
+        end
+
+        def constraint_validators constraint
+          (DbValidator.find(:all, :conditions => ["constraints LIKE ?", "%#{constraint}%"]) + validators_to_add - validators_to_remove).select{|validator| validator.in_constraint?(constraint)}
+        end
+
+        def remove_table_validators table_name 
+          remove_validators :table_name => table_name.to_s
+        end
+        
+        def column_validators table_name, column_name, opts = {}
+          with_options opts do
+            DbValidator.find :all, :conditions => { :table_name => table_name.to_s, :column_name => column_name.to_s }
+          end
+        end
+
+        def rename_column table_name, old_column_name, new_column_name
+          DbValidator.update_all({:column_name => new_column_name.to_s}, :column_name => old_column_name.to_s)
+        end
+
+        def rename_table old_table_name, new_table_name
+          DbValidator.update_all({:table_name => new_table_name.to_s}, :table_name => old_table_name.to_s)
+        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
+
+        def validators_to_remove
+          @validators_to_remove ||= []
+        end
+
+        def validators_to_add
+          @validators_to_add ||= []
+        end
+
+        private 
+
+        def validators_to_remove
+          @validators_to_remove ||= []
+        end
+
+        def validators_to_add
+          @validators_to_add ||= []
+        end
+
+        def with_options opts, &block
+          block.call.select {|validator| validator.satisfies(opts) } 
+        end
+
+        def add_new_validator opts
+          validators_to_add << new(opts)
+        end
+
+        def remove_validators opts
+          DbValidator.find(:all, :conditions => opts).each { |validator| validators_to_remove << validator }
+        end
+
+
+      end
+    end
+  end
+end