mv-core 1.0.1 → 2.0.0

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

@@ -0,0 +1,98 @@
+module Mv
+  module Core
+    module Validation
+      class Base
+        include Comparable
+        include ActiveModel::Validations
+
+        attr_reader :table_name, :column_name, :message, :on, :create_trigger_name, 
+                    :update_trigger_name, :allow_nil, :allow_blank, :as, :options
+
+        validates :on, inclusion: { in: :available_on }, allow_nil: true
+        validates :allow_nil, :allow_blank, inclusion: { in: [true, false] }
+        validates :as, inclusion: { in: :available_as }
+
+        validates :on, absence: { message: 'allowed when :as == :trigger' }, unless: :trigger?
+        validates :create_trigger_name, absence: { message: 'allowed when :on in [:save, :create] and :as == :trigger'}, unless: "create? && trigger?"
+        validates :update_trigger_name, absence: { message: 'allowed when :on in [:save, :update] and :as == :trigger'}, unless: "update? && trigger?"
+
+        def initialize table_name, column_name, options
+          @table_name = table_name
+          @column_name = column_name
+          @options = options
+
+          options.with_indifferent_access.tap do |options|
+            @message = options[:message] || default_message
+            @as = options[:as] || default_as
+            @on = options[:on] || default_on
+            @create_trigger_name = options[:create_trigger_name] || default_create_trigger_name
+            @update_trigger_name = options[:update_trigger_name] || default_update_trigger_name
+            @allow_nil = options[:allow_nil].nil? ? default_allow_nil : options[:allow_nil]
+            @allow_blank = options[:allow_blank].nil? ? default_allow_blank : options[:allow_blank]
+          end
+        end
+
+        def to_a
+          [table_name.to_s, column_name.to_s, message.to_s, on.to_s, create_trigger_name.to_s, 
+           update_trigger_name.to_s, allow_nil, allow_blank, as.to_s]
+        end
+
+        def <=> other_validation
+          [self.class.name, to_a] <=> [other_validation.class.name, other_validation.to_a]
+        end
+        
+        def update?
+          [:save, :update].include?(on.try(:to_sym))
+        end
+
+        def create?
+          [:save, :create].include?(on.try(:to_sym))
+        end
+
+        protected 
+
+        def available_as
+          [:trigger]
+        end
+
+        def available_on 
+          [:save, :update, :create]
+        end
+
+        def default_message
+          "#{self.class.name.split('::').last} violated on the table #{table_name} column #{column_name}"
+        end
+
+        def default_on
+          :save if trigger?
+        end
+
+        def default_as
+          :trigger
+        end
+
+        def default_create_trigger_name
+          "trg_mv_#{table_name}_ins" if create? && trigger?
+        end
+
+        def default_update_trigger_name
+          "trg_mv_#{table_name}_upd" if update? && trigger?
+        end
+
+        def default_allow_nil
+          false
+        end
+
+        def default_allow_blank
+          false
+        end
+
+        private
+
+        def trigger?
+          as.try(:to_sym) == :trigger
+        end
+      end
+    end
+  end
+end

data/lib/mv/core/validation/builder/absence.rb

@@ -0,0 +1,19 @@
+require 'mv/core/validation/builder/base'
+
+module Mv
+  module Core
+    module Validation
+      module Builder
+        class Absence < Base
+          def conditions
+            null_stmt = "#{column_reference} #{allow_nil ? 'IS' : 'IS NOT'} NULL"
+            blank_stmt = "LENGTH(TRIM(#{column_reference})) #{allow_blank ? '=' : '>'} 0"
+            join_stmt = allow_nil && allow_blank ? 'OR' : 'AND'
+
+            [{ statement: [null_stmt, join_stmt, blank_stmt].join(' '), message: message }]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module Mv
+  module Core
+    module Validation
+      module Builder
+        class Base
+          attr_reader :validation 
+
+          delegate :table_name, 
+                   :column_name, 
+                   :message, 
+                   :allow_nil, 
+                   :allow_blank, to: :validation
+
+          def initialize(validation)
+            @validation = validation
+          end
+          
+          protected
+          
+          def column_reference 
+            column_name
+          end
+
+          def apply_allow_nil_and_blank stmt
+            res = stmt
+
+            if allow_nil || allow_blank
+              if allow_nil
+                res = apply_allow_nil(res)
+              end
+
+              if allow_blank
+                res = apply_allow_nil(res) unless allow_nil
+                res = apply_allow_blank(res)
+              end
+            else
+              res = apply_neither_nil_or_blank_allowed(stmt)
+            end
+
+            res
+          end
+
+          def apply_allow_nil stmt
+            "#{stmt} OR #{column_reference} IS NULL"
+          end
+
+          def apply_allow_blank stmt
+            "#{stmt} OR LENGTH(TRIM(#{column_reference})) = 0"
+          end
+
+          def apply_neither_nil_or_blank_allowed stmt
+            "#{column_reference} IS NOT NULL AND #{stmt}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mv/core/validation/builder/exclusion.rb

