pure_validator 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b2eaaaed1d01fb6d73c7caecc66ad7b97422502b
+  data.tar.gz: febaaa1df0a19e771ea4246253ccf6592a46d429
+SHA512:
+  metadata.gz: fdebd2254d6696cfec46bc455893d9622721a0f70a63efc63364847ce7b500ba55c06e4f7891076d89965e6ff076e98ae3549e36153982bc9b7394cf051f26ac
+  data.tar.gz: 1d881ee39ddc16f215dbe39be4450ef49ec84e2ad6ae0bdc94c9bc3bf4dc2b9030aa943fbec50f97c86be8a1fb2eda342b4f5603ea0f9a756f03e18e69b90856

data/.gitignore

@@ -0,0 +1,7 @@
+vendor/
+tags
+.bundle
+.DS_Store
+pkg
+coverage/
+.byebug_history

data/.travis.yml

@@ -0,0 +1,5 @@
+rvm:
+- 2.0.0
+- 2.2.0
+- 2.3.0
+script: "bundle exec rspec spec/"

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,47 @@
+PATH
+  remote: .
+  specs:
+    pure_validator (0.3.0)
+      i18n
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    byebug (9.0.6)
+    codecov (0.1.9)
+      json
+      simplecov
+      url
+    diff-lcs (1.2.5)
+    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)
+      docile (~> 1.1.0)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.0)
+    url (0.3.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  byebug
+  codecov
+  pure_validator!
+  rake
+  rspec
+
+BUNDLED WITH
+   1.13.6

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,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/Rakefile

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

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "pure_validator"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/lib/pure_validator/args_validator.rb

@@ -0,0 +1,107 @@
+# Helper class for arguments validation
+module PureValidator::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)
+      allow!(obj, [Symbol], "#{obj_name} should be a Symbol")
+    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)
+      allow!(obj, [TrueClass, FalseClass], "#{obj_name} should be a Boolean")
+    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)
+      allow!(obj, [Integer], "#{obj_name} should be an Integer")
+    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)
+      allow!(obj, [Array], "#{obj_name} should be an Array")
+    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)
+      allow!(obj, [Hash], "#{obj_name} should be a Hash")
+    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)
+      allow!(obj, [Integer, Float], "#{obj_name} should be an Integer or Float")
+    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)
+      allow!(obj, [String, Regexp], "#{obj_name} should be a String or Regexp")
+    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)
+      allow!(obj, [Symbol, Class], "#{obj_name} should be a Symbol or Class")
+    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)
+      allow!(obj, [Symbol, Proc], "#{obj_name} should be a Symbol or Proc")
+    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 have '#{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
+
+    private
+
+    def allow!(obj, klasses, msg)
+      return if klasses.any?{|klass| obj.is_a?(klass)}
+      raise ArgError, msg
+    end
+  end
+end

data/lib/pure_validator/concern.rb

@@ -0,0 +1,136 @@
+module PureValidator
+  # 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/pure_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/pure_validator/core_extensions/humanize.rb

@@ -0,0 +1,44 @@
+module PureValidator
+  module Humanize
+    # poor mans humanize... (to not depend on inflector)
+    # puts humanize "hello_there", format: :class
+    def self.humanize(value, options = {})
+      options[:format] = :sentence if options.empty?
+
+      values = if value.include? '_'
+       value.split('_')
+      else
+        [value]
+      end
+      values.each { |v| v.downcase! }
+
+      if options[:format] == :allcaps
+        values.each do |value|
+          value.capitalize!
+        end
+
+        if options.empty?
+          options[:seperator] = " "
+        end
+
+        return values.join " "
+      end
+
+      if options[:format] == :class
+        values.each do |value|
+          value.capitalize!
+        end
+        return values.join ""
+      end
+
+      if options[:format] == :sentence
+        values[0].capitalize!
+        return values.join " "
+      end
+
+      if options[:format] == :nocaps
+        return values.join " "
+      end
+    end
+  end
+end