attr_validator 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+vendor/
+tags
+.bundle
+.DS_Store

data/.travis.yml

@@ -0,0 +1,4 @@
+rvm:
+- 1.9.3
+- 2.0.0
+script: "bundle exec rspec spec/"

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in aggregate_builder.gemspec
+gemspec
+
+group :test do
+  gem 'rspec'
+  gem 'debugger'
+end

data/Gemfile.lock

@@ -0,0 +1,37 @@
+PATH
+  remote: .
+  specs:
+    attr_validator (0.0.1)
+      i18n
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    columnize (0.3.6)
+    debugger (1.6.5)
+      columnize (>= 0.3.1)
+      debugger-linecache (~> 1.2.0)
+      debugger-ruby_core_source (~> 1.3.1)
+    debugger-linecache (1.2.0)
+    debugger-ruby_core_source (1.3.1)
+    diff-lcs (1.2.5)
+    i18n (0.6.9)
+    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)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  attr_validator!
+  bundler (~> 1.3)
+  debugger
+  rake
+  rspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Albert Gazizov
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,119 @@
+# AttrValidator [![Build Status](https://travis-ci.org/AlbertGazizov/attr_validator.png)](https://travis-ci.org/AlbertGazizov/attr_validator) [![Code Climate](https://codeclimate.com/github/AlbertGazizov/attr_validator.png)](https://codeclimate.com/github/AlbertGazizov/attr_validator)
+
+
+AttrValidator is simple library for validating ruby objects.
+The main idea of the gem is separate all object validation logic from the object itself
+
+## Usage
+Lets say you have the following class and you wan to validate objects of this class
+```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 a validator:
+```ruby
+class ContactValidator
+  include AttrValidator::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 pass a contact object inside:
+```ruby
+errors = ContactValidator.new.validate(contact)
+```
+errors is a hash which contains all validation errors
+if object is valid then errors will be empty
+
+### Adding own validators
+AttrValidator can be extended by adding your own validators.
+To add a validator define a class with two the class method validate and validate_options:
+The following example demonstrates the built in inclusion validator,
+it validates that specified value is one of the defined value
+```ruby
+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 [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] || 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)
+    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 AttrValidator:
+```ruby
+AttrValidator.add_validator(:inclusion,    AttrValidator::Validators::InclusionValidator)
+```
+Now you can use it:
+```ruby
+class SomeValidator
+  include AttrValidator::Validator
+
+  validates :size, inclusion: { in: [:small, :medium, :large] }
+end
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'attr_validator'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install attr_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
+
+# TODO
+1. Document methods

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/attr_validator.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'attr_validator/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "attr_validator"
+  spec.version       = AttrValidator::VERSION
+  spec.authors       = ["Albert Gazizov"]
+  spec.email         = ["deeper4k@gmail.com"]
+  spec.description   = %q{Object validation library}
+  spec.summary       = %q{Moves validation logic to validators}
+  spec.homepage      = "http://github.com/AlbertGazizov/attr_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"
+end

data/lib/attr_validator/args_validator.rb

