attr_validator 0.0.1

data/lib/attr_validator/validation_errors.rb

@@ -0,0 +1,245 @@
+class AttrValidator::ValidationErrors
+  attr_reader :messages
+
+   def initialize
+      @messages = {}
+   end
+
+   # Clear the error messages.
+   #
+   #   errors.full_messages # => ["name can not be nil"]
+   #   errors.clear
+   #   errors.full_messages # => []
+   def clear
+     messages.clear
+   end
+
+    # Returns +true+ if the error messages include an error for the given key
+    # +attribute+, +false+ otherwise.
+    #
+    #   errors.messages        # => {:name=>["can not be nil"]}
+    #   errors.include?(:name) # => true
+    #   errors.include?(:age)  # => false
+    def include?(attribute)
+      (v = messages[attribute]) && v.any?
+    end
+    # aliases include?
+    alias :has_key? :include?
+
+    # Get messages for +key+.
+    #
+    #   errors.messages   # => {:name=>["can not be nil"]}
+    #   errors.get(:name) # => ["can not be nil"]
+    #   errors.get(:age)  # => nil
+    def get(key)
+      messages[key]
+    end
+
+    # Set messages for +key+ to +value+.
+    #
+    #   errors.get(:name) # => ["can not be nil"]
+    #   errors.set(:name, ["can't be nil"])
+    #   errors.get(:name) # => ["can't be nil"]
+    def set(key, value)
+      messages[key] = value
+    end
+
+    # Delete messages for +key+. Returns the deleted messages.
+    #
+    #   errors.get(:name)    # => ["can not be nil"]
+    #   errors.delete(:name) # => ["can not be nil"]
+    #   errors.get(:name)    # => nil
+    def delete(key)
+      messages.delete(key)
+    end
+
+    # When passed a symbol or a name of a method, returns an array of errors
+    # for the method.
+    #
+    #   errors[:name]  # => ["can not be nil"]
+    #   errors['name'] # => ["can not be nil"]
+    def [](attribute)
+      get(attribute.to_sym) || set(attribute.to_sym, [])
+    end
+
+    # Adds to the supplied attribute the supplied error message.
+    #
+    #   errors[:name] = "must be set"
+    #   errors[:name] # => ['must be set']
+    def []=(attribute, error)
+      self[attribute] << error
+    end
+
+    # Iterates through each error key, value pair in the error messages hash.
+    # Yields the attribute and the error for that attribute. If the attribute
+    # has more than one error message, yields once for each error message.
+    #
+    #   errors.add(:name, "can't be blank")
+    #   errors.each do |attribute, error|
+    #     # Will yield :name and "can't be blank"
+    #   end
+    #
+    #   errors.add(:name, "must be specified")
+    #   errors.each do |attribute, error|
+    #     # Will yield :name and "can't be blank"
+    #     # then yield :name and "must be specified"
+    #   end
+    def each
+      messages.each_key do |attribute|
+        self[attribute].each { |error| yield attribute, error }
+      end
+    end
+
+    # Returns the number of error messages.
+    #
+    #   errors.add(:name, "can't be blank")
+    #   errors.size # => 1
+    #   errors.add(:name, "must be specified")
+    #   errors.size # => 2
+    def size
+      values.flatten.size
+    end
+
+    # Returns all message values.
+    #
+    #   errors.messages # => {:name=>["can not be nil", "must be specified"]}
+    #   errors.values   # => [["can not be nil", "must be specified"]]
+    def values
+      messages.values
+    end
+
+    # Returns all message keys.
+    #
+    #   errors.messages # => {:name=>["can not be nil", "must be specified"]}
+    #   errors.keys     # => [:name]
+    def keys
+      messages.keys
+    end
+
+    # Returns an array of error messages, with the attribute name included.
+    #
+    #   errors.add(:name, "can't be blank")
+    #   errors.add(:name, "must be specified")
+    #   errors.to_a # => ["name can't be blank", "name must be specified"]
+    def to_a
+      full_messages
+    end
+
+    # Returns the number of error messages.
+    #
+    #   errors.add(:name, "can't be blank")
+    #   errors.count # => 1
+    #   errors.add(:name, "must be specified")
+    #   errors.count # => 2
+    def count
+      to_a.size
+    end
+
+    # Returns +true+ if no errors are found, +false+ otherwise.
+    # If the error message is a string it can be empty.
+    #
+    #   errors.full_messages # => ["name can not be nil"]
+    #   errors.empty?        # => false
+    def empty?
+      messages.all? { |k, v| v && v.empty? && !v.is_a?(String) }
+    end
+    # aliases empty?
+    alias_method :blank?, :empty?
+
+    # Returns a Hash of attributes with their error messages. If +full_messages+
+    # is +true+, it will contain full messages (see +full_message+).
+    #
+    #   errors.to_hash       # => {:name=>["can not be nil"]}
+    #   errors.to_hash(true) # => {:name=>["name can not be nil"]}
+    def to_hash(full_messages = false)
+      if full_messages
+        messages = {}
+        self.messages.each do |attribute, array|
+          messages[attribute] = array.map { |message| full_message(attribute, message) }
+        end
+        messages
+      else
+        self.messages.dup
+      end
+    end
+
+    # Adds +message+ to the error messages on +attribute+. More than one error
+    # can be added to the same +attribute+
+    #
+    #   errors.add(:name, 'is invalid')
+    #   # => ["is invalid"]
+    #   errors.add(:name, 'must be implemented')
+    #   # => ["is invalid", "must be implemented"]
+    #
+    #   errors.messages
+    #   # => {:name=>["must be implemented", "is invalid"]}
+    #
+    # If +message+ is a proc, it will be called, allowing for things like
+    # <tt>Time.now</tt> to be used within an error.
+    #
+    #   errors.messages # => {}
+    def add(attribute, message)
+      self[attribute] << message
+    end
+
+    # Adds +messages+ to the error messages on +attribute+.
+    #
+    #   errors.add(:name, ['is invalid', 'must present'])
+    #   # => ["is invalid", "must present"]
+    def add_all(attribute, errors)
+      messages[attribute] ||= []
+      messages[attribute] += errors
+    end
+
+    # Returns +true+ if an error on the attribute with the given message is
+    # present, +false+ otherwise. +message+ is treated the same as for +add+.
+    #
+    #   errors.add :name, :blank
+    #   errors.added? :name, :blank # => true
+    def added?(attribute, message)
+      self[attribute].include? message
+    end
+
+    # Returns all the full error messages in an array.
+    #
+    #   class PersonValidator
+    #     validates :name, :address, :email, presence: true
+    #     validates :name, length: { min: 5, max: 30 }
+    #   end
+    #
+    #   = create(address: '123 First St.')
+    #   errors.full_messages
+    #   # => ["Name is too short (minimum is 5 characters)", "Name can't be blank", "Email can't be blank"]
+    def full_messages
+      map { |attribute, message| full_message(attribute, message) }
+    end
+
+    # Returns all the full error messages for a given attribute in an array.
+    #
+    #   class PersonValidator
+    #     validates :name, :address, :email, presence: true
+    #     validates :name, length: { min: 5, max: 30 }
+    #   end
+    #
+    #   = create()
+    #   errors.full_messages_for(:name)
+    #   # => ["Name is too short (minimum is 5 characters)", "Name can't be blank"]
+    def full_messages_for(attribute)
+      (get(attribute) || []).map { |message| full_message(attribute, message) }
+    end
+
+    # Returns a full message for a given attribute.
+    #
+    #   errors.full_message(:name, 'is invalid') # => "Name is invalid"
+    def full_message(attribute, message)
+      return message if attribute == :base
+      attr_name = attribute.to_s.tr('.', '_').humanize
+      attr_name = @base.class.human_attribute_name(attribute, default: attr_name)
+      I18n.t(:"errors.format", {
+        default:  "%{attribute} %{message}",
+        attribute: attr_name,
+        message:   message
+      })
+    end
+
+end

