validation_profiler 0.2.0 → 1.0.0

data/lib/validation_profiler/rules.rb

@@ -0,0 +1,23 @@
+require_relative 'rules/validation_rule'
+
+###############################
+###Add Validation Rules Here###
+###############################
+
+require_relative 'rules/child_validation_rule'
+require_relative 'rules/condition_validation_rule'
+require_relative 'rules/email_validation_rule'
+require_relative 'rules/length_validation_rule'
+require_relative 'rules/list_validation_rule'
+require_relative 'rules/match_validation_rule'
+require_relative 'rules/max_validation_rule'
+require_relative 'rules/min_validation_rule'
+require_relative 'rules/not_allowed_validation_rule'
+require_relative 'rules/regex_validation_rule'
+require_relative 'rules/required_validation_rule'
+
+
+################################
+
+require_relative 'rules/validation_rule_manager'
+

data/lib/validation_profiler/version.rb

@@ -1,3 +1,3 @@
 module ValidationProfiler
-  VERSION = "0.2.0"
+  VERSION = "1.0.0"
 end

data/lib/validation_profiler.rb

@@ -1,6 +1,6 @@
 require 'validation_profiler/version'
-require 'validation_profiler/rules/rules'
-require 'validation_profiler/rules/validation_rule_manager'
+require 'validation_profiler/exceptions'
+require 'validation_profiler/rules'
 
 class Class
 
@@ -28,56 +28,58 @@ class Class
 
 end
 
-class ValidationManager
+module ValidationProfiler
+  class Manager
 
-  # Called to validate an object against a validation profile.
-  #
-  # @param obj [Object] The object to validate
-  # @param profile [ClassName] The class name of the validation profile to validate against
-  #
-  # @return [ValidationManagerResult] The result of the validation
-  def validate(obj, profile, parent = nil)
+    # Called to validate an object against a validation profile.
+    #
+    # @param obj [Object] The object to validate
+    # @param profile [ClassName] The class name of the validation profile to validate against
+    #
+    # @return [ValidationManagerResult] The result of the validation
+    def validate(obj, profile, parent = nil)
 
-    result = ValidationManagerResult.new
+      result = ValidationProfiler::ManagerResult.new
 
-    validation_rules = profile.class_variable_get(:@@validation_rules)
+      validation_rules = profile.class_variable_get(:@@validation_rules)
 
-    validation_rules.each do |r|
+      validation_rules.each do |r|
 
-      if ValidationRuleManager.instance == nil
-        ValidationRuleManager.new
-      end
+        if ValidationProfiler::Rules::Manager.instance == nil
+          ValidationProfiler::Rules::Manager.new
+        end
 
-      rule = ValidationRuleManager.instance.get_rule(r[:name])
-      outcome = rule.validate(obj, r[:field], r[:attributes], parent)
+        rule = ValidationProfiler::Rules::Manager.instance.get_rule(r[:name])
+        outcome = rule.validate(obj, r[:field], r[:attributes], parent)
+
+        if outcome.is_a?(ValidationProfiler::ManagerResult)
+          result = outcome
+        elsif !outcome
+          result.outcome = false
+          result.errors.push({ field: r[:field], message: rule.error_message(r[:field], r[:attributes], parent) })
+        end
 
-      if outcome.is_a?(ValidationManagerResult)
-        result = outcome
-      elsif !outcome
-        result.outcome = false
-        result.errors.push({ field: r[:field], message: rule.error_message(r[:field], r[:attributes], parent) })
       end
 
-    end
+      result
 
-    result
+    end
 
   end
 
-end
-
-# This is used to specify validation results from the #validate method of the ValidationManager
-class ValidationManagerResult
+  # This is used to specify validation results from the #validate method of the Validation Manager
+  class ManagerResult
 
-  # @!attribute outcome
-  #   @return [Boolean] The outcome of the validation.
-  attr_accessor :outcome
-  # @!attribute errors
-  #   @return [Array[{:field, :error_message}]] An array of field errors that occurred during validation.
-  attr_accessor :errors
+    # @!attribute outcome
+    #   @return [Boolean] The outcome of the validation.
+    attr_accessor :outcome
+    # @!attribute errors
+    #   @return [Array[{:field, :error_message}]] An array of field errors that occurred during validation.
+    attr_accessor :errors
 
