pure_validator 0.3.0

data/lib/pure_validator/validators/presence_validator.rb

@@ -0,0 +1,26 @@
+class PureValidator::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 << PureValidator::I18n.t('errors.can_not_be_blank')
+      end
+    else
+      if value
+        errors << PureValidator::I18n.t('errors.should_be_blank')
+      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/regexp_validator.rb

@@ -0,0 +1,21 @@
+class PureValidator::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 << PureValidator::I18n.t('errors.does_not_match')
+    end
+    errors
+  end
+
+  def self.validate_options(regexp)
+    PureValidator::ArgsValidator.is_string_or_regexp!(regexp, :validation_rule)
+  end
+
+end

data/lib/pure_validator/validators/url_validator.rb

@@ -0,0 +1,25 @@
+class PureValidator::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 << PureValidator::I18n.t('errors.invalid_url') unless !!URL_REGEXP.match(value)
+    else
+      errors << PureValidator::I18n.t('errors.can_not_be_url') if !!URL_REGEXP.match(value)
+    end
+
+    errors
+  end
+
+  def self.validate_options(url_flag)
+    PureValidator::ArgsValidator.is_boolean!(url_flag, :validation_rule)
+  end
+
+end

data/lib/pure_validator/validators.rb

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

data/lib/pure_validator/version.rb

@@ -0,0 +1,3 @@
+module PureValidator
+  VERSION = "0.3.0"
+end

data/lib/pure_validator.rb

@@ -0,0 +1,43 @@
+require 'i18n'
+require 'pure_validator/core_extensions/class_attribute'
+require 'pure_validator/core_extensions/humanize'
+require 'pure_validator/concern'
+require 'pure_validator/version'
+require 'pure_validator/errors'
+require 'pure_validator/args_validator'
+require 'pure_validator/validator'
+require 'pure_validator/i18n'
+require 'pure_validator/validators'
+require 'pure_validator/validation_errors'
+
+module PureValidator
+  @@validators = {}
+
+  # Returns list of defined validators
+  def self.validators
+    @@validators
+  end
+
+  # Adds new validator to PureValidator
+  # @param validator_name [Symbol] validator name
+  # @param validator      [.validate, .validation_options] validator
+  def self.add_validator(validator_name, validator)
+    @@validators[validator_name] = validator
+  end
+end
+
+PureValidator.add_validator(:email,        PureValidator::Validators::EmailValidator)
+PureValidator.add_validator(:exclusion,    PureValidator::Validators::ExclusionValidator)
+PureValidator.add_validator(:inclusion,    PureValidator::Validators::InclusionValidator)
+PureValidator.add_validator(:length,       PureValidator::Validators::LengthValidator)
+PureValidator.add_validator(:numericality, PureValidator::Validators::NumericalityValidator)
+PureValidator.add_validator(:presence,     PureValidator::Validators::PresenceValidator)
+PureValidator.add_validator(:not_blank,    PureValidator::Validators::PresenceValidator)
+PureValidator.add_validator(:not_nil,      PureValidator::Validators::NotNilValidator)
+PureValidator.add_validator(:regexp,       PureValidator::Validators::RegexpValidator)
+PureValidator.add_validator(:url,          PureValidator::Validators::UrlValidator)
+
+# I18n settings
+I18n.load_path += Dir[File.dirname(__FILE__) +'/pure_validator/locales/*.yml']
+I18n.default_locale = :en
+I18n.reload!

data/pure_validator.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pure_validator/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "pure_validator"
+  spec.version       = PureValidator::VERSION
+  spec.authors       = ["Albert Gazizov", "Roman Heinrich"]
+  spec.email         = ["deeper4k@gmail.com"]
+  spec.description   = %q{Object validation library}
+  spec.summary       = %q{Moves validation logic to validators}
+  spec.homepage      = "http://github.com/ddd-ruby/pure_validator"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(spec)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency             "i18n"
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "codecov"
+  spec.add_development_dependency "byebug"
+end

data/spec/pure_validator/args_validator_spec.rb