data/lib/attr_validator/validator.rb

@@ -0,0 +1,148 @@
+module AttrValidator::Validator
+  extend AttrValidator::Concern
+
+  included do
+    class_attribute :validations, :associated_validations, :custom_validations
+  end
+
+  module ClassMethods
+    def validates(*args)
+      options = args.pop
+      AttrValidator::ArgsValidator.is_hash!(options, "last argument")
+
+      self.validations ||= {}
+      args.each do |attr_name|
+        add_validations(attr_name, options)
+      end
+    end
+
+    def validate_associated(association_name, options)
+      AttrValidator::ArgsValidator.not_nil!(options[:validator], :validator)
+      AttrValidator::ArgsValidator.is_class_or_symbol!(options[:validator], :validator)
+      AttrValidator::ArgsValidator.is_symbol_or_block!(options[:if], :if) if options[:if]
+      AttrValidator::ArgsValidator.is_symbol_or_block!(options[:unless], :unless) if options[:unless]
+
+      self.associated_validations ||= {}
+      self.associated_validations[association_name] = options
+    end
+
+    def validate(method_name = nil, &block)
+      self.custom_validations ||= []
+      if block_given?
+        self.custom_validations << block
+      elsif method_name
+        AttrValidator::ArgsValidator.is_symbol!(method_name, "validate method name")
+        self.custom_validations << method_name
+      else
+        raise ArgumentError, "method name or block should be given for validate"
+      end
+    end
+
+    private
+
+    def add_validations(attr_name, options)
+      self.validations[attr_name] ||= {}
+      options.each do |validator_name, validation_options|
+        validator = AttrValidator.validators[validator_name]
+        unless validator
+          raise AttrValidator::Errors::MissingValidatorError, "Validator with name '#{validator_name}' doesn't exist"
+        end
+        validator.validate_options(validation_options)
+        self.validations[attr_name][validator] = validation_options
+      end
+    end
+  end
+
+  def validate(entity)
+    errors = AttrValidator::ValidationErrors.new
+    self.validations ||= {}
+    self.custom_validations ||= []
+    self.associated_validations ||= {}
+
+    self.validations.each do |attr_name, validators|
+      error_messages = validate_attr(attr_name, entity, validators)
+      errors.add_all(attr_name, error_messages) unless error_messages.empty?
+    end
+    self.associated_validations.each do |association_name, options|
+      next if skip_validation?(options)
+      validator = options[:validator].is_a?(Class) ? options[:validator].new : self.send(options[:validator])
+      children = entity.send(association_name)
+      if children.is_a?(Array)
+        validate_children(association_name, validator, children, errors)
+      elsif children
+        validate_child(association_name, validator, children, errors)
+      end
+    end
+    self.custom_validations.each do |custom_validation|
+      if custom_validation.is_a?(Symbol)
+        self.send(custom_validation, entity, errors)
+      else # it's Proc
+        custom_validation.call(entity, errors)
+      end
+    end
+    errors.to_hash
+  end
+
+  def validate!(entity)
+    errors = validate(entity)
+    unless errors.empty?
+      raise AttrValidator::Errors::ValidationError.new("Validation Error", errors)
+    end
+  end
+
+  private
+
+  def validate_attr(attr_name, entity, validators)
+    attr_value = entity.send(attr_name)
+    error_messages = []
+    validators.each do |validator, validation_rule|
+      error_messages = validator.validate(attr_value, validation_rule)
+      break unless error_messages.empty?
+    end
+    error_messages
+  end
+
+  def skip_validation?(options)
+    if options[:if]
+      if options[:if].is_a?(Symbol)
+        true unless self.send(options[:if])
+      elsif options[:if].is_a?(Proc)
+        true unless self.instance_exec(&options[:if])
+      else
+        false
+      end
+    elsif options[:unless]
+      if options[:unless].is_a?(Symbol)
+        true if self.send(options[:unless])
+      elsif options[:unless].is_a?(Proc)
+        true if self.instance_exec(&options[:unless])
+      else
+        false
+      end
+    end
+  end
+
+  def validate_children(association_name, validator, children, errors)
+    if validator.respond_to?(:validate_all)
+      children_errors = validator.validate_all(children)
+    elsif validator.respond_to?(:validate)
+      children_errors = children.inject([]) do |errors, child|
+        errors << validator.validate(child).to_hash
+      end
+    else
+      raise NotImplementedError, "Validator should respond at least to :validate or :validate_all"
+    end
+    unless children_errors.all?(&:empty?)
+      errors.messages["#{association_name}_errors".to_sym] ||= []
+      errors.messages["#{association_name}_errors".to_sym] += children_errors
+    end
+  end
+
+  def validate_child(association_name, validator, child, errors)
+    child_errors = validator.validate(child).to_hash
+    unless child_errors.empty?
+      errors.messages["#{association_name}_errors".to_sym] = child_errors
+    end
+  end
+
+end

