pure_validator 0.3.0

data/lib/pure_validator/errors.rb

@@ -0,0 +1,23 @@
+module PureValidator::Errors
+  # Thrown when object has validation errors
+  class ValidationError < StandardError
+    attr_reader :errors
+
+    def initialize(message, errors)
+      @errors = errors
+      super(message)
+    end
+
+    def message
+      "#{@message}\n#{errors}"
+    end
+
+    def short_message
+      'Validation error'
+    end
+  end
+
+
+  # Thrown when validator is not defined
+  class MissingValidatorError < StandardError; end
+end

data/lib/pure_validator/i18n.rb

@@ -0,0 +1,7 @@
+class PureValidator::I18n
+
+  # Translates message to specific language
+  def self.t(message, options = {})
+    I18n.t("pure_validator.#{message}", options)
+  end
+end

data/lib/pure_validator/locales/en.yml

@@ -0,0 +1,24 @@
+en:
+  pure_validator:
+    errors:
+      invalid_email: "invalid email"
+      can_not_be_email: "can't be email"
+      should_not_be_included_in_list: "should not be included in %{list}"
+      should_be_included_in_list: "should be included in %{list}"
+      can_not_be_less_than: "can not be less than %{length}"
+      can_not_be_more_than: "can not be more than %{length}"
+      should_be_equal_to: "should be equal to %{length}"
+      should_not_be_equal_to: "should not be equal to %{length}"
+      can_not_be_nil: "can not be nil"
+      should_be_nil: "should be nil"
+      should_be_greater_than: "should be greater than %{number}"
+      should_be_greater_than_or_equal_to: "should be greater than or equal to %{number}"
+      should_be_less_than: "should be less than %{number}"
+      should_be_less_than_or_equal_to: "should be less than or equal to %{number}"
+      should_be_even: "should be even number"
+      should_be_odd: "should be odd number"
+      can_not_be_blank: "can not be blank"
+      should_be_blank: "should be blank"
+      does_not_match: "does not match defined format"
+      invalid_url: "invalid url"
+      can_not_be_url: "can not be a url"

data/lib/pure_validator/locales/ru.yml

@@ -0,0 +1,24 @@
+ru:
+  pure_validator:
+    errors:
+      invalid_email: "невалидный электронный адрес"
+      can_not_be_email: "не может быть адресом элекронной почты"
+      should_not_be_included_in_list: "не должен быть включен в список %{list}"
+      should_be_included_in_list: "должен быть включен в список %{list}"
+      can_not_be_less_than: "не может быть меньше чем %{length}"
+      can_not_be_more_than: "не может быть больше чем %{length}"
+      should_be_equal_to: "должен быть равен %{length}"
+      should_not_be_equal_to: "не должен быть равен %{length}"
+      can_not_be_nil: "не может быть пустым"
+      should_be_nil: "должен быть пустым"
+      should_be_greater_than: "должен быть больше чем %{number}"
+      should_be_greater_than_or_equal_to: "должен быть больше либо равен %{number}"
+      should_be_less_than: "должен быть меньше чем %{number}"
+      should_be_less_than_or_equal_to: "должен быть меньше либо равен %{number}"
+      should_be_even: "должен быть четным числом"
+      should_be_odd: "должен быть нечетным числом"
+      can_not_be_blank: "не может быть пустым"
+      should_be_blank: "должен быть пустым"
+      does_not_match: "неверный формат"
+      invalid_url: "невалидный адресс"
+      can_not_be_url: "не может быть адресом"

data/lib/pure_validator/validation_errors.rb

@@ -0,0 +1,248 @@
+class PureValidator::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
+    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 = humanize(attribute.to_s.tr('.', '_'))
+    # attr_name = @base.class.human_attribute_name(attribute, default: attr_name)
+    I18n.t(:"errors.format", {
+      default:  "%{attribute} %{message}",
+      attribute: attr_name,
+      message:   message
+    })
+  end
+
+  def humanize(value, options = {})
+    PureValidator::Humanize.humanize(value, options)
+  end
+end

data/lib/pure_validator/validator.rb