@@ -0,0 +1,169 @@
+require "spec_helper"
+
+describe PureValidator::ArgsValidator do
+  context "::is_symbol!" do
+    it "works with symbol" do
+      PureValidator::ArgsValidator.is_symbol!(:symbol, "some.name")
+    end
+
+    it "raises else" do
+      expect{
+        PureValidator::ArgsValidator.is_symbol!("symbol", "some.name")
+      }.to raise_error(PureValidator::ArgsValidator::ArgError, "some.name should be a Symbol")
+    end
+  end
+
+  context "::is_boolean!" do
+    it "works with boolean" do
+      PureValidator::ArgsValidator.is_boolean!(true, "some.name")
+      PureValidator::ArgsValidator.is_boolean!(false, "some.name")
+    end
+
+    it "raises else" do
+      expect{
+        PureValidator::ArgsValidator.is_boolean!("true", "some.name")
+      }.to raise_error(PureValidator::ArgsValidator::ArgError, "some.name should be a Boolean")
+    end
+  end
+
+  context "::is_integer!" do
+    it "works with integer" do
+      PureValidator::ArgsValidator.is_integer!(1, "some.name")
+      PureValidator::ArgsValidator.is_integer!(0, "some.name")
+    end
+
+    it "raises else" do
+      expect{
+        PureValidator::ArgsValidator.is_integer!("true", "some.name")
+      }.to raise_error(PureValidator::ArgsValidator::ArgError, "some.name should be an Integer")
+    end
+  end
+
+  context "::is_array!" do
+    it "works with array" do
+      PureValidator::ArgsValidator.is_array!([], "some.name")
+      PureValidator::ArgsValidator.is_array!([1], "some.name")
+    end
+
+    it "raises else" do
+      expect{
+        PureValidator::ArgsValidator.is_array!("true", "some.name")
+      }.to raise_error(PureValidator::ArgsValidator::ArgError, "some.name should be an Array")
+    end
+  end
+
+  context "::is_hash!" do
+    it "works with hash" do
+      PureValidator::ArgsValidator.is_hash!({}, "some.name")
+      PureValidator::ArgsValidator.is_hash!({a:1}, "some.name")
+    end
+
+    it "raises else" do
+      expect{
+        PureValidator::ArgsValidator.is_hash!("true", "some.name")
+      }.to raise_error(PureValidator::ArgsValidator::ArgError, "some.name should be a Hash")
+    end
+  end
+
+  context "::is_integer_or_float!" do
+    it "works with integer or float" do
+      PureValidator::ArgsValidator.is_integer_or_float!(1, "some.name")
+      PureValidator::ArgsValidator.is_integer_or_float!(1.3, "some.name")
+    end
+
+    it "raises else" do
+      expect{
+        PureValidator::ArgsValidator.is_integer_or_float!("true", "some.name")
+      }.to raise_error(PureValidator::ArgsValidator::ArgError, "some.name should be an Integer or Float")
+    end
+  end
+
+  context "::is_string_or_regexp!" do
+    it "works with string or regexp" do
+      PureValidator::ArgsValidator.is_string_or_regexp!("string", "some.name")
+      PureValidator::ArgsValidator.is_string_or_regexp!(/regex/, "some.name")
+    end
+
+    it "raises else" do
+      expect{
+        PureValidator::ArgsValidator.is_string_or_regexp!(1, "some.name")
+      }.to raise_error(PureValidator::ArgsValidator::ArgError, "some.name should be a String or Regexp")
+    end
+  end
+
+  context "::is_class_or_symbol!" do
+    it "works with class or symbol" do
+      PureValidator::ArgsValidator.is_class_or_symbol!(:symbol, "some.name")
+      PureValidator::ArgsValidator.is_class_or_symbol!(String, "some.name")
+    end
+
+    it "raises else" do
+      expect{
+        PureValidator::ArgsValidator.is_class_or_symbol!(1, "some.name")
+      }.to raise_error(PureValidator::ArgsValidator::ArgError, "some.name should be a Symbol or Class")
+    end
+  end
+
+  context "::is_symbol_or_block!" do
+    it "works with symbol or block" do
+      PureValidator::ArgsValidator.is_symbol_or_block!(:symbol, "some.name")
+      PureValidator::ArgsValidator.is_symbol_or_block!(-> {puts 1}, "some.name")
+    end
+
+    it "raises else" do
+      expect{
+        PureValidator::ArgsValidator.is_symbol_or_block!(1, "some.name")
+      }.to raise_error(PureValidator::ArgsValidator::ArgError, "some.name should be a Symbol or Proc")
+    end
+  end
+
+  context "::has_key!" do
+    it "works when hash has a key" do
+      PureValidator::ArgsValidator.has_key!({a: 1}, :a)
+      PureValidator::ArgsValidator.has_key!({b: 1}, :b)
+    end
+
+    it "raises else" do
+      expect{
+        PureValidator::ArgsValidator.has_key!({a: 1}, :b)
+      }.to raise_error(PureValidator::ArgsValidator::ArgError, "{:a=>1} should have 'b' key")
+    end
+  end
+
+  context "::not_nil!" do
+    it "works when hash has a key" do
+      PureValidator::ArgsValidator.not_nil!(1, "some.name")
+      PureValidator::ArgsValidator.not_nil!(true, "some.name")
+    end
+
+    it "raises else" do
+      expect{
+        PureValidator::ArgsValidator.not_nil!(nil, "some.name")
+      }.to raise_error(PureValidator::ArgsValidator::ArgError, "some.name can't be nil")
+    end
+  end
+
+  context "::has_only_allowed_keys!" do
+    it "works when hash has a key" do
+      PureValidator::ArgsValidator.has_only_allowed_keys!({a: 1, b: 2}, [:a, :b, :c], "some.name")
+    end
+
+    it "raises else" do
+      expect{
+        PureValidator::ArgsValidator.has_only_allowed_keys!({a: 1, b: 2}, [:a, :c], "some.name")
+      }.to raise_error(PureValidator::ArgsValidator::ArgError, "some.name has unacceptable options [:b]")
+    end
+  end
+
+  context "::block_given!" do
+    it "works when hash has a key" do
+      PureValidator::ArgsValidator.block_given!(true)
+    end
+
+    it "raises else" do
+      expect{
+        PureValidator::ArgsValidator.block_given!(false)
+      }.to raise_error(PureValidator::ArgsValidator::ArgError, "Block should be given")
+    end
+  end
+end