data/lib/attr_validator/validators/email_validator.rb

@@ -0,0 +1,48 @@
+class AttrValidator::Validators::EmailValidator
+  # This rule was adapted from https://github.com/emmanuel/aequitas/blob/master/lib/aequitas/rule/format/email_address.rb
+  EMAIL_ADDRESS = begin
+    letter         = 'a-zA-Z'
+    digit          = '0-9'
+    atext          = "[#{letter}#{digit}\!\#\$\%\&\'\*+\/\=\?\^\_\`\{\|\}\~\-]"
+    dot_atom_text  = "#{atext}+([.]#{atext}*)+"
+    dot_atom       = dot_atom_text
+    no_ws_ctl      = '\x01-\x08\x11\x12\x14-\x1f\x7f'
+    qtext          = "[^#{no_ws_ctl}\\x0d\\x22\\x5c]"  # Non-whitespace, non-control character except for \ and "
+    text           = '[\x01-\x09\x11\x12\x14-\x7f]'
+    quoted_pair    = "(\\x5c#{text})"
+    qcontent       = "(?:#{qtext}|#{quoted_pair})"
+    quoted_string  = "[\"]#{qcontent}+[\"]"
+    atom           = "#{atext}+"
+    word           = "(?:#{atom}|#{quoted_string})"
+    obs_local_part = "#{word}([.]#{word})*"
+    local_part     = "(?:#{dot_atom}|#{quoted_string}|#{obs_local_part})"
+    dtext          = "[#{no_ws_ctl}\\x21-\\x5a\\x5e-\\x7e]"
+    dcontent       = "(?:#{dtext}|#{quoted_pair})"
+    domain_literal = "\\[#{dcontent}+\\]"
+    obs_domain     = "#{atom}([.]#{atom})+"
+    domain         = "(?:#{dot_atom}|#{domain_literal}|#{obs_domain})"
+    addr_spec      = "#{local_part}\@#{domain}"
+    pattern        = /\A#{addr_spec}\z/u
+  end
+
+  # Validates that value actually is email
+  # @param value   [String] object to validate
+  # @param email_flag [Boolean] should be given string be email or not
+  # @return [Array] empty array if string is valid, array with error message otherwise
+  def self.validate(value, email_flag)
+    return [] if value.nil?
+
+    errors = []
+    if email_flag
+      errors << AttrValidator::I18n.t("errors.invalid_email") unless !!EMAIL_ADDRESS.match(value)
+    else
+      errors << AttrValidator::I18n.t("errors.can_not_be_email") if !!EMAIL_ADDRESS.match(value)
+    end
+    errors
+  end
+
+  def self.validate_options(email_flag)
+    AttrValidator::ArgsValidator.is_boolean!(email_flag, :validation_rule)
+  end
+
+end