@@ -0,0 +1,42 @@
+require 'mv/core/validation/builder/base'
+
+module Mv
+  module Core
+    module Validation
+      module Builder
+        class Exclusion < Base
+          delegate :in, to: :validation
+
+          def conditions
+            [{
+              statement: apply_allow_nil_and_blank(apply_in(column_reference)), 
+              message: message
+            }]
+          end
+
+          protected
+
+          def db_value value
+            return value if value.is_a?(Integer) or value.is_a?(Float)
+            return "'#{value.to_s}'" if value.is_a?(String)
+            raise Mv::Core::Error.new(table_name: table_name, 
+                                      column_name: column_name, 
+                                      validation_type: :inclusion, 
+                                      options: { in: value }, 
+                                      error: "#{value.class} is not supported as :in value")
+          end
+
+          def apply_in stmt
+            if self.in.is_a?(Range)
+              "#{stmt} < #{db_value(self.in.min)} OR #{stmt} > #{db_value(self.in.max)}"
+            else
+              prepared_in = self.in.to_a.collect{ |v| db_value(v) }
+
+              "#{stmt} NOT IN (#{prepared_in.join(', ')})" 
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'mv/core/validation/builder/exclusion'
+require 'mv/core/validation/builder/inclusion'
+require 'mv/core/validation/builder/length'
+require 'mv/core/validation/builder/presence'
+require 'mv/core/validation/builder/absence'
+require 'mv/core/validation/builder/uniqueness'
+
+module Mv
+  module Core
+    module Validation
+      module Builder
+        class Factory
+          def create_builder validation
+            factory_map[validation.class].new(validation)
+          end
+
+          def register_builder validation_class, builder_class
+            factory_map[validation_class] = builder_class
+          end
+
+          def register_builders opts
+            opts.each do |validation_class, builder_class|
+              register_builder(validation_class, builder_class)
+            end
+          end
+
+          private
+
+          def factory_map
+            @factory_map ||= {
+              Mv::Core::Validation::Exclusion => Mv::Core::Validation::Builder::Exclusion,
+              Mv::Core::Validation::Inclusion => Mv::Core::Validation::Builder::Inclusion,
+              Mv::Core::Validation::Length => Mv::Core::Validation::Builder::Length,
+              Mv::Core::Validation::Presence => Mv::Core::Validation::Builder::Presence,
+              Mv::Core::Validation::Absence => Mv::Core::Validation::Builder::Absence,
+              Mv::Core::Validation::Uniqueness => Mv::Core::Validation::Builder::Uniqueness
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mv/core/validation/builder/inclusion.rb

@@ -0,0 +1,42 @@
+require 'mv/core/validation/builder/base'
+
+module Mv
+  module Core
+    module Validation
+      module Builder
+        class Inclusion < Base
+          delegate :in, to: :validation
+
+          def conditions
+            [{
+              statement: apply_allow_nil_and_blank(apply_in(column_reference)), 
+              message: message
+            }]
+          end
+
+          protected
+
+          def db_value value
+            return value if value.is_a?(Integer) or value.is_a?(Float)
+            return "'#{value.to_s}'" if value.is_a?(String)
+            raise Mv::Core::Error.new(table_name: table_name, 
+                                      column_name: column_name, 
+                                      validation_type: :inclusion, 
+                                      options: { in: value }, 
+                                      error: "#{value.class} is not supported as :in value")
+          end
+
+          def apply_in stmt
+            if self.in.is_a?(Range)
+              "#{stmt} BETWEEN #{db_value(self.in.min)} AND #{db_value(self.in.max)}"
+            else
+              prepared_in = self.in.to_a.collect{ |v| db_value(v) }
+
+              "#{stmt} IN (#{prepared_in.join(', ')})" 
+            end
+          end
+        end
+      end
+    end 
+  end
+end

data/lib/mv/core/validation/builder/length.rb

@@ -0,0 +1,68 @@
+require 'mv/core/validation/builder/base'
+
+module Mv
+  module Core
+    module Validation
+      module Builder
+        class Length < Base
+          delegate :in, 
+                   :within, 
+                   :is, 
+                   :maximum, 
+                   :minimum,
+                   :too_short, 
+                   :too_long,
+                   to: :validation
+
+          def conditions
+            res = apply_in(column_reference) if self.in
+            res = apply_within(column_reference) if within
+            res = apply_is(column_reference) if self.is
+            res = apply_maximum(column_reference) if maximum && !minimum
+            res = apply_minimum(column_reference) if minimum && !maximum
+            res = apply_minimum_and_maximum(column_reference) if minimum && maximum
+
+            res.collect do |condition| 
+              { statement: apply_allow_nil_and_blank(condition[:statement]), message: condition[:message] }
+            end
+          end
+
+          protected
+
+          def apply_in stmt
+            [{ statement: self.in.is_a?(Range) ? "LENGTH(#{stmt}) BETWEEN #{self.in.min} AND #{self.in.max}" :
+                                                 "LENGTH(#{stmt}) IN (#{self.in.join(', ')})",
+              message: message }]
+          end
+
+          def apply_within stmt
+            [{ statement: within.is_a?(Range) ? "LENGTH(#{stmt}) BETWEEN #{within.min} AND #{within.max}" :
+                                                "LENGTH(#{stmt}) IN (#{within.join(', ')})",
+              message: message }]
+          end
+
+          def apply_is stmt
+            [{ statement: "LENGTH(#{stmt}) = #{self.is}", message: message }]
+          end
+
+          def apply_maximum stmt
+            [{ statement: "LENGTH(#{stmt}) <= #{maximum}", message: too_long || message }]
+          end
+
+          def apply_minimum stmt
+            [{ statement: "LENGTH(#{stmt}) >= #{minimum}", message: too_short || message }]
+          end
+
+          def apply_minimum_and_maximum stmt
+            if too_long == too_short
+              [{ statement: "LENGTH(#{stmt}) BETWEEN #{minimum} AND #{maximum}", 
+                message: message }]
+            else
+              [apply_minimum(stmt), apply_maximum(stmt)].flatten
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mv/core/validation/builder/presence.rb

@@ -0,0 +1,19 @@
+require 'mv/core/validation/builder/base'
+
+module Mv
+  module Core
+    module Validation
+      module Builder
+        class Presence < Base
+          def conditions
+            null_stmt = "#{column_reference} #{allow_nil ? 'IS' : 'IS NOT'} NULL"
+            blank_stmt = "LENGTH(TRIM(#{column_reference})) #{allow_blank ? '=' : '>'} 0"
+            join_stmt = allow_nil || allow_blank ? 'OR' : 'AND'
+
+            [{ statement: [null_stmt, join_stmt, blank_stmt].join(' '), message: message }]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mv/core/validation/builder/uniqueness.rb

@@ -0,0 +1,19 @@
+require 'mv/core/validation/builder/base'
+
+module Mv
+  module Core
+    module Validation
+      module Builder
+        class Uniqueness < Base
+          def conditions
+            res = "NOT EXISTS(SELECT #{column_name} 
+                                FROM #{table_name} 
+                               WHERE #{column_reference} = #{column_name})"
+
+            [{statement: apply_allow_nil_and_blank(res).squish, message: message}]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mv/core/validation/exclusion.rb

@@ -0,0 +1,27 @@
+require 'mv/core/validation/base'
+require 'mv/core/validators/array_validator'
+
+module Mv
+  module Core
+    module Validation
+      class Exclusion < Base
+        include ActiveModel::Validations
+
+        attr_reader :in
+
+        validates :in, presence: true, array: true
+
+        def initialize(table_name, column_name, opts)
+          super(table_name, column_name, opts)
+
+          @in = opts.with_indifferent_access[:in]
+        end
+
+        def to_a
+          prepared_in = self.in.is_a?(Range) ? [self.in.min, self.in.max] : self.in.try(:sort)
+          super + [prepared_in]
+        end
+      end
+    end
+  end
+end