validation_profiler 0.2.0 → 1.0.0

data/lib/validation_profiler/rules/match_validation_rule.rb

@@ -0,0 +1,46 @@
+module ValidationProfiler
+  module Rules
+    class MatchValidationRule < ValidationProfiler::Rules::ValidationRule
+
+      def error_message(field, attributes, parent = nil)
+
+        field_name = field.to_s
+        if parent != nil
+          field_name = "#{parent.to_s}.#{field.to_s}"
+        end
+
+        match_field = attributes[:field]
+
+        #check if a custom error message has been specified in the attributes
+        if attributes[:message] == nil
+          #no custom error message has been specified so create the default message.
+          "#{field_name} does not match #{match_field}"
+        else
+          attributes[:message]
+        end
+      end
+
+
+      def validate(obj, field, attributes, parent = nil)
+
+        #attempt to get the field value from the object
+        field_value = get_field_value(obj, field)
+
+        match_field = attributes[:field]
+        if match_field == nil
+          raise ValidationProfiler::Exceptions::InvalidValidationRuleAttributes.new(ValidationProfiler::Rules::MatchValidationRule, field)
+        end
+
+        if !is_required?(field_value, attributes)
+          return true
+        end
+
+        match_field_value = get_field_value(obj, match_field)
+
+        return field_value == match_field_value
+
+      end
+
+    end
+  end
+end

data/lib/validation_profiler/rules/max_validation_rule.rb

@@ -0,0 +1,52 @@
+module ValidationProfiler
+  module Rules
+    class MaxValidationRule < ValidationProfiler::Rules::ValidationRule
+
+      def error_message(field, attributes, parent = nil)
+
+        field_name = field.to_s
+        if parent != nil
+          field_name = "#{parent.to_s}.#{field.to_s}"
+        end
+
+        #check if a custom error message has been specified in the attributes
+        if attributes[:message] == nil
+          #no custom error message has been specified so create the default message.
+          max = attributes[:value]
+          "#{field_name} must not have a value greater than #{max}"
+        else
+          attributes[:message]
+        end
+      end
+
+      def validate(obj, field, attributes, parent = nil)
+
+        max = attributes[:value]
+
+        #verify the expected attributes have been specified.
+        if max == nil
+          raise ValidationProfiler::Exceptions::InvalidValidationRuleAttributes.new(ValidationProfiler::Rules::MaxValidationRule, field)
+        end
+
+        #attempt to get the field value from the object
+        field_value = get_field_value(obj, field)
+
+        if !is_required?(field_value, attributes)
+          return true
+        end
+
+        if field_value == nil
+          return false
+        end
+
+        if field_value.is_a?(DateTime) || field_value.is_a?(Numeric)
+          field_value <= max
+        else
+          raise ValidationProfiler::Exceptions::InvalidFieldType.new(ValidationProfiler::Rules::MaxValidationRule, field)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/validation_profiler/rules/min_validation_rule.rb

@@ -0,0 +1,52 @@
+module ValidationProfiler
+  module Rules
+    class MinValidationRule < ValidationProfiler::Rules::ValidationRule
+
+      def error_message(field, attributes, parent = nil)
+
+        field_name = field.to_s
+        if parent != nil
+          field_name = "#{parent.to_s}.#{field.to_s}"
+        end
+
+        #check if a custom error message has been specified in the attributes
+        if attributes[:message] == nil
+          #no custom error message has been specified so create the default message.
+          min = attributes[:value]
+          "#{field_name} must have a minimum value of #{min}"
+        else
+          attributes[:message]
+        end
+      end
+
+      def validate(obj, field, attributes, parent = nil)
+
+        min = attributes[:value]
+
+        #verify the expected attributes have been specified.
+        if min == nil
+          raise ValidationProfiler::Exceptions::InvalidValidationRuleAttributes.new(ValidationProfiler::Rules::MinValidationRule, field)
+        end
+
+        #attempt to get the field value from the object
+        field_value = get_field_value(obj, field)
+
+        if !is_required?(field_value, attributes)
+          return true
+        end
+
+        if field_value == nil
+          return false
+        end
+
+        if field_value.is_a?(DateTime) || field_value.is_a?(Numeric)
+          field_value >= min
+        else
+          raise ValidationProfiler::Exceptions::InvalidFieldType.new(ValidationProfiler::Rules::MinValidationRule, field)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/validation_profiler/rules/not_allowed_validation_rule.rb

@@ -0,0 +1,37 @@
+module ValidationProfiler
+  module Rules
+    class NotAllowedValidationRule < ValidationProfiler::Rules::ValidationRule
+
+      def error_message(field, attributes = {}, parent = nil)
+
+        field_name = field.to_s
+        if parent != nil
+          field_name = "#{parent.to_s}.#{field.to_s}"
+        end
+
+        #check if a custom error message has been specified in the attributes
+        if attributes[:message] == nil
+          #no custom error message has been specified so create the default message.
+          "#{field_name} is not allowed."
+        else
+          attributes[:message]
+        end
+      end
+
+
+      def validate(obj, field, attributes = {}, parent = nil)
+
+        #attempt to get the field value from the object
+        field_value = get_field_value(obj, field)
+
+        if field_value != nil
+          return false
+        end
+
+        return true
+
+      end
+
+    end
+  end
+end