data/lib/attr_validator/validators/exclusion_validator.rb

@@ -0,0 +1,23 @@
+class AttrValidator::Validators::ExclusionValidator
+
+  # Validates that value isn't in the specified list validation.in
+  # @param value Object object to validate exclusion
+  # @return Boolean true if object is excluded, false otherwise
+  def self.validate(value, options)
+    return [] if value.nil?
+
+    errors = []
+    if options[:in]
+      if options[:in].include?(value)
+        errors << (options[:message] || AttrValidator::I18n.t('errors.should_not_be_included_in_list', list: options[:in]))
+      end
+    end
+    errors
+  end
+
+  def self.validate_options(options)
+    AttrValidator::ArgsValidator.is_hash!(options, :validation_rule)
+    AttrValidator::ArgsValidator.has_only_allowed_keys!(options, [:in, :message], :validation_rule)
+  end
+
+end

data/lib/attr_validator/validators/inclusion_validator.rb

@@ -0,0 +1,28 @@
+class AttrValidator::Validators::InclusionValidator
+
+  # Validates that given value inscluded in the specified list
+  # @param value [Object] object to validate
+  # @parm options [Hash] validation options, e.g. { in: [:small, :medium, :large], message: "not included in the list of allowed items" }
+  #                      where :in - list of allowed values,
+  #                      message - is a message to return if value is not included in the list
+  # @return Boolean true if object is included in the list, false otherwise
+  def self.validate(value, options)
+    return [] if value.nil?
+
+    errors = []
+    if options[:in]
+      unless options[:in].include?(value)
+        errors << (options[:message] || AttrValidator::I18n.t('errors.should_be_included_in_list', list: options[:in]))
+      end
+    end
+    errors
+  end
+
+  # Validates that options specified in
+  # :inclusion are valid
+  def self.validate_options(options)
+    AttrValidator::ArgsValidator.is_hash!(options, 'validation options')
+    AttrValidator::ArgsValidator.has_only_allowed_keys!(options, [:in, :message], 'validation options')
+  end
+
+end