@@ -0,0 +1,118 @@
+# Helper class for arguments validation
+module AttrValidator::ArgsValidator
+  class ArgError < StandardError; end
+
+  class << self
+
+    # Checks that specifid +obj+ is a symbol
+    # @param obj some object
+    # @param obj_name object's name, used to clarify error causer in exception
+    def is_symbol!(obj, obj_name)
+      unless obj.is_a?(Symbol)
+        raise ArgError, "#{obj_name} should be a Symbol"
+      end
+    end
+
+    # Checks that specifid +obj+ is a boolean
+    # @param obj some object
+    # @param obj_name object's name, used to clarify error causer in exception
+    def is_boolean!(obj, obj_name)
+      if !obj.is_a?(TrueClass) && !obj.is_a?(FalseClass)
+        raise ArgError, "#{obj_name} should be a Boolean"
+      end
+    end
+
+    # Checks that specifid +obj+ is an integer
+    # @param obj some object
+    # @param obj_name object's name, used to clarify error causer in exception
+    def is_integer!(obj, obj_name)
+      unless obj.is_a?(Integer)
+        raise ArgError, "#{obj_name} should be an Integer"
+      end
+    end
+
+    # Checks that specifid +obj+ is an Array
+    # @param obj some object
+    # @param obj_name object's name, used to clarify error causer in exception
+    def is_array!(obj, obj_name)
+      unless obj.is_a?(Array)
+        raise ArgError, "#{obj_name} should be an Array"
+      end
+    end
+
+    # Checks that specifid +obj+ is a Hash
+    # @param obj some object
+    # @param obj_name object's name, used to clarify error causer in exception
+    def is_hash!(obj, obj_name)
+      unless obj.is_a?(Hash)
+        raise ArgError, "#{obj_name} should be a Hash"
+      end
+    end
+
+    # Checks that specifid +obj+ is an integer or float
+    # @param obj some object
+    # @param obj_name object's name, used to clarify error causer in exception
+    def is_integer_or_float!(obj, obj_name)
+      if !obj.is_a?(Integer) && !obj.is_a?(Float)
+        raise ArgError, "#{obj_name} should be an Integer or Float"
+      end
+    end
+
+    # Checks that specifid +obj+ is a string or regexp
+    # @param obj some object
+    # @param obj_name object's name, used to clarify error causer in exception
+    def is_string_or_regexp!(obj, obj_name)
+      if !obj.is_a?(String) && !obj.is_a?(Regexp)
+        raise ArgError, "#{obj_name} should be a String or Regexp"
+      end
+    end
+
+    # Checks that specifid +obj+ is a symbol or class
+    # @param obj some object
+    # @param obj_name object's name, used to clarify error causer in exception
+    def is_class_or_symbol!(obj, obj_name)
+      if !obj.is_a?(Symbol) && !obj.is_a?(Class)
+        raise ArgError, "#{obj_name} should be a Symbol or Class"
+      end
+    end
+
+    # Checks that specifid +obj+ is a symbol or block
+    # @param obj some object
+    # @param obj_name object's name, used to clarify error causer in exception
+    def is_symbol_or_block!(obj, obj_name)
+      if !obj.is_a?(Symbol) && !obj.is_a?(Proc)
+        raise ArgError, "#{obj_name} should be a Symbol or Proc"
+      end
+    end
+
+    # Checks that specifid +hash+ has a specified +key+
+    # @param hash some hash
+    # @param key hash's key
+    def has_key!(hash, key)
+      unless hash.has_key?(key)
+        raise ArgError, "#{hash} should has #{key} key"
+      end
+    end
+
+    def not_nil!(obj, obj_name)
+      if obj.nil?
+        raise ArgError, "#{obj_name} can't be nil"
+      end
+    end
+
+    def has_only_allowed_keys!(hash, keys, obj_name)
+      remaining_keys = hash.keys - keys
+      unless remaining_keys.empty?
+        raise ArgError, "#{obj_name} has unacceptable options #{remaining_keys}"
+      end
+    end
+
+    # Checks that specified +block+ is given
+    # @param block some block
+    def block_given!(block)
+      unless block
+        raise ArgError, "Block should be given"
+      end
+    end
+  end
+end

data/lib/attr_validator/concern.rb