data/lib/validation_profiler/rules/regex_validation_rule.rb

@@ -0,0 +1,47 @@
+module ValidationProfiler
+  module Rules
+    class RegexValidationRule < ValidationProfiler::Rules::ValidationRule
+
+      def error_message(field, attributes = {}, parent = nil)
+
+        field_name = field.to_s
+        if parent != nil
+          field_name = "#{parent.to_s}.#{field.to_s}"
+        end
+
+        #check if a custom error message has been specified in the attributes
+        if attributes[:message] == nil
+          #no custom error message has been specified so create the default message.
+          "#{field_name} is not a valid"
+        else
+          attributes[:message]
+        end
+      end
+
+
+      def validate(obj, field, attributes, parent = nil)
+
+        #attempt to get the field value from the object
+        field_value = get_field_value(obj, field)
+
+        regex = attributes[:regex]
+        if regex == nil
+          raise ValidationProfiler::Exceptions::InvalidValidationRuleAttributes.new(ValidationProfiler::Rules::RegexValidationRule, field)
+        end
+
+        if !is_required?(field_value, attributes)
+          return true
+        end
+
+        #validate the value against the regex
+        if field_value =~ regex
+          return true
+        end
+
+        return false
+
+      end
+
+    end
+  end
+end

data/lib/validation_profiler/rules/required_validation_rule.rb

@@ -0,0 +1,41 @@
+module ValidationProfiler
+  module Rules
+    class RequiredValidationRule < ValidationProfiler::Rules::ValidationRule
+
+      def error_message(field, attributes = {}, parent = nil)
+
+        field_name = field.to_s
+        if parent != nil
+          field_name = "#{parent.to_s}.#{field.to_s}"
+        end
+
+        #check if a custom error message has been specified in the attributes
+        if attributes[:message] == nil
+          #no custom error message has been specified so create the default message.
+          "#{field_name} is required"
+        else
+          attributes[:message]
+        end
+      end
+
+
+      def validate(obj, field, attributes = {}, parent = nil)
+
+        #attempt to get the field value from the object
+        field_value = get_field_value(obj, field)
+
+        if field_value == nil
+          return false
+        end
+
+        if field_value.is_a?(Array) || field_value.is_a?(String)
+          return !field_value.empty?
+        end
+
+        return true
+
+      end
+
+    end
+  end
+end

data/lib/validation_profiler/rules/validation_rule.rb

@@ -0,0 +1,43 @@
+module ValidationProfiler
+  module Rules
+    class ValidationRule
+
+      def get_field_value(obj, field)
+        #attempt to get the field value from the object
+        field_value = nil
+        #check if the object is a hash
+        if obj.is_a?(Hash)
+          if obj.has_key?(field)
+            #get the field value
+            field_value = obj[field]
+          elsif obj.has_key?(field.to_s)
+            field_value = obj[field.to_s]
+          end
+        else
+          #if the object does not contain the specified field raise an exception
+          if !obj.respond_to?(field)
+            raise ValidationProfiler::Exceptions::FieldNotFound.new(field)
+          end
+
+          #get the field value
+          field_value = obj.send(field)
+        end
+      end
+
+      def is_required?(field_value, attributes = {})
+        required = attributes[:required]
+        if required == nil
+          required = true
+        end
+
+        #check if the field is required
+        if field_value == nil && required == false
+          return false
+        else
+          return true
+        end
+      end
+
+    end
+  end
+end

data/lib/validation_profiler/rules/validation_rule_manager.rb