data/lib/attr_validator/validators/length_validator.rb

@@ -0,0 +1,32 @@
+class AttrValidator::Validators::LengthValidator
+
+  # Validates that given object has correct length
+  # @param object [#length] object to validate
+  # @param options [Hash] validation options, e.g. { min: 2, max: 4, equal_to: 3, not_equal_to: 6 }
+  # @return [Array] empty array if object is valid, array of error messages otherwise
+  def self.validate(object, options)
+    return [] if object.nil?
+
+    errors = []
+    if options[:min]
+      errors << AttrValidator::I18n.t('errors.can_not_be_less_than', length: options[:min]) if object.length < options[:min]
+    end
+    if options[:max]
+      errors << AttrValidator::I18n.t('errors.can_not_be_more_than', length: options[:max]) if object.length > options[:max]
+    end
+    if options[:equal_to]
+      errors << AttrValidator::I18n.t('errors.should_be_equal_to', length: options[:equal_to]) if object.length != options[:equal_to]
+    end
+    if options[:not_equal_to]
+      errors << AttrValidator::I18n.t('errors.should_not_be_equal_to', length: options[:not_equal_to]) if object.length == options[:not_equal_to]
+    end
+
+    errors
+  end
+
+  def self.validate_options(options)
+    AttrValidator::ArgsValidator.is_hash!(options, :validation_rule)
+    AttrValidator::ArgsValidator.has_only_allowed_keys!(options, [:min, :max, :equal_to, :not_equal_to], :validation_rule)
+  end
+
+end

data/lib/attr_validator/validators/not_nil_validator.rb

@@ -0,0 +1,25 @@
+class AttrValidator::Validators::NotNilValidator
+
+  # Validates that given object not nil
+  # @param value    [Object] object to validate
+  # @param presence [Boolean] validation options, check presence or not
+  # @return [Array] empty array if object is valid, array of error messages otherwise
+  def self.validate(value, presence)
+    errors = []
+    if presence
+      if value.nil?
+        errors << AttrValidator::I18n.t('errors.can_not_be_nil')
+      end
+    else
+      if value
+        errors << AttrValidator::I18n.t('errors.should_be_nil')
+      end
+    end
+    errors
+  end
+
+  def self.validate_options(presence_flag)
+    AttrValidator::ArgsValidator.is_boolean!(presence_flag, :validation_rule)
+  end
+
+end

data/lib/attr_validator/validators/numericality_validator.rb

@@ -0,0 +1,39 @@
+class AttrValidator::Validators::NumericalityValidator
+
+  # Validates that +number+ satisfies all validation rules defined in +options+
+  # @param number  [Numeric] number to validate
+  # @param options [Hash]    validation rules
+  # @return [Array] empty array if number is valid, array of error messages otherwise
+  def self.validate(number, options)
+    return [] if number.nil?
+
+    errors = []
+    if options[:greater_than]
+      errors << AttrValidator::I18n.t('errors.should_be_greater_than', number: options[:greater_than]) if number <= options[:greater_than]
+    end
+    if options[:greater_than_or_equal_to]
+      errors << AttrValidator::I18n.t('errors.should_be_greater_than_or_equal_to', number: options[:greater_than_or_equal_to]) if number < options[:greater_than_or_equal_to]
+    end
+    if options[:less_than]
+      errors << AttrValidator::I18n.t('errors.should_be_less_than', number: options[:less_than]) if number >= options[:less_than]
+    end
+    if options[:less_than_or_equal_to]
+      errors << AttrValidator::I18n.t('errors.should_be_less_than_or_equal_to', number: options[:less_than_or_equal_to]) if number > options[:less_than_or_equal_to]
+    end
+    if options[:even]
+      errors << AttrValidator::I18n.t('errors.should_be_even') unless number.even?
+    end
+    if options[:odd]
+      errors << AttrValidator::I18n.t('errors.should_be_odd') unless number.odd?
+    end
+    errors
+  end
+
+  def self.validate_options(options)
+    AttrValidator::ArgsValidator.is_hash!(options, :validation_rule)
+    AttrValidator::ArgsValidator.has_only_allowed_keys!(options, [
+      :greater_than, :greater_than_or_equal_to, :less_than, :less_than_or_equal_to, :even, :odd
+    ], :validation_rule)
+  end
+
+end