data/spec/pure_validator/errors_spec.rb

@@ -0,0 +1,10 @@
+require "spec_helper"
+
+
+describe "PureValidator::Errors::ValidationError" do
+  it "works" do
+    error = PureValidator::Errors::ValidationError.new("wrong", [:a, :b])
+    expect(error.message).to eq("\n[:a, :b]")
+    expect(error.short_message).to eq("Validation error")
+  end
+end

data/spec/pure_validator/validation_errors_spec.rb

@@ -0,0 +1,109 @@
+require "spec_helper"
+
+
+describe "PureValidator::ValidationErrors" do
+  let(:errors){PureValidator::ValidationErrors.new}
+
+
+  context "construction" do
+    it "works with :add" do
+      errors.add(:name, 'is invalid')
+      expect(errors.size).to eq(1)
+    end
+
+    it "works with []=" do
+      errors[:name] = 'is invalid'
+      expect(errors.size).to eq(1)
+      expect(errors.count).to eq(1)
+    end
+  end
+
+  context ":clear" do
+    it "clears messages" do
+      errors.add(:name, 'is invalid')
+      expect(errors.size).to eq(1)
+      errors.clear
+      expect(errors.size).to eq(0)
+    end
+  end
+
+  context "include?" do
+    it "checks if message already present" do
+      errors.add(:name, 'is invalid')
+      expect(errors.include?(:name)).to eq(true)
+      expect(errors.include?(:names)).not_to eq(true)
+    end
+  end
+
+  context "delete" do
+    it "removes message" do
+      errors.add(:name, 'is invalid')
+      errors.add(:age, 'is invalid')
+      expect(errors.include?(:age)).to eq(true)
+      errors.delete(:age)
+      expect(errors.include?(:age)).not_to eq(true)
+    end
+  end
+
+
+  context "each" do
+    it "yields name, error" do
+      errors.add(:name, "must be specified")
+      errors.each do |attribute, error|
+        expect(attribute).to eq(:name)
+        expect(error).to eq("must be specified")
+      end
+    end
+  end
+
+  context "keys" do
+    it "returns attribute names" do
+      errors.add(:name, "must be specified")
+      errors.add(:age, "must be specified")
+      expect(errors.keys).to eq([:name, :age])
+    end
+  end
+
+
+  context "added?" do
+    it "Returns +true+ if an error on the attribute with the given message is present" do
+      errors.add :name, :blank
+      expect(errors.added?(:name, :blank)).to eq(true)
+    end
+  end
+
+  context "full_messages" do
+    it "returns attribute names" do
+      errors.add(:name, "must be specified")
+      errors.add(:age, "must be specified")
+      expect(errors.full_messages).to eq(["Name [\"must be specified\"]", "Age [\"must be specified\"]"])
+    end
+  end
+
+  context "full_messages_for" do
+    it "returns attribute names" do
+      errors.add(:name, "must be specified")
+      errors.add(:name, "min. 3 chars")
+      expect(errors.full_messages_for(:name)).to eq(["Name must be specified", "Name min. 3 chars"])
+    end
+  end
+
+  context "to_hash" do
+    it "Returns a Hash of attributes with their error messages" do
+      errors.add(:name, "must be specified")
+      errors.add(:name, "min. 3 chars")
+      expect(errors.to_hash).to eq({:name => ["must be specified", "min. 3 chars"]})
+      expect(errors.to_hash(true)).to eq({:name => ["Name must be specified", "Name min. 3 chars"]})
+    end
+  end
+
+  context "empty?" do
+    it "Returns +true+ if no errors are found" do
+      errors.add(:name, "must be specified")
+      errors.add(:name, "min. 3 chars")
+      expect(errors.empty?).to eq(false)
+      errors.clear
+      expect(errors.empty?).to eq(true)
+    end
+  end
+end