@@ -1,110 +1,75 @@
-require_relative '../../../lib/validation_profiler/rules/rules'
+require_relative '../../../lib/validation_profiler/rules/child_validation_rule'
+
+module ValidationProfiler
+  module Rules
+    # This is the manager class that holds all registered validation rules.
+    class Manager
+
+      class << self
+        attr_accessor :instance
+      end
+
+      def initialize
+        @rules = []
+        ValidationProfiler::Rules::Manager.instance = self
+        load_rules
+      end
+
+      # This method is called to get a validation rule by it's registered key.
+      #
+      # @params key [Symbol] This is the key of the validation rule you want to request.
+      #
+      # @return [ValidationRule] This is the requested ValidationRule instance.
+      def get_rule(key)
+
+        results = @rules.select { |r| r[:key] == key }
+        if !results.empty?
+          results[0][:instance]
+        else
+          raise ValidationProfiler::Exceptions::ValidationRuleNotFound.new(key)
+        end
+      end
+
+      # This method is called to add a validation rule to the manager for use.
+      #
+      # @param key [Symbol] This is the key to register the validation rule for.
+      # @param rule [ClassName] This is the class name of the validation rule to register.
+      def add_rule(key, rule)
+
+        instance = rule.new
+
+        #verify the rule instance inherits ValidationRule
+        if instance == nil || !instance.is_a?(ValidationRule)
+          raise ValidationProfiler::Exceptions::InvalidValidationRuleType.new(instance.class)
+        end
+
+        #verify the rule name has not already been registered
+        if !@rules.select { |r| r[:key] == key }.empty?
+          raise ValidationProfiler::Exceptions::ValidationRuleAlreadyExists.new(key)
+        end
+
+        @rules.push({ key: key, instance: instance})
+
+      end
+
+      private
+
+      def load_rules
+
+        @rules.push({ key: :required, instance: ValidationProfiler::Rules::RequiredValidationRule.new })
+        @rules.push({ key: :length, instance: ValidationProfiler::Rules::LengthValidationRule.new })
+        @rules.push({ key: :min, instance: ValidationProfiler::Rules::MinValidationRule.new })
+        @rules.push({ key: :max, instance: ValidationProfiler::Rules::MaxValidationRule.new })
+        @rules.push({ key: :email, instance: ValidationProfiler::Rules::EmailValidationRule.new })
+        @rules.push({ key: :regex, instance: ValidationProfiler::Rules::RegexValidationRule.new })
+        @rules.push({ key: :match, instance: ValidationProfiler::Rules::MatchValidationRule.new })
+        @rules.push({ key: :condition, instance: ValidationProfiler::Rules::ConditionValidationRule.new })
+        @rules.push({ key: :not_allowed, instance: ValidationProfiler::Rules::NotAllowedValidationRule.new })
+        @rules.push({ key: :list, instance: ValidationProfiler::Rules::ListValidationRule.new })
+        @rules.push({ key: :child, instance: ValidationProfiler::Rules::ChildValidationRule.new })
+
+      end
 
-# This is the manager class that holds all registered validation rules.
-class ValidationRuleManager
-
-  class << self
-    attr_accessor :instance
-  end
-
-  def initialize
-    @rules = []
-    ValidationRuleManager.instance = self
-    load_rules
-  end
-
-  # This method is called to get a validation rule by it's registered key.
-  #
-  # @params key [Symbol] This is the key of the validation rule you want to request.
-  #
-  # @return [ValidationRule] This is the requested ValidationRule instance.
-  def get_rule(key)
-
-    results = @rules.select { |r| r[:key] == key }
-    if !results.empty?
-      results[0][:instance]
-    else
-      raise ValidationRuleNotFound.new(key)
     end
   end
-
-  # This method is called to add a validation rule to the manager for use.
-  #
-  # @param key [Symbol] This is the key to register the validation rule for.
-  # @param rule [ClassName] This is the class name of the validation rule to register.
-  def add_rule(key, rule)
-
-    instance = rule.new
-
-    #verify the rule instance inherits ValidationRule
-    if instance == nil || !instance.is_a?(ValidationRule)
-      raise InvalidRuleType.new(instance.class)
-    end
-
-    #verify the rule name has not already been registered
-    if !@rules.select { |r| r[:key] == key }.empty?
-      raise RuleAlreadyExists.new(key)
-    end
-
-    @rules.push({ key: key, instance: instance})
-
-  end
-
-  private
-
-  def load_rules
-
-      @rules.push({ key: :required, instance: RequiredValidationRule.new })
-      @rules.push({ key: :length, instance: LengthValidationRule.new })
-      @rules.push({ key: :min, instance: MinValidationRule.new })
-      @rules.push({ key: :max, instance: MaxValidationRule.new })
-      @rules.push({ key: :email, instance: EmailValidationRule.new })
-      @rules.push({ key: :regex, instance: RegexValidationRule.new })
-      @rules.push({ key: :match, instance: MatchValidationRule.new })
-      @rules.push({ key: :condition, instance: ConditionValidationRule.new })
-      @rules.push({ key: :not_allowed, instance: NotAllowedValidationRule.new })
-      @rules.push({ key: :list, instance: ListValidationRule.new })
-      @rules.push({ key: :child, instance: ChildValidationRule.new })
-
-  end
-
-end
-
-class ValidationRuleNotFound < StandardError
-
-  def initialize(rule)
-    @rule = rule
-  end
-
-  def to_s
-    rule = @rule
-    "Validation rule: #{rule} could not be found."
-  end
-
-end
-
-class InvalidRuleType < StandardError
-
-  def initialize(rule)
-    @rule = rule
-  end
-
-  def to_s
-    rule = @rule
-    "Validation rule: #{rule} is not a valid type. Rules must inherit from the ValidationRule base class."
-  end
-
-end
-
-class RuleAlreadyExists < StandardError
-
-  def initialize(key)
-    @key = key
-  end
-
-  def to_s
-    key = @key
-    "A Rule has already been registered for the key: #{key}."
-  end
-
 end