data/lib/attr_validator/validators/presence_validator.rb

@@ -0,0 +1,26 @@
+class AttrValidator::Validators::PresenceValidator
+
+  # Validates that given object not nil and not empty
+  # if string is given strips it before validating
+  # @param value   [Object] object to validate
+  # @param presence [Boolean] check presence or not
+  # @return [Array] empty array if number is valid, array of error messages otherwise
+  def self.validate(value, presence)
+    errors = []
+    if presence
+      if value.nil? || (value.is_a?(String) && value.strip.length == 0)
+        errors << AttrValidator::I18n.t('errors.can_not_be_blank')
+      end
+    else
+      if value
+        errors << AttrValidator::I18n.t('errors.should_be_blank')
+      end
+    end
+    errors
+  end
+
+  def self.validate_options(presence_flag)
+    AttrValidator::ArgsValidator.is_boolean!(presence_flag, :validation_rule)
+  end
+
+end

data/lib/attr_validator/validators/regexp_validator.rb

@@ -0,0 +1,21 @@
+class AttrValidator::Validators::RegexpValidator
+
+  # Validates that given value match regexp if regexp validation exists
+  # @param value String value to match with regexp
+  # @param regexp [Regexp] regexp to match
+  # @return [Array] empty array if number is valid, array of error messages otherwise
+  def self.validate(value, regexp)
+    return [] if value.nil?
+
+    errors = []
+    unless !!regexp.match(value)
+      errors << AttrValidator::I18n.t('errors.does_not_match')
+    end
+    errors
+  end
+
+  def self.validate_options(regexp)
+    AttrValidator::ArgsValidator.is_string_or_regexp!(regexp, :validation_rule)
+  end
+
+end

data/lib/attr_validator/validators/url_validator.rb

@@ -0,0 +1,25 @@
+class AttrValidator::Validators::UrlValidator
+  URL_REGEXP = /^(https?:\/\/)?([\w\.]+)\.([a-z]{2,6}\.?)(\/[\w\.]*)*\/?$/
+
+  # Validates that string is a valid url
+  # @param value [String] string to validate
+  # @param url [Boolean] should given string be url or not
+  # @return [Array] empty array if number is valid, array of error messages otherwise
+  def self.validate(value, url_flag)
+    return [] if value.nil?
+
+    errors = []
+    if url_flag
+      errors << AttrValidator::I18n.t('errors.invalid_url') unless !!URL_REGEXP.match(value)
+    else
+      errors << AttrValidator::I18n.t('errors.can_not_be_url') if !!URL_REGEXP.match(value)
+    end
+
+    errors
+  end
+
+  def self.validate_options(url_flag)
+    AttrValidator::ArgsValidator.is_boolean!(url_flag, :validation_rule)
+  end
+
+end

data/lib/attr_validator/validators.rb

@@ -0,0 +1,11 @@
+module AttrValidator::Validators
+  require 'attr_validator/validators/exclusion_validator'
+  require 'attr_validator/validators/inclusion_validator'
+  require 'attr_validator/validators/email_validator'
+  require 'attr_validator/validators/url_validator'
+  require 'attr_validator/validators/length_validator'
+  require 'attr_validator/validators/numericality_validator'
+  require 'attr_validator/validators/presence_validator'
+  require 'attr_validator/validators/not_nil_validator'
+  require 'attr_validator/validators/regexp_validator'
+end

data/lib/attr_validator/version.rb

@@ -0,0 +1,3 @@
+module AttrValidator
+  VERSION = "0.0.1"
+end