-  def initialize
-    @errors = []
-    @outcome = true
+    def initialize
+      @errors = []
+      @outcome = true
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: validation_profiler
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.0.0
 platform: ruby
 authors:
 - vaughanbrittonsage
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-06-16 00:00:00.000000000 Z
+date: 2016-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -77,7 +77,26 @@ files:
 - bin/console
 - bin/setup
 - lib/validation_profiler.rb
-- lib/validation_profiler/rules/rules.rb
+- lib/validation_profiler/exceptions.rb
+- lib/validation_profiler/exceptions/field_not_found.rb
+- lib/validation_profiler/exceptions/invalid_field_type.rb
+- lib/validation_profiler/exceptions/invalid_validation_rule_attributes.rb
+- lib/validation_profiler/exceptions/invalid_validation_rule_type.rb
+- lib/validation_profiler/exceptions/validation_rule_already_exists.rb
+- lib/validation_profiler/exceptions/validation_rule_not_found.rb
+- lib/validation_profiler/rules.rb
+- lib/validation_profiler/rules/child_validation_rule.rb
+- lib/validation_profiler/rules/condition_validation_rule.rb
+- lib/validation_profiler/rules/email_validation_rule.rb
+- lib/validation_profiler/rules/length_validation_rule.rb
+- lib/validation_profiler/rules/list_validation_rule.rb
+- lib/validation_profiler/rules/match_validation_rule.rb
+- lib/validation_profiler/rules/max_validation_rule.rb
+- lib/validation_profiler/rules/min_validation_rule.rb
+- lib/validation_profiler/rules/not_allowed_validation_rule.rb
+- lib/validation_profiler/rules/regex_validation_rule.rb
+- lib/validation_profiler/rules/required_validation_rule.rb
+- lib/validation_profiler/rules/validation_rule.rb
 - lib/validation_profiler/rules/validation_rule_manager.rb
 - lib/validation_profiler/version.rb
 homepage: https://github.com/vaughanbrittonsage/validation_profiler

data/lib/validation_profiler/rules/rules.rb