data/spec/pure_validator/validator_spec.rb

@@ -0,0 +1,234 @@
+require 'spec_helper'
+
+describe PureValidator::Validator do
+  describe "#validate" do
+    class Contact
+      attr_accessor :first_name, :last_name, :position, :age, :type, :email, :color, :status, :stage, :description, :companies, :address
+    end
+
+    class Company
+      attr_accessor :name
+    end
+
+    class Address
+      attr_accessor :city, :street
+    end
+
+    class CompanyValidator
+      include PureValidator::Validator
+
+      validates :name, presence: true, length: { min: 3, max: 9 }
+    end
+
+    class AddressValidator
+      include PureValidator::Validator
+
+      validates :city, presence: true, length: { min: 3, max: 33 }
+      validates :street, presence: true, length: { min: 3, max: 33 }
+    end
+
+    class ContactValidator
+      include PureValidator::Validator
+
+      validates :first_name, presence: true, length: { min: 4, max: 7 }
+      validates :last_name,  length: { equal_to: 5 }
+      validates :position,   length: { not_equal_to: 5 }
+      validates :age,        numericality: { greater_than: 0, less_than: 150 }
+      validates :type,       numericality: { greater_than_or_equal_to: 1, less_than_or_equal_to: 5 }
+      validates :email,      email: true
+      validates :color,      regexp: /#\w{6}/
+      validates :status,     inclusion: { in: [:new, :lead] }
+      validates :stage,      exclusion: { in: [:wrong, :bad] }
+
+      validate_associated :companies, validator: CompanyValidator
+
+      validates :address, presence: true
+      validate_associated :address, validator: AddressValidator
+
+
+      validate :check_description
+
+      def check_description(entity, errors)
+        if entity.description.nil?
+          errors.add(:description, "can't be empty")
+        end
+      end
+    end
+
+    it "should return empty errors if object is valid" do
+      contact = Contact.new
+      contact.first_name  = "John"
+      contact.last_name   = "Smith"
+      contact.position    = "Team Lead"
+      contact.age         = 35
+      contact.type        = 2
+      contact.email       = "johh.smith@example.com"
+      contact.color       = "#DDD333"
+      contact.status      = :lead
+      contact.stage       = :good
+      contact.description = "good guy"
+
+      company1 = Company.new
+      company1.name = 'DroidLabs'
+      company2 = Company.new
+      company2.name = 'ICL'
+
+      contact.companies = [company1, company2]
+
+      address = Address.new.tap do |a| a.city = "New York" ; a.street = "Wall Street" end
+      contact.address = address
+
+      errors = ContactValidator.new.validate(contact)
+      errors.should be_empty
+    end
+
+    it "should return validation errors if object is invalid" do
+      contact = Contact.new
+      contact.first_name = nil
+      contact.last_name  = "Sm"
+      contact.position   = "develp"
+      contact.age        = -1
+      contact.type       = 7
+      contact.email      = "johh.com"
+      contact.color      = "DDD333"
+      contact.status     = :left
+      contact.stage      = :bad
+
+      company1 = Company.new
+      company1.name = 'DroidLabs Wrong'
+      company2 = Company.new
+      company2.name = 'IC'
+
+      contact.companies = [company1, company2]
+
+      errors = ContactValidator.new.validate(contact)
+      errors.should == {
+        first_name: ["can not be blank"],
+        last_name: ["should be equal to 5"],
+        age: ["should be greater than 0"],
+        type: ["should be less than or equal to 5"],
+        email: ["invalid email"],
+        color: ["does not match defined format"],
+        status: ["should be included in [:new, :lead]"],
+        stage: ["should not be included in [:wrong, :bad]"],
+        description: ["can't be empty"],
+        companies_errors: [
+          { name: ["can not be more than 9"] },
+          { name: ["can not be less than 3"] },
+        ],
+        address: ["can not be blank"],
+      }
+    end
+  end
+
+  context "some error cases" do
+    context "validate" do
+      it "raises with improper :validate definition" do
+        expect{
+          class ValidateWithoutArgsValidator
+            include PureValidator::Validator
+            validate
+          end
+        }.to raise_error(ArgumentError, "method name or block should be given for validate")
+      end
+    end
+
+    it "raises with non-existing validators" do
+      expect {
+        validator_class = Class.new do
+          include PureValidator::Validator
+          validates :last_name,  lengths: { equal_to: 5 }
+        end
+      }.to raise_error(PureValidator::Errors::MissingValidatorError, "Validator with name 'lengths' doesn't exist")
+    end
+
+    it "allows procs as validators" do
+      validator_class = Class.new do
+        include PureValidator::Validator
+
+        validate :shtick do |entity, errors|
+          errors.set(:shtick, PureValidator::I18n.t('errors.can_not_be_nil'))
+        end
+      end
+
+      klass = Class.new do
+        attr_accessor :shtick
+      end
+
+      expect(validator_class.new.validate(klass.new)).to eq({:shtick=>"can not be nil"})
+      expect(validator_class.new.validate({})).to eq({:shtick=>"can not be nil"})
+      expect{
+        validator_class.new.validate!({})
+      }.to raise_error(PureValidator::Errors::ValidationError)
+    end
+
+    context "skip_validation? (for associated_validations)" do
+      context "with :if" do
+        it "skips validations with a truthy proc, and otherwise not" do
+          validator1 = Class.new do
+            include PureValidator::Validator
+            validates :name, presence: true
+          end
+
+          validator2 = Class.new do
+            include PureValidator::Validator
+            validate_associated :b, validator: validator1, if: lambda { true } # you are in the validator instance context here!
+            validate_associated :c, validator: validator1, if: lambda { false }
+            validate_associated :d, validator: validator1, if: :should_validate_d
+
+            def should_validate_d
+              true
+            end
+          end
+
+          klass1 = Struct.new(:name)
+          klass2 = Struct.new(:b, :c, :d)
+
+          b = klass1.new("name")
+          c = klass1.new(nil)
+          d = klass1.new("d")
+
+          i_passing = klass2.new(b, c, d)
+          i_failing = klass2.new(c, b, c)
+
+          expect(validator2.new.validate(i_passing)).to be_empty
+          expect(validator2.new.validate(i_failing)).to eq(:b_errors => {:name=>["can not be blank"]}, :d_errors => {:name=>["can not be blank"]})
+        end
+      end
+
+      context "with :unless" do
+        it "skips validations with a falsy proc, and otherwise not" do
+          validator1 = Class.new do
+            include PureValidator::Validator
+            validates :name, presence: true
+          end
+
+          validator2 = Class.new do
+            include PureValidator::Validator
+            validate_associated :b, validator: validator1, unless: lambda { true } # you are in the validator instance context here!
+            validate_associated :c, validator: validator1, unless: lambda { false }
+            validate_associated :d, validator: validator1, unless: :should_skip_d?
+
+            def should_skip_d?
+              false
+            end
+          end
+
+          klass1 = Struct.new(:name)
+          klass2 = Struct.new(:b, :c, :d)
+
+          b = klass1.new("name")
+          c = klass1.new(nil)
+          d_pass = klass1.new("d")
+          d_fail = klass1.new(nil)
+
+          i_failing = klass2.new(b, c, d_fail)
+          i_passing= klass2.new(c, b, d_pass)
+
+          expect(validator2.new.validate(i_passing)).to be_empty
+          expect(validator2.new.validate(i_failing)).to eq(:c_errors => {:name=>["can not be blank"]}, :d_errors => {:name=>["can not be blank"]})
+        end
+      end
+    end
+  end
+end