mv-core 1.0.1 → 2.0.0

data/lib/mv/core/constraint/builder/base.rb

@@ -0,0 +1,45 @@
+require 'mv/core/validation/builder/factory'
+
+module Mv
+  module Core
+    module Constraint
+      module Builder
+        class Base
+          attr_reader :constraint
+
+          delegate :name, to: :constraint
+
+          def initialize(constraint)
+            @constraint = constraint
+          end
+
+          def create
+          end
+
+          def delete
+          end
+
+          def update new_constraint_builder
+          end
+
+          def self.validation_builders_factory
+            @validation_builders_factory ||= Mv::Core::Validation::Builder::Factory.new
+          end
+          
+          def validation_builders
+            @validation_builders ||= constraint.validations.collect do |validation|
+              self.class.validation_builders_factory.create_builder(validation)
+            end
+          end
+
+          protected
+
+
+          def db
+            ::ActiveRecord::Base.connection
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mv/core/constraint/builder/factory.rb

@@ -0,0 +1,42 @@
+require 'mv/core/constraint/builder/index'
+require 'mv/core/constraint/builder/trigger'
+
+module Mv
+  module Core
+    module Constraint
+      module Builder
+        class Factory
+          include Singleton
+
+          def create_builder constraint
+            factory_map[constraint.class].new(constraint)
+          end
+
+          def register_builder constraint_class, builder_class
+            factory_map[constraint_class] = builder_class
+          end
+
+          def register_builders opts
+            opts.each do |constraint_class, builder_class| 
+              register_builder(constraint_class, builder_class)
+            end
+          end
+
+          class << self
+            delegate :create_builder, :register_builder, :register_builders, to: :instance
+          end
+
+
+          private
+
+          def factory_map
+            @factory_map ||= {
+              Mv::Core::Constraint::Index => Mv::Core::Constraint::Builder::Index, 
+              Mv::Core::Constraint::Trigger => Mv::Core::Constraint::Builder::Trigger
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mv/core/constraint/builder/index.rb

@@ -0,0 +1,50 @@
+require 'mv/core/constraint/builder/base'
+
+module Mv
+  module Core
+    module Constraint
+      module Builder
+        class Index < Base
+          def create
+            super
+
+            constraint.validations.group_by(&:table_name).each do |table_name, validations|
+              remove_index(table_name)
+              add_index(table_name, validations.collect(&:column_name))
+            end
+          end
+
+          def delete
+            super 
+
+            constraint.validations.group_by(&:table_name).each do |table_name, validations|
+              remove_index(table_name)
+            end
+          end
+
+          def update new_constraint_builder
+            super 
+
+            delete
+            new_constraint_builder.create
+          end
+
+          private
+
+          def index_exists?(table_name)
+            db.table_exists?(table_name) && 
+            db.index_name_exists?(table_name, name, false) 
+          end
+
+          def remove_index(table_name)
+            db.remove_index!(table_name, name) if index_exists?(table_name)
+          end
+
+          def add_index(table_name, columns)
+            db.add_index(table_name, columns, name: name, unique: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mv/core/constraint/builder/trigger.rb

@@ -0,0 +1,13 @@
+require 'mv/core/constraint/builder/base'
+
+module Mv
+  module Core
+    module Constraint
+      module Builder
+        class Trigger < Base
+          delegate :event, :update?, to: :constraint
+        end
+      end
+    end
+  end
+end

data/lib/mv/core/constraint/description.rb

@@ -0,0 +1,24 @@
+module Mv
+  module Core
+    module Constraint
+      class Description
+        include Comparable
+
+        attr_reader :name, :type, :options
+
+        def initialize name, type, options = {}
+          @name = name.to_sym
+          @type = type.to_sym
+          @options = options.inject({}) do |res, (name, value)|
+            res[name.to_sym] = value.to_s
+            res
+          end
+        end
+
+        def <=> other_info
+          [name, type, options] <=> [other_info.name, other_info.type, other_info.options]
+        end
+      end
+    end
+  end
+end

data/lib/mv/core/constraint/factory.rb

@@ -0,0 +1,33 @@
+require 'mv/core/constraint/trigger'
+require 'mv/core/constraint/index'
+
+module Mv
+  module Core
+    module Constraint
+      class Factory
+        include Singleton
+
+        def create_constraint description
+          factory_map[description.type.to_sym].new(description)
+        end
+
+        def register_constraint type, klass
+          factory_map[type.to_sym] = klass
+        end
+
+        class << self
+          delegate :create_constraint, :register_constraint, to: :instance
+        end
+
+        private 
+
+        def factory_map
+          @factory_map ||= {
+            trigger: Mv::Core::Constraint::Trigger,  
+            index: Mv::Core::Constraint::Index
+          }
+        end
+      end
+    end
+  end
+end

data/lib/mv/core/constraint/index.rb

@@ -0,0 +1,13 @@
+require 'mv/core/constraint/base'
+
+module Mv
+  module Core
+    module Constraint
+      class Index < Base
+        def initialize description
+          super
+        end
+      end
+    end
+  end
+end

data/lib/mv/core/constraint/trigger.rb

@@ -0,0 +1,20 @@
+require 'mv/core/constraint/base'
+
+module Mv
+  module Core
+    module Constraint
+      class Trigger < Base
+        attr_reader :event
+        
+        def initialize description
+          super 
+          @event = @description.options[:event].try(:to_sym)
+        end
+
+        def update?
+          event == :update
+        end
+      end
+    end
+  end
+end

data/lib/mv/core/db/helpers/column_validators.rb

@@ -0,0 +1,57 @@
+require 'mv/core/db/helpers/table_validators'
+
+module Mv
+  module Core
+    module Db
+      module Helpers
+        module ColumnValidators
+          include TableValidators
+
+          attr_accessor :column_name
+
+          def column_validators
+            table_validators.where(column_name: column_name)
+          end
+
+          def create_column_validator validation_type, opts
+            raise_column_validation_error(validation_type, opts) if opts == false
+
+            update_column_validator(validation_type, opts)
+          end
+
+          def delete_column_validator 
+            delete_validators(column_validators) > 0
+          end
+          
+          def update_column_validator validation_type, opts
+            return delete_validators(column_validators.where(validation_type: validation_type)) if opts == false
+
+            column_validators.where(validation_type: validation_type).first_or_initialize.tap do |validator|
+              validator.options = normalize_opts(opts)
+            end.save!
+          end
+
+          def rename_column new_column_name
+            column_validators.update_all(column_name: new_column_name)
+          end
+
+          private
+
+          def normalize_opts opts
+            opts == true ? {} : opts
+          end
+
+          def raise_column_validation_error validation_type, opts
+            raise Mv::Core::Error.new(
+              table_name: table_name, 
+              column_name: column_name, 
+              validation_type: validation_type, 
+              options: opts,
+              error: 'Validator can not be removed when new column is being added'
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mv/core/db/helpers/table_validators.rb

@@ -0,0 +1,38 @@
+require 'mv/core/db/migration_validator'
+
+module Mv
+  module Core
+    module Db
+      module Helpers
+        module TableValidators
+          attr_accessor :table_name
+          
+          def table_validators
+            Mv::Core::Db::MigrationValidator.where(table_name: table_name)
+          end
+
+          def delete_table_validators
+            delete_validators(table_validators)
+          end
+
+          def update_table_validators new_table_name
+            table_validators.update_all(table_name: new_table_name)
+          end
+
+          private
+
+          def say(message) 
+            ::ActiveRecord::Migration.say(message, true)
+          end
+
+          def delete_validators validators
+            validators.each do |validator|
+              validator.destroy
+            end
+            validators.length
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mv/core/db/migration_validator.rb

@@ -0,0 +1,26 @@
+require 'mv/core/validation/factory'
+require 'mv/core/constraint/description'
+require 'mv/core/validators/valid_validator'
+
+module Mv
+  module Core
+    module Db
+      class MigrationValidator < ::ActiveRecord::Base
+        serialize :options, Hash
+
+        validates :table_name, presence: true
+        validates :column_name, presence: true
+        validates :validation_type, presence: true
+
+        validates :validation, valid: true
+
+        def validation
+          Mv::Core::Validation::Factory.create_validation(table_name, 
+                                                          column_name, 
+                                                          validation_type, 
+                                                          options)
+        end
+      end
+    end
+  end
+end

data/lib/mv/core/error.rb

@@ -0,0 +1,25 @@
+module Mv
+  module Core
+    class Error < StandardError
+      attr_reader :table_name, :column_name, :validation_type, :options, :error
+
+      def initialize(opts = {})
+        opts = opts.with_indifferent_access
+
+        @table_name = opts[:table_name]
+        @column_name = opts[:column_name]
+        @validation_type = opts[:validation_type]
+        @options = opts[:options]
+        @error = opts[:error]
+
+        super [
+          @table_name ? "table: '#{@table_name}'" : nil,
+          @column_name ? "column: '#{@column_name}'" : nil, 
+          @validation_type ? "validation: '#{@validation_type}'" : nil, 
+          @options ? "options: '#{@options}'" : nil, 
+          @error ? "error: '#{@error}'" : nil, 
+        ].compact.join(', ')
+      end
+    end
+  end
+end

data/lib/mv/core/migration/base.rb

@@ -0,0 +1,94 @@
+require 'mv/core/db/migration_validator'
+require 'mv/core/migration/operations/list'
+require 'mv/core/migration/operations/factory'
+require 'mv/core/services/load_constraints'
+require 'mv/core/services/compare_constraint_arrays'
+require 'mv/core/services/synchronize_constraints'
+require 'mv/core/services/create_migration_validators_table.rb'
+
+module Mv
+  module Core
+    module Migration
+      class Base
+        include Singleton
+
+        SUPPORTED_METHODS = %i{ add_column remove_column rename_column 
+                                change_column rename_table drop_table}
+
+        attr_reader :operations_list, :operations_factory
+        
+        def initialize()
+          @operations_list = Mv::Core::Migration::Operations::List.new
+          @operations_factory = Mv::Core::Migration::Operations::Factory.new()
+        end
+
+        SUPPORTED_METHODS.each do |operation_name|
+          define_method operation_name do |*args|
+
+            unless disabled_validations?
+              operation = operations_factory.create_operation(operation_name, *args)
+              operations_list.add_operation(operation)
+            end
+          end
+        end
+
+        def execute
+          if operations_list.present?
+            Mv::Core::Services::CreateMigrationValidatorsTable.new.execute
+            
+            constraints_loader = Mv::Core::Services::LoadConstraints.new(operations_list.tables)
+
+            old_constraints = constraints_loader.execute
+
+            operations_list.execute()
+
+            new_constraints = constraints_loader.execute
+
+            constraints_comparizon = Mv::Core::Services::CompareConstraintArrays.new(old_constraints, new_constraints)
+                                                                                     .execute
+
+            Mv::Core::Services::SynchronizeConstraints.new(constraints_comparizon[:added], 
+                                                           constraints_comparizon[:updated], 
+                                                           constraints_comparizon[:deleted])
+                                                      .execute
+          end
+        end
+
+        def add_column table_name, column_name, opts
+          return unless opts.present?
+          
+          unless disabled_validations?
+            operation = operations_factory.create_operation(:add_column, table_name, column_name, opts)
+            operations_list.add_operation(operation)
+          end
+        end
+
+        def with_suppressed_validations
+          disable_validations!
+          yield
+          enable_validations!
+        end
+
+        class << self
+          alias_method :current, :instance
+
+          delegate *[SUPPORTED_METHODS, :execute, :with_suppressed_validations].flatten, to: :current, allow_nil: true
+        end
+
+        private
+
+        def disabled_validations?
+          !!@disabled_validations
+        end
+
+        def disable_validations!
+          @disabled_validations = true
+        end
+
+        def enable_validations!
+          @disabled_validations = false
+        end
+      end
+    end
+  end
+end