@@ -1,632 +0,0 @@
-
-class InvalidRuleAttributes < StandardError
-
-  def initialize(rule, field)
-    @rule = rule
-    @field = field
-  end
-
-  def to_s
-    rule = @rule
-    field = @field
-    "Incorrect attributes specified for Validation rule: #{rule} Field: #{field}."
-  end
-
-end
-
-class FieldNotFound < StandardError
-
-  def initialize(field)
-    @field = field
-  end
-
-  def to_s
-    field = @field
-    "Field: #{field} could not be found."
-  end
-
-end
-
-class InvalidFieldType < StandardError
-
-  def initialize(rule, field)
-    @rule = rule
-    @field = field
-  end
-
-  def to_s
-    rule = @rule
-    field = @field
-    "Field: #{field} has an incorrect value type for Validation Rule: #{rule}."
-  end
-
-end
-
-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 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
-
-class LengthValidationRule < 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[:min]
-      max = attributes[:max]
-      if min && max
-        "#{field_name} must have a min length of #{min} and a max length of #{max}"
-      elsif min
-        "#{field_name} must have a min length of #{min}"
-      else
-        "#{field_name} must have a max length of #{max}"
-      end
-    else
-      attributes[:message]
-    end
-  end
-
-  def validate(obj, field, attributes, parent = nil)
-
-    min = attributes[:min]
-    max = attributes[:max]
-
-    #verify the expected attributes have been specified.
-    if min == nil && max == nil
-      raise InvalidRuleAttributes.new(LengthValidationRule, field)
-    end
-
-    #attempt to get the field value from the object
-    field_value = get_field_value(obj, field)
-
-    #check if this validation check should be skipped
-    if !is_required?(field_value, attributes)
-      return true
-    end
-
-    if field_value.is_a?(Array)
-      length = field_value.length
-    else
-      length = field_value.to_s.length
-    end
-
-    #validate the field value
-    if min && max
-      return length >= min && length <= max
-    elsif min
-      return length >= min
-    elsif max
-      return length <= max
-    end
-
-    return false
-  end
-
-end
-
-class MinValidationRule < 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 InvalidRuleAttributes.new(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 InvalidFieldType.new(MinValidationRule, field)
-    end
-
-  end
-
-end
-
-class MaxValidationRule < 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 InvalidRuleAttributes.new(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 <= max
-    else
-      raise InvalidFieldType.new(MaxValidationRule, field)
-    end
-
-  end
-
-end
-
-class RequiredValidationRule < 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
-
-class EmailValidationRule < ValidationRule
-
-  REGEX = /^[^@]+@[^@]+\.[^@]+$/
-
-  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 email address"
-    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 !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
-
-class RegexValidationRule < 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 InvalidRuleAttributes.new(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
-
-class MatchValidationRule < 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 InvalidRuleAttributes.new(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
-
-class ConditionValidationRule < 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 valid"
-    else
-      attributes[:message]
-    end
-  end
-
-
-  def validate(obj, field, attributes, parent = nil)
-
-    #attempt to get the field value from the object
-    value = get_field_value(obj, field)
-
-    condition_field = attributes[:condition_field]
-    if condition_field == nil
-      raise InvalidRuleAttributes.new(ConditionValidationRule, field)
-    end
-
-    condition_value = attributes[:condition_value]
-    if condition_value == nil
-      raise InvalidRuleAttributes.new(ConditionValidationRule, field)
-    end
-
-    condition_expression = attributes[:condition_expression]
-    if condition_expression == nil
-      raise InvalidRuleAttributes.new(ConditionValidationRule, field)
-    end
-
-    field_expression = attributes[:field_expression]
-    if field_expression == nil
-      raise InvalidRuleAttributes.new(ConditionValidationRule, field)
-    end
-
-    field_value = attributes[:field_value]
-    if field_value == nil
-      raise InvalidRuleAttributes.new(ConditionValidationRule, field)
-    end
-
-    if !is_required?(value, attributes)
-      return true
-    end
-
-    condition_field_value = get_field_value(obj, condition_field)
-
-    #check if the condition is valid
-    if confirm_expression?(condition_field_value, condition_expression, condition_value)
-      #check if the field value is correct for the condition
-      if confirm_expression?(value, field_expression, field_value)
-        return true
-      else
-        return false
-      end
-    end
-
-    return true
-
-  end
-
-  def confirm_expression?(value_a, expression, value_b)
-    a = value_a
-    b = value_b
-
-    if value_a.is_a?(String)
-      a = "'#{value_a}'"
-    elsif value_a == nil
-      a = 'nil'
-    end
-
-    if value_b.is_a?(String)
-      b = "'#{value_b}'"
-    elsif value_b == nil
-      b = 'nil'
-    end
-
-    eval("#{a} #{expression} #{b}")
-  end
-
-end
-
-class NotAllowedValidationRule < 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
-
-class ListValidationRule < 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 an accepted value."
-    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 !is_required?(field_value, attributes)
-      return true
-    end
-
-    if field_value == nil
-      return false
-    end
-
-    list = attributes[:list]
-    if list == nil || !list.is_a?(Array)
-      raise InvalidRuleAttributes.new(ListValidationRule, field)
-    end
-
-    if !list.include?(field_value)
-      return false
-    end
-
-    return true
-
-  end
-
-end
-
-class ChildValidationRule < ValidationRule
-
-  def initialize
-    @validation_manager = ValidationManager.new
-  end
-
-  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 !is_required?(field_value, attributes)
-      return true
-    end
-
-    profile = attributes[:profile]
-    if profile == nil
-      raise InvalidRuleAttributes.new(ChildValidationRule, field)
-    end
-
-    if field_value == nil
-      return false
-    end
-
-    parent_field = field.to_s
-    if parent != nil
-      parent_field = "#{parent.to_s}.#{field.to_s}"
-    end
-
-    return @validation_manager.validate(field_value, profile, parent_field)
-
-  end
-
-end