@@ -0,0 +1,150 @@
+module PureValidator::Validator
+  extend PureValidator::Concern
+
+  included do
+    class_attribute :validations, :associated_validations, :custom_validations
+  end
+
+  module ClassMethods
+    def validates(*args)
+      options = args.pop
+      PureValidator::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)
+      PureValidator::ArgsValidator.not_nil!(options[:validator], :validator)
+      PureValidator::ArgsValidator.is_class_or_symbol!(options[:validator], :validator)
+      PureValidator::ArgsValidator.is_symbol_or_block!(options[:if], :if) if options[:if]
+      PureValidator::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
+        PureValidator::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 = PureValidator.validators[validator_name]
+        unless validator
+          raise PureValidator::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 = PureValidator::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 PureValidator::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)
+    return unless options[:if] || options[:unless]
+    return handle_if_skip_validation(options)     if options[:if]
+    return handle_unless_skip_validation(options) if options[:unless]
+  end
+
+  def handle_if_skip_validation(options)
+    if options[:if].is_a?(Symbol)
+      return ! self.send(options[:if])
+    elsif options[:if].is_a?(Proc)
+      return ! self.instance_exec(&options[:if])
+    end
+  end
+
+  def handle_unless_skip_validation(options)
+    if options[:unless].is_a?(Symbol)
+      return self.send(options[:unless])
+    elsif options[:unless].is_a?(Proc)
+      return self.instance_exec(&options[:unless])
+    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/pure_validator/validators/email_validator.rb

@@ -0,0 +1,48 @@
+class PureValidator::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 << PureValidator::I18n.t("errors.invalid_email") unless !!EMAIL_ADDRESS.match(value)
+    else
+      errors << PureValidator::I18n.t("errors.can_not_be_email") if !!EMAIL_ADDRESS.match(value)
+    end
+    errors
+  end
+
+  def self.validate_options(email_flag)
+    PureValidator::ArgsValidator.is_boolean!(email_flag, :validation_rule)
+  end
+
+end

data/lib/pure_validator/validators/exclusion_validator.rb

@@ -0,0 +1,22 @@
+class PureValidator::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].include?(value)
+      errors << (options[:message] || PureValidator::I18n.t('errors.should_not_be_included_in_list', list: options[:in]))
+    end
+    errors
+  end
+
+  def self.validate_options(options)
+    PureValidator::ArgsValidator.is_hash!(options, :validation_rule)
+    PureValidator::ArgsValidator.has_key!(options, :in)
+    PureValidator::ArgsValidator.has_only_allowed_keys!(options, [:in, :message], :validation_rule)
+  end
+
+end

data/lib/pure_validator/validators/inclusion_validator.rb

@@ -0,0 +1,27 @@
+class PureValidator::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 = []
+    unless options[:in].include?(value)
+      errors << (options[:message] || PureValidator::I18n.t('errors.should_be_included_in_list', list: options[:in]))
+    end
+    errors
+  end
+
+  # Validates that options specified in
+  # :inclusion are valid
+  def self.validate_options(options)
+    PureValidator::ArgsValidator.is_hash!(options, 'validation options')
+    PureValidator::ArgsValidator.has_key!(options, :in)
+    PureValidator::ArgsValidator.has_only_allowed_keys!(options, [:in, :message], 'validation options')
+  end
+
+end

data/lib/pure_validator/validators/length_validator.rb

@@ -0,0 +1,32 @@
+class PureValidator::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 << PureValidator::I18n.t('errors.can_not_be_less_than', length: options[:min]) if object.length < options[:min]
+    end
+    if options[:max]
+      errors << PureValidator::I18n.t('errors.can_not_be_more_than', length: options[:max]) if object.length > options[:max]
+    end
+    if options[:equal_to]
+      errors << PureValidator::I18n.t('errors.should_be_equal_to', length: options[:equal_to]) if object.length != options[:equal_to]
+    end
+    if options[:not_equal_to]
+      errors << PureValidator::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)
+    PureValidator::ArgsValidator.is_hash!(options, :validation_rule)
+    PureValidator::ArgsValidator.has_only_allowed_keys!(options, [:min, :max, :equal_to, :not_equal_to], :validation_rule)
+  end
+
+end

data/lib/pure_validator/validators/not_nil_validator.rb

@@ -0,0 +1,25 @@
+class PureValidator::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 << PureValidator::I18n.t('errors.can_not_be_nil')
+      end
+    else
+      if value
+        errors << PureValidator::I18n.t('errors.should_be_nil')
+      end
+    end
+    errors
+  end
+
+  def self.validate_options(presence_flag)
+    PureValidator::ArgsValidator.is_boolean!(presence_flag, :validation_rule)
+  end
+
+end

data/lib/pure_validator/validators/numericality_validator.rb

@@ -0,0 +1,39 @@
+class PureValidator::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 << PureValidator::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 << PureValidator::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 << PureValidator::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 << PureValidator::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 << PureValidator::I18n.t('errors.should_be_even') unless number.even?
+    end
+    if options[:odd]
+      errors << PureValidator::I18n.t('errors.should_be_odd') unless number.odd?
+    end
+    errors
+  end
+
+  def self.validate_options(options)
+    PureValidator::ArgsValidator.is_hash!(options, :validation_rule)
+    PureValidator::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