@@ -0,0 +1,136 @@
+module AttrValidator
+  # Copied from here https://github.com/rails/rails/blob/master/activesupport/lib/active_support/concern.rb
+  #
+  # A typical module looks like this:
+  #
+  #   module M
+  #     def self.included(base)
+  #       base.extend ClassMethods
+  #       base.class_eval do
+  #         scope :disabled, -> { where(disabled: true) }
+  #       end
+  #     end
+  #
+  #     module ClassMethods
+  #       ...
+  #     end
+  #   end
+  #
+  # By using <tt>ActiveSupport::Concern</tt> the above module could instead be
+  # written as:
+  #
+  #   require 'active_support/concern'
+  #
+  #   module M
+  #     extend ActiveSupport::Concern
+  #
+  #     included do
+  #       scope :disabled, -> { where(disabled: true) }
+  #     end
+  #
+  #     module ClassMethods
+  #       ...
+  #     end
+  #   end
+  #
+  # Moreover, it gracefully handles module dependencies. Given a +Foo+ module
+  # and a +Bar+ module which depends on the former, we would typically write the
+  # following:
+  #
+  #   module Foo
+  #     def self.included(base)
+  #       base.class_eval do
+  #         def self.method_injected_by_foo
+  #           ...
+  #         end
+  #       end
+  #     end
+  #   end
+  #
+  #   module Bar
+  #     def self.included(base)
+  #       base.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Foo # We need to include this dependency for Bar
+  #     include Bar # Bar is the module that Host really needs
+  #   end
+  #
+  # But why should +Host+ care about +Bar+'s dependencies, namely +Foo+? We
+  # could try to hide these from +Host+ directly including +Foo+ in +Bar+:
+  #
+  #   module Bar
+  #     include Foo
+  #     def self.included(base)
+  #       base.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Bar
+  #   end
+  #
+  # Unfortunately this won't work, since when +Foo+ is included, its <tt>base</tt>
+  # is the +Bar+ module, not the +Host+ class. With <tt>ActiveSupport::Concern</tt>,
+  # module dependencies are properly resolved:
+  #
+  #   require 'active_support/concern'
+  #
+  #   module Foo
+  #     extend ActiveSupport::Concern
+  #     included do
+  #       def self.method_injected_by_foo
+  #         ...
+  #       end
+  #     end
+  #   end
+  #
+  #   module Bar
+  #     extend ActiveSupport::Concern
+  #     include Foo
+  #
+  #     included do
+  #       self.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Bar # works, Bar takes care now of its dependencies
+  #   end
+  module Concern
+    class MultipleIncludedBlocks < StandardError #:nodoc:
+      def initialize
+        super "Cannot define multiple 'included' blocks for a Concern"
+      end
+    end
+
+    def self.extended(base) #:nodoc:
+      base.instance_variable_set(:@_dependencies, [])
+    end
+
+    def append_features(base)
+      if base.instance_variable_defined?(:@_dependencies)
+        base.instance_variable_get(:@_dependencies) << self
+        return false
+      else
+        return false if base < self
+        @_dependencies.each { |dep| base.send(:include, dep) }
+        super
+        base.extend const_get(:ClassMethods) if const_defined?(:ClassMethods)
+        base.class_eval(&@_included_block) if instance_variable_defined?(:@_included_block)
+      end
+    end
+
+    def included(base = nil, &block)
+      if base.nil?
+        raise MultipleIncludedBlocks if instance_variable_defined?(:@_included_block)
+
+        @_included_block = block
+      else
+        super
+      end
+    end
+  end
+end

data/lib/attr_validator/core_extensions/class_attribute.rb

@@ -0,0 +1,143 @@
+module Kernel
+  # class_eval on an object acts like singleton_class.class_eval.
+  def class_eval(*args, &block)
+    singleton_class.class_eval(*args, &block)
+  end
+end
+
+class Module
+  def remove_possible_method(method)
+    if method_defined?(method) || private_method_defined?(method)
+      undef_method(method)
+    end
+  end
+
+  def redefine_method(method, &block)
+    remove_possible_method(method)
+    define_method(method, &block)
+  end
+end
+
+class Class
+  # Declare a class-level attribute whose value is inheritable by subclasses.
+  # Subclasses can change their own value and it will not impact parent class.
+  #
+  #   class Base
+  #     class_attribute :setting
+  #   end
+  #
+  #   class Subclass < Base
+  #   end
+  #
+  #   Base.setting = true
+  #   Subclass.setting            # => true
+  #   Subclass.setting = false
+  #   Subclass.setting            # => false
+  #   Base.setting                # => true
+  #
+  # In the above case as long as Subclass does not assign a value to setting
+  # by performing <tt>Subclass.setting = _something_ </tt>, <tt>Subclass.setting</tt>
+  # would read value assigned to parent class. Once Subclass assigns a value then
+  # the value assigned by Subclass would be returned.
+  #
+  # This matches normal Ruby method inheritance: think of writing an attribute
+  # on a subclass as overriding the reader method. However, you need to be aware
+  # when using +class_attribute+ with mutable structures as +Array+ or +Hash+.
+  # In such cases, you don't want to do changes in places but use setters:
+  #
+  #   Base.setting = []
+  #   Base.setting                # => []
+  #   Subclass.setting            # => []
+  #
+  #   # Appending in child changes both parent and child because it is the same object:
+  #   Subclass.setting << :foo
+  #   Base.setting               # => [:foo]
+  #   Subclass.setting           # => [:foo]
+  #
+  #   # Use setters to not propagate changes:
+  #   Base.setting = []
+  #   Subclass.setting += [:foo]
+  #   Base.setting               # => []
+  #   Subclass.setting           # => [:foo]
+  #
+  # For convenience, an instance predicate method is defined as well.
+  # To skip it, pass <tt>instance_predicate: false</tt>.
+  #
+  #   Subclass.setting?       # => false
+  #
+  # Instances may overwrite the class value in the same way:
+  #
+  #   Base.setting = true
+  #   object = Base.new
+  #   object.setting          # => true
+  #   object.setting = false
+  #   object.setting          # => false
+  #   Base.setting            # => true
+  #
+  # To opt out of the instance reader method, pass <tt>instance_reader: false</tt>.
+  #
+  #   object.setting          # => NoMethodError
+  #   object.setting?         # => NoMethodError
+  #
+  # To opt out of the instance writer method, pass <tt>instance_writer: false</tt>.
+  #
+  #   object.setting = false  # => NoMethodError
+  #
+  # To opt out of both instance methods, pass <tt>instance_accessor: false</tt>.
+  def class_attribute(*attrs)
+    options = attrs.last.is_a?(Hash) ? attrs.pop : {}
+    instance_reader = options.fetch(:instance_accessor, true) && options.fetch(:instance_reader, true)
+    instance_writer = options.fetch(:instance_accessor, true) && options.fetch(:instance_writer, true)
+    instance_predicate = options.fetch(:instance_predicate, true)
+
+    attrs.each do |name|
+      define_singleton_method(name) { nil }
+      define_singleton_method("#{name}?") { !!public_send(name) } if instance_predicate
+
+      ivar = "@#{name}"
+
+      define_singleton_method("#{name}=") do |val|
+        singleton_class.class_eval do
+          remove_possible_method(name)
+          define_method(name) { val }
+        end
+
+        if singleton_class?
+          class_eval do
+            remove_possible_method(name)
+            define_method(name) do
+              if instance_variable_defined? ivar
+                instance_variable_get ivar
+              else
+                singleton_class.send name
+              end
+            end
+          end
+        end
+        val
+      end
+
+      if instance_reader
+        remove_possible_method name
+        define_method(name) do
+          if instance_variable_defined?(ivar)
+            instance_variable_get ivar
+          else
+            self.class.public_send name
+          end
+        end
+        define_method("#{name}?") { !!public_send(name) } if instance_predicate
+      end
+
+      attr_writer name if instance_writer
+    end
+  end
+
+  private
+
+    unless respond_to?(:singleton_class?)
+      def singleton_class?
+        ancestors.first != self
+      end
+    end
+end

data/lib/attr_validator/errors.rb

@@ -0,0 +1,23 @@
+module AttrValidator::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/attr_validator/i18n.rb

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

data/lib/attr_validator/locales/en.yml

@@ -0,0 +1,23 @@
+en:
+  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"