pure_validator 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b2eaaaed1d01fb6d73c7caecc66ad7b97422502b
-  data.tar.gz: febaaa1df0a19e771ea4246253ccf6592a46d429
+  metadata.gz: 77569240246f2ea1f784cab102071acb50716095
+  data.tar.gz: b247e8889706590ed2aee0a4f3ad2ae0d2d34d8d
 SHA512:
-  metadata.gz: fdebd2254d6696cfec46bc455893d9622721a0f70a63efc63364847ce7b500ba55c06e4f7891076d89965e6ff076e98ae3549e36153982bc9b7394cf051f26ac
-  data.tar.gz: 1d881ee39ddc16f215dbe39be4450ef49ec84e2ad6ae0bdc94c9bc3bf4dc2b9030aa943fbec50f97c86be8a1fb2eda342b4f5603ea0f9a756f03e18e69b90856
+  metadata.gz: ede8f6afabc19468a541b78bf6c372d387827ac65f30df2a7f5fc9e351d5039b7959e228cf6ef99935afb1aa891e9877a636ab8f66601c0b2a1db30509316f54
+  data.tar.gz: be8130b200ea9b5777d9057f21a4ab7afcb2b3281c7b46f1e95a4f8e11275c3bcb44ae839aec2972c1760deaca392e04d8c425e16e3c4707d29ac03366047b3c

data/.codeclimate.yml

@@ -0,0 +1,27 @@
+engines:
+  rubocop:
+    enabled: true
+    exclude_fingerprints:
+    - 1deadbbb4a858ae5aeeff38fc78ad557
+    - 10973ead6ddf385b4d4d7ec0f75236ae
+
+  bundler-audit:
+    enabled: true
+
+  fixme:
+    enabled: true
+
+  duplication:
+    enabled: true
+    config:
+      languages:
+      - ruby
+
+ratings:
+  paths:
+  - Gemfile.lock
+  - "**.rb"
+
+exclude_paths:
+- spec/**/*
+- lib/pure_validator/core_extensions/**/*

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+v0.4 (2017-06-19)
+  - it is now possible to validate hashes with pure validator
+

data/Gemfile.lock

@@ -1,35 +1,40 @@
 PATH
   remote: .
   specs:
-    pure_validator (0.3.0)
+    pure_validator (0.4.0)
       i18n
 
 GEM
   remote: https://rubygems.org/
   specs:
     byebug (9.0.6)
-    codecov (0.1.9)
+    codecov (0.1.10)
       json
       simplecov
       url
-    diff-lcs (1.2.5)
+    diff-lcs (1.3)
     docile (1.1.5)
-    i18n (0.6.9)
-    json (2.0.2)
-    rake (10.1.1)
-    rspec (2.14.1)
-      rspec-core (~> 2.14.0)
-      rspec-expectations (~> 2.14.0)
-      rspec-mocks (~> 2.14.0)
-    rspec-core (2.14.7)
-    rspec-expectations (2.14.4)
-      diff-lcs (>= 1.1.3, < 2.0)
-    rspec-mocks (2.14.4)
-    simplecov (0.12.0)
+    i18n (0.8.4)
+    json (2.1.0)
+    rake (12.0.0)
+    rspec (3.6.0)
+      rspec-core (~> 3.6.0)
+      rspec-expectations (~> 3.6.0)
+      rspec-mocks (~> 3.6.0)
+    rspec-core (3.6.0)
+      rspec-support (~> 3.6.0)
+    rspec-expectations (3.6.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.6.0)
+    rspec-mocks (3.6.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.6.0)
+    rspec-support (3.6.0)
+    simplecov (0.14.1)
       docile (~> 1.1.0)
       json (>= 1.8, < 3)
       simplecov-html (~> 0.10.0)
-    simplecov-html (0.10.0)
+    simplecov-html (0.10.1)
     url (0.3.2)
 
 PLATFORMS
@@ -44,4 +49,4 @@ DEPENDENCIES
   rspec
 
 BUNDLED WITH
-   1.13.6
+   1.14.6

data/README.md

@@ -1,4 +1,9 @@
-# PureValidator [![Build Status](https://travis-ci.org/ddd-ruby/pure_validator.png)](https://travis-ci.org/ddd-ruby/pure_validator) [![Code Climate](https://codeclimate.com/github/ddd-ruby/pure_validator/badges/gpa.svg)](https://codeclimate.com/github/ddd-ruby/pure_validator) [![codecov](https://codecov.io/gh/ddd-ruby/pure_validator/branch/master/graph/badge.svg)](https://codecov.io/gh/ddd-ruby/pure_validator)
+# PureValidator
+[![Build Status](https://travis-ci.org/ddd-ruby/pure_validator.svg)](https://travis-ci.org/ddd-ruby/pure_validator)
+[![Gem Version](https://badge.fury.io/rb/pure_validator.svg)](http://badge.fury.io/rb/pure_validator)
+[![Code Climate](https://codeclimate.com/github/ddd-ruby/pure_validator/badges/gpa.svg)](https://codeclimate.com/github/ddd-ruby/pure_validator)
+[![codecov](https://codecov.io/gh/ddd-ruby/pure_validator/branch/master/graph/badge.svg)](https://codecov.io/gh/ddd-ruby/pure_validator)
+[![Dependency Status](https://gemnasium.com/ddd-ruby/pure_validator.svg)](https://gemnasium.com/ddd-ruby/pure_validator)
 
 PureValidator is a simple, mostly dependency-free (except `i18n`) library to validate your domain Ruby objects.
 
@@ -10,6 +15,14 @@ It is a simple step to separate those concerns, but it will give you unlimited f
 
 Do yourself a favor and start using PureValidator today, you will never look back!
 
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'pure_validator'
+```
+
 ## Usage
 Let's say you have the following class and you want to validate its instances:
 
@@ -137,3 +150,4 @@ Or install it yourself as:
 
 - Albert Gazizov, [@deeper4k](https://twitter.com/deeper4k)
 - Roman Heinrich, [@mindreframer](https://twitter.com/mindreframer)
+

data/docs/_config.yml

@@ -0,0 +1 @@
+theme: jekyll-theme-minimal

data/docs/index.md

@@ -0,0 +1,139 @@
+# PureValidator [![Build Status](https://travis-ci.org/ddd-ruby/pure_validator.png)](https://travis-ci.org/ddd-ruby/pure_validator) [![Code Climate](https://codeclimate.com/github/ddd-ruby/pure_validator/badges/gpa.svg)](https://codeclimate.com/github/ddd-ruby/pure_validator) [![codecov](https://codecov.io/gh/ddd-ruby/pure_validator/branch/master/graph/badge.svg)](https://codecov.io/gh/ddd-ruby/pure_validator)
+
+PureValidator is a simple, mostly dependency-free (except `i18n`) library to validate your domain Ruby objects.
+
+It keeps the concerns of validation separate from the Entity / Value object itself.
+
+This gives you the option to have different validations rules for different ocasions for the same object in a very clean and unit-testable way.
+
+It is a simple step to separate those concerns, but it will give you unlimited flexibility and save your *SS from debugging entangled and conflicting validations for non-trivial requirements.
+
+Do yourself a favor and start using PureValidator today, you will never look back!
+
+## Usage
+Let's say you have the following class and you want to validate its instances:
+
+```ruby
+class Contact
+  attr_accessor :first_name, :last_name, :position, :age, :type, :email, :color, :status, :stage, :description, :companies
+end
+```
+
+To validate objects of the Contact class define following validator:
+
+```ruby
+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
+
+  validate :check_description
+
+  def check_description(entity, errors)
+    if entity.description.nil?
+      errors.add(:description, "can't be empty")
+    end
+  end
+end
+```
+
+Instantiate the validator and call `validate` with a contact object:
+
+```ruby
+errors = ContactValidator.new.validate(contact)
+```
+
+`errors` is a Hash that contains all validation errors.
+If the object is valid then errors will be an empty Hash.
+
+### Adding own validators
+
+PureValidator can be extended by adding your own validators.
+To add a validator define a class with 2 static methods: `validate` and `validate_options`:
+
+The following example shows the built-in inclusion validator, it validates that specified value is one of the defined values.
+
+```ruby
+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 [Array] empty array if object is valid, list of errors otherwise
+  def self.validate(value, options)
+    return [] if value.nil?
+
+    errors = []
+    if options[:in]
+      unless options[:in].include?(value)
+        errors << (options[:message] || PureValidator::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)
+    raise ArgumentError, "validation options should be a Hash" unless options.is_a?(Hash)
+    raise ArgumentError, "validation options should have :in option and it should be an array of allowed values" unless options[:in].is_a?(Array)
+  end
+
+end
+```
+
+And register it in PureValidator:
+
+```ruby
+PureValidator.add_validator(:inclusion, PureValidator::Validators::InclusionValidator)
+```
+
+Now you can use it:
+
+```ruby
+class SomeValidator
+  include PureValidator::Validator
+
+  validates :size, inclusion: { in: [:small, :medium, :large] }
+end
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'pure_validator'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install pure_validator
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+
+## Authors
+
+- Albert Gazizov, [@deeper4k](https://twitter.com/deeper4k)
+- Roman Heinrich, [@mindreframer](https://twitter.com/mindreframer)

data/lib/pure_validator/validator.rb

@@ -66,7 +66,7 @@ module PureValidator::Validator
     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)
+      children = get_attribute_value(entity, association_name)
       if children.is_a?(Array)
         validate_children(association_name, validator, children, errors)
       elsif children
@@ -93,7 +93,7 @@ module PureValidator::Validator
   private
 
   def validate_attr(attr_name, entity, validators)
-    attr_value = entity.send(attr_name)
+    attr_value = get_attribute_value(entity, attr_name)
     error_messages = []
     validators.each do |validator, validation_rule|
       error_messages = validator.validate(attr_value, validation_rule)
@@ -102,6 +102,11 @@ module PureValidator::Validator
     error_messages
   end
 
+  def get_attribute_value(entity, attr_name)
+    return entity[attr_name] if entity.is_a?(Hash)
+    return entity.send(attr_name)
+  end
+
   def skip_validation?(options)
     return unless options[:if] || options[:unless]
     return handle_if_skip_validation(options)     if options[:if]

data/lib/pure_validator/validators/length_validator.rb

@@ -5,23 +5,7 @@ class PureValidator::Validators::LengthValidator
   # @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
+    self.new(object, options).validate
   end
 
   def self.validate_options(options)
@@ -29,4 +13,31 @@ class PureValidator::Validators::LengthValidator
     PureValidator::ArgsValidator.has_only_allowed_keys!(options, [:min, :max, :equal_to, :not_equal_to], :validation_rule)
   end
 
+  attr_accessor :object, :options, :errors
+  def initialize(object, options)
+    @object, @options = object, options
+    @errors = []
+  end
+
+  def validate
+    return errors if object.nil?
+
+    handle(:min, :<, 'errors.can_not_be_less_than')
+    handle(:max, :>, 'errors.can_not_be_more_than')
+    handle(:equal_to, :!=, 'errors.should_be_equal_to')
+    handle(:not_equal_to, :==, 'errors.should_not_be_equal_to')
+
+    errors
+  end
+
+  def handle(key, condition, error_key)
+    return unless options[key]
+    if object.length.send(condition, options[key])
+      add_error!(error_key, options[key])
+    end
+  end
+
+  def add_error!(key, length)
+    errors << PureValidator::I18n.t(key, length: length)
+  end
 end

data/lib/pure_validator/validators/numericality_validator.rb

@@ -5,28 +5,7 @@ class PureValidator::Validators::NumericalityValidator
   # @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
+    self.new(number, options).validate
   end
 
   def self.validate_options(options)
@@ -36,4 +15,44 @@ class PureValidator::Validators::NumericalityValidator
     ], :validation_rule)
   end
 
+  attr_accessor :object, :options, :errors
+  def initialize(object, options)
+    @object, @options = object, options
+    @errors = []
+  end
+
+  def validate
+    return errors if object.nil?
+
+    handle_compare(:greater_than, :<=, 'errors.should_be_greater_than')
+    handle_compare(:greater_than_or_equal_to, :<, 'errors.should_be_greater_than_or_equal_to')
+    handle_compare(:less_than, :>=, 'errors.should_be_less_than')
+    handle_compare(:less_than_or_equal_to, :>, 'errors.should_be_less_than_or_equal_to')
+    handle_condition(:even, :even?, 'errors.should_be_even')
+    handle_condition(:odd, :odd?, 'errors.should_be_odd')
+
+    errors
+  end
+
+  def handle_compare(key, condition, error_key)
+    return unless options[key]
+    if object.send(condition, options[key])
+      add_error!(error_key, options[key])
+    end
+  end
+
+  def handle_condition(key, condition, error_key)
+    return unless options[key]
+    unless object.send(condition)
+      add_error!(error_key)
+    end
+  end
+
+  def add_error!(key, number=nil)
+    if number
+      errors << PureValidator::I18n.t(key, number: number)
+    else
+      errors << PureValidator::I18n.t(key)
+    end
+  end
 end

data/lib/pure_validator/version.rb

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

data/spec/pure_validator/validator_hash_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+
+describe PureValidator::Validator do
+  describe "#validate" do
+    class ContactH
+      attr_accessor :first_name, :last_name, :position, :age, :type,
+        :email, :color, :status, :stage, :description,
+        :companies, :address
+
+      def to_h
+        {
+          first_name: first_name,
+          last_name: last_name,
+          position: position,
+          age: age,
+          type: type,
+          email: email,
+          color: color,
+          status: status,
+          stage: stage,
+          description: description,
+          companies: (companies||[]).map(&:to_h),
+          address: (address && address.to_h),
+        }
+      end
+    end
+
+    class CompanyH
+      attr_accessor :name
+
+      def to_h
+        {name: name}
+      end
+    end
+
+    class AddressH
+      attr_accessor :city, :street
+      def to_h
+        {
+          city: city,
+          street: street,
+        }
+      end
+    end
+
+    class CompanyValidatorH
+      include PureValidator::Validator
+
+      validates :name, presence: true, length: { min: 3, max: 9 }
+    end
+
+    class AddressValidatorH
+      include PureValidator::Validator
+
+      validates :city, presence: true, length: { min: 3, max: 33 }
+      validates :street, presence: true, length: { min: 3, max: 33 }
+    end
+
+    class ContactValidatorH
+      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: CompanyValidatorH
+
+      validates :address, presence: true
+      validate_associated :address, validator: AddressValidatorH
+
+
+      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 = ContactH.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 = CompanyH.new
+      company1.name = 'DroidLabs'
+      company2 = CompanyH.new
+      company2.name = 'ICL'
+
+      contact.companies = [company1, company2]
+
+      address = AddressH.new.tap do |a| a.city = "New York" ; a.street = "Wall Street" end
+      contact.address = address
+
+      errors = ContactValidatorH.new.validate(contact.to_h)
+      expect(errors).to be_empty
+    end
+
+    it "should return validation errors if object is invalid" do
+      contact = ContactH.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 = CompanyH.new
+      company1.name = 'DroidLabs Wrong'
+      company2 = CompanyH.new
+      company2.name = 'IC'
+
+      contact.companies = [company1, company2]
+      errors = ContactValidatorH.new.validate(contact.to_h)
+      expect(errors).to eq(
+        {
+          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
+end

data/spec/pure_validator/validator_spec.rb

@@ -79,7 +79,7 @@ describe PureValidator::Validator do
       contact.address = address
 
       errors = ContactValidator.new.validate(contact)
-      errors.should be_empty
+      expect(errors).to be_empty
     end
 
     it "should return validation errors if object is invalid" do
@@ -102,22 +102,24 @@ describe PureValidator::Validator do
       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"],
-      }
+      expect(errors).to eq(
+        {
+          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
 

data/spec/pure_validator/validators/email_validator_spec.rb

@@ -4,12 +4,12 @@ describe PureValidator::Validators::EmailValidator do
   describe ".validate" do
     it "should return empty errors if email is valid" do
       errors = PureValidator::Validators::EmailValidator.validate('test@example.com', true)
-      errors.should be_empty
+      expect(errors).to be_empty
     end
 
     it "should return errors if value is invalid" do
       errors = PureValidator::Validators::EmailValidator.validate('test@asdffd', true)
-      errors.should == ["invalid email"]
+      expect(errors).to eq(["invalid email"])
     end
 
     context "false as email_flag" do
@@ -27,9 +27,9 @@ describe PureValidator::Validators::EmailValidator do
 
   describe ".validate_options" do
     it "should raise error if validation attributes are invalid" do
-      lambda do
+      expect{
         PureValidator::Validators::EmailValidator.validate_options("asdf")
-      end.should raise_error("validation_rule should be a Boolean")
+      }.to raise_error("validation_rule should be a Boolean")
     end
   end
 end

data/spec/pure_validator/validators/exclusion_validator_spec.rb

@@ -4,20 +4,20 @@ describe PureValidator::Validators::ExclusionValidator do
   describe ".validate" do
     it "should return empty errors if value is valid" do
       errors = PureValidator::Validators::ExclusionValidator.validate(:wrong_type, in: [:new, :old, :medium])
-      errors.should be_empty
+      expect(errors).to be_empty
     end
 
     it "should return errors if value is invalid" do
       errors = PureValidator::Validators::ExclusionValidator.validate(:new, in: [:new, :old, :medium])
-      errors.should == ["should not be included in [:new, :old, :medium]"]
+      expect(errors).to eq(["should not be included in [:new, :old, :medium]"])
     end
   end
 
   describe ".validate_options" do
     it "should raise error if validation attributes are invalid" do
-      lambda do
+      expect{
         PureValidator::Validators::ExclusionValidator.validate_options(wrong_option: false, in: [])
-      end.should raise_error("validation_rule has unacceptable options [:wrong_option]")
+      }.to raise_error("validation_rule has unacceptable options [:wrong_option]")
     end
   end
 end

data/spec/pure_validator/validators/inclusion_validator_spec.rb

@@ -4,20 +4,20 @@ describe PureValidator::Validators::InclusionValidator do
   describe ".validate" do
     it "should return empty errors if value is valid" do
       errors = PureValidator::Validators::InclusionValidator.validate(:old, in: [:new, :old, :medium])
-      errors.should be_empty
+      expect(errors).to be_empty
     end
 
     it "should return errors if value is invalid" do
       errors = PureValidator::Validators::InclusionValidator.validate(:wrong_type, in: [:new, :old, :medium])
-      errors.should == ["should be included in [:new, :old, :medium]"]
+      expect(errors).to eq(["should be included in [:new, :old, :medium]"])
     end
   end
 
   describe ".validate_options" do
     it "should raise error if validation attributes are invalid" do
-      lambda do
+      expect{
         PureValidator::Validators::InclusionValidator.validate_options(wrong_option: false, in: [])
-      end.should raise_error("validation options has unacceptable options [:wrong_option]")
+      }.to raise_error("validation options has unacceptable options [:wrong_option]")
     end
   end
 end

data/spec/pure_validator/validators/length_validator_spec.rb

@@ -4,35 +4,35 @@ describe PureValidator::Validators::LengthValidator do
   describe ".validate" do
     it "should return empty errors if text has valid length" do
       errors = PureValidator::Validators::LengthValidator.validate('home', max: 5, min: 3)
-      errors.should be_empty
+      expect(errors).to be_empty
     end
 
     it "should return errors if value has invalid max length" do
       errors = PureValidator::Validators::LengthValidator.validate('long title', max: 5)
-      errors.should == ["can not be more than 5"]
+      expect(errors).to eq(["can not be more than 5"])
     end
 
     it "should return errors if value has invalid min length" do
       errors = PureValidator::Validators::LengthValidator.validate('ya', min: 3)
-      errors.should == ["can not be less than 3"]
+      expect(errors).to eq(["can not be less than 3"])
     end
 
     it "should return errors if value has invalid equal_to length" do
       errors = PureValidator::Validators::LengthValidator.validate('ya', equal_to: 3)
-      errors.should == ["should be equal to 3"]
+      expect(errors).to eq(["should be equal to 3"])
     end
 
     it "should return errors if value has invalid not_equal_to length" do
       errors = PureValidator::Validators::LengthValidator.validate('yad', not_equal_to: 3)
-      errors.should == ["should not be equal to 3"]
+      expect(errors).to eq(["should not be equal to 3"])
     end
   end
 
   describe ".validate_options" do
     it "should raise error if validation attributes are invalid" do
-      lambda do
+      expect {
         PureValidator::Validators::LengthValidator.validate_options(max: 5, wrong_attr: 3)
-      end.should raise_error("validation_rule has unacceptable options [:wrong_attr]")
+      }.to raise_error("validation_rule has unacceptable options [:wrong_attr]")
     end
   end
 end

data/spec/pure_validator/validators/not_nil_validator_spec.rb

@@ -35,9 +35,9 @@ describe PureValidator::Validators::NotNilValidator do
 
   describe ".validate_options" do
     it "should raise error if validation attributes are invalid" do
-      lambda do
+      expect{
         PureValidator::Validators::NotNilValidator.validate_options("asdf")
-      end.should raise_error("validation_rule should be a Boolean")
+      }.to raise_error("validation_rule should be a Boolean")
     end
   end
 

data/spec/pure_validator/validators/numericality_validator_spec.rb

@@ -1,49 +1,53 @@
 require 'spec_helper'
 
 describe PureValidator::Validators::NumericalityValidator do
+  def validate(*args)
+    PureValidator::Validators::NumericalityValidator.validate(*args)
+  end
+
+  def passes(v)
+    expect(v).to be_empty
+  end
+
+  def fails(v, errors)
+    expect(v).to eq(errors)
+  end
+
   describe ".validate" do
     it "should return empty errors if number is valid" do
-      errors = PureValidator::Validators::NumericalityValidator.validate(4, less_than: 5, greater_than: 3)
-      errors.should be_empty
+      passes(validate(4, less_than: 5, greater_than: 3))
     end
 
     it "should return errors if value is less than needed" do
-      errors = PureValidator::Validators::NumericalityValidator.validate(5, greater_than: 5)
-      errors.should == ["should be greater than 5"]
+      fails(validate(5, greater_than: 5), ["should be greater than 5"])
     end
 
     it "should return errors if value is less than or equal to what needed" do
-      errors = PureValidator::Validators::NumericalityValidator.validate(4, greater_than_or_equal_to: 5)
-      errors.should == ["should be greater than or equal to 5"]
+      fails(validate(4, greater_than_or_equal_to: 5), ["should be greater than or equal to 5"])
     end
 
     it "should return errors if value is greater than needed" do
-      errors = PureValidator::Validators::NumericalityValidator.validate(5, less_than: 5)
-      errors.should == ["should be less than 5"]
+      fails(validate(5, less_than: 5), ["should be less than 5"])
     end
 
     it "should return errors if value is greater than or equal to what needed" do
-      errors = PureValidator::Validators::NumericalityValidator.validate(6, less_than_or_equal_to: 5)
-      errors.should == ["should be less than or equal to 5"]
+      fails(validate(6, less_than_or_equal_to: 5), ["should be less than or equal to 5"])
     end
 
     it "should return errors if value is not even" do
-      errors = PureValidator::Validators::NumericalityValidator.validate(7, even: true)
-      errors.should == ["should be even number"]
+      fails(validate(7, even: true), ["should be even number"])
     end
 
     it "should return errors if value is not odd" do
-      errors = PureValidator::Validators::NumericalityValidator.validate(6, odd: true)
-      errors.should == ["should be odd number"]
+      fails(validate(6, odd: true), ["should be odd number"])
     end
-
   end
 
   describe ".validate_options" do
     it "should raise error if validation attributes are invalid" do
-      lambda do
+      expect{
         PureValidator::Validators::NumericalityValidator.validate_options(less_than: 5, wrong_attr: 3)
-      end.should raise_error("validation_rule has unacceptable options [:wrong_attr]")
+      }.to raise_error("validation_rule has unacceptable options [:wrong_attr]")
     end
   end
 end

data/spec/pure_validator/validators/presence_validator_spec.rb

@@ -29,9 +29,9 @@ describe PureValidator::Validators::PresenceValidator do
 
   describe ".validate_options" do
     it "should raise error if validation attributes are invalid" do
-      lambda do
+      expect {
         PureValidator::Validators::PresenceValidator.validate_options("asdf")
-      end.should raise_error("validation_rule should be a Boolean")
+      }.to raise_error("validation_rule should be a Boolean")
     end
   end
 

data/spec/pure_validator/validators/regexp_validator_spec.rb

@@ -1,23 +1,33 @@
 require 'spec_helper'
 
 describe PureValidator::Validators::RegexpValidator do
+  def validate(*args)
+    PureValidator::Validators::RegexpValidator.validate(*args)
+  end
+
+  def passes(v)
+    expect(v).to be_empty
+  end
+
+  def fails(v, errors)
+    expect(v).to eq(errors)
+  end
+
   describe ".validate" do
     it "should return empty errors if value is valid" do
-      errors = PureValidator::Validators::RegexpValidator.validate('#aaa', /#\w{3,6}/)
-      errors.should be_empty
+      passes(validate('#aaa', /#\w{3,6}/))
     end
 
     it "should return errors if value is invalid" do
-      errors = PureValidator::Validators::RegexpValidator.validate('asdf', /#\w{3,6}/)
-      errors.should == ["does not match defined format"]
+      fails(validate('asdf', /#\w{3,6}/), ["does not match defined format"])
     end
   end
 
   describe ".validate_options" do
     it "should raise error if validation attributes are invalid" do
-      lambda do
+      expect {
         PureValidator::Validators::RegexpValidator.validate_options({})
-      end.should raise_error("validation_rule should be a String or Regexp")
+      }.to raise_error("validation_rule should be a String or Regexp")
     end
   end
 end

data/spec/pure_validator/validators/url_validator_spec.rb

@@ -1,35 +1,43 @@
 require 'spec_helper'
 
 describe PureValidator::Validators::UrlValidator do
+  def validate(*args)
+    PureValidator::Validators::UrlValidator.validate(*args)
+  end
+
+  def passes(v)
+    expect(v).to be_empty
+  end
+
+  def fails(v, errors)
+    expect(v).to eq(errors)
+  end
+
   describe ".validate" do
     it "should return empty errors if email is valid" do
-      errors = PureValidator::Validators::UrlValidator.validate('example-asdf.com', true)
-      errors.should be_empty
+      passes(validate('example-asdf.com', true))
     end
 
     it "should return errors if value is invalid" do
-      errors = PureValidator::Validators::UrlValidator.validate(':123asdffd.com', true)
-      errors.should == ["invalid url"]
+      fails(validate(':123asdffd.com', true), ["invalid url"])
     end
 
     context "false as url_flag" do
       it "fails if url is valid" do
-        errors = PureValidator::Validators::UrlValidator.validate('example-asdf.com', false)
-        expect(errors).to eq(["can not be a url"])
+        fails(validate('example-asdf.com', false), ["can not be a url"])
       end
 
       it "passes if url is invalid" do
-        errors = PureValidator::Validators::UrlValidator.validate(':123asdffd.com', false)
-        expect(errors).to eq([])
+        passes(validate(':123asdffd.com', false))
       end
     end
   end
 
   describe ".validate_options" do
     it "should raise error if validation attributes are invalid" do
-      lambda do
+      expect{
         PureValidator::Validators::UrlValidator.validate_options("asdf")
-      end.should raise_error("validation_rule should be a Boolean")
+      }.to raise_error("validation_rule should be a Boolean")
     end
   end
 end

data/spec/spec_helper.rb

@@ -17,5 +17,4 @@ end
 require 'pure_validator'
 
 RSpec.configure do |config|
-  config.color_enabled = true
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pure_validator
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Albert Gazizov
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-05 00:00:00.000000000 Z
+date: 2017-06-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n
@@ -89,14 +89,18 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".codeclimate.yml"
 - ".gitignore"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
 - bin/console
+- docs/_config.yml
+- docs/index.md
 - lib/pure_validator.rb
 - lib/pure_validator/args_validator.rb
 - lib/pure_validator/concern.rb
@@ -123,6 +127,7 @@ files:
 - spec/pure_validator/args_validator_spec.rb
 - spec/pure_validator/errors_spec.rb
 - spec/pure_validator/validation_errors_spec.rb
+- spec/pure_validator/validator_hash_spec.rb
 - spec/pure_validator/validator_spec.rb
 - spec/pure_validator/validators/email_validator_spec.rb
 - spec/pure_validator/validators/exclusion_validator_spec.rb
@@ -154,7 +159,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Moves validation logic to validators
@@ -162,6 +167,7 @@ test_files:
 - spec/pure_validator/args_validator_spec.rb
 - spec/pure_validator/errors_spec.rb
 - spec/pure_validator/validation_errors_spec.rb
+- spec/pure_validator/validator_hash_spec.rb
 - spec/pure_validator/validator_spec.rb
 - spec/pure_validator/validators/email_validator_spec.rb
 - spec/pure_validator/validators/exclusion_validator_spec.rb