valligator 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 901e61d04df742c8b66f23ae13d25fe593b1f67a
+  data.tar.gz: c51339d7634a55baa18c4d2f66deb7f28a7ba2a0
+SHA512:
+  metadata.gz: e12044a5195fb8e1eded23cf1cedbfed7dd28e248815bb40f6ecc9ec491f0f4531bbbf544a8ba2dfd0ef1a4496b0282f135fe6377c92d987e1f3ec3df6f556c4
+  data.tar.gz: 7e2c676687fae5c74f833663dd533c8dda491fe471a680ffe5cfdd2a074ab2b7a19e4c02effbb75193dbb88970f4fe6b96ef5c553de0251f4fe25d1b1c0a1572

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gem 'rake'
+
+group :test do
+  gem 'minitest'
+  gem 'minitest-reporters'
+end

data/README.md

@@ -0,0 +1,254 @@
+# Valligator
+
+
+## Ruby objects validator
+
+In ruby we often run into a case when we need to validate method parameter types, check if their values are in the
+required boundaries, or to perform any other crazy variable validations. The valligator an attempt to simplify the problem.
+
+
+## Requirements
+
+Ruby 2.0+
+
+
+## Installation
+
+Add it to your Gemfile
+
+```
+gem "valligator"
+```
+
+Or install manually:
+
+```
+gem install valligator
+```
+
+## Statements
+
+There are 3 validations (a.k.a. statements) that the Valligator supports:
+
+#### speaks
+
+```
+  testee.speaks(*methods)
+  testee.does_not_speak(*methods)
+```
+  - _methods_ are symbols
+
+The validations passes when testee responds to all (or none in negative case) the methods from the list.
+
+#### is_instance_of
+```
+  testee.is_instance_of(*classes)
+  testee.is_not_instance_of(*classes)
+```
+  - _classes_ a list of ruby classes
+
+The validations passes when testee is an instance of any class (or not an instance of all the classes in negative case).
+
+#### asserts
+```
+  testee.asserts(method, *method_args, &block)
+  testee.asserts_not(method, *method_args, &block)
+```
+  - _method_ a method to be calld on testee
+  - _method_args_ (optional) the method arguments
+  - _block_ (optional) a block to be invoked in the context of the _method_ response
+
+When the _block_ is not provided the validation passes if the _method_, called with _method_args_ on the testee, returns truthy response (not false or nil).
+
+When the _block_ is provided the validation passes if the _block_, called in the context of the value returned by the _method_ called with _method_args_, returns truthy (not false or nil) value.
+
+If it does not sound clear, then it is something like this:
+```
+  testee = Valligator.new(:foo)
+  testee.has(:size){self == 10}
+
+  # is the same as:
+
+  value = :foo.size
+  raise !!value.instance_eval { self == 10 }
+```
+
+I use _instance_eval_ so that the _value_ could be assessed as _self_, and one would not need to access it using standard block params definition ({|value| value == 10 }).
+
+**asserts** has two aliases: **is** and **has**. The negative form **asserts_not** also has its own clones: **is_not**, **does_not_have**. All the methods are absolutely identical, just use what ever sounds more grammatically correct: _is(:active?)_, _has(:apples)_, _asserts(:respond_to?, :foo)_, etc.
+
+## Method chaining
+
+Each statement, if it does not fail, returns an instance of the Valligator, so that they can be chained:
+
+```
+  testee.is_instance_of(String).is_not(:empty?).has(:size){self > 10}.speaks(:to_s)
+```
+
+## Errors
+
+When validation fails a Valligator::ValidationError is raised. The error message contains the full path of the
+passed validations. If the validation above would fail on _is_instance_of_ statement the error message wold look like:
+
+```
+Valligator::ValidationError: at testee#1.is_instance_of
+```
+
+but if it would fail on _has_ then the erro would be
+
+
+```
+Valligator::ValidationError: at testee#1.is_instance_of.is_not.has
+```
+
+You can provide a testee name when you instantiate a Valligator instance, and the name will be used in the error message instead of 'testee#x'
+
+```
+testee = Valligator.new('Very long string', 'Short', names: ['long', 'short'])
+testee.is_instance_of(String).has(:size){self > 10}
+  #=> Valligator::ValidationError: at `short.is_instance_of.has'
+```
+
+## Examples
+
+Validate that testee is an instance of String
+```
+Valligator.new('foo').is_instance_of(String) #=> OK
+```
+
+Validate that all testees respond to :to_s and :upcase methods
+```
+testees = ['foo', 'bar', :baz]
+Valligator.new(*testees).speaks(:to_s, :upcase) #=> OK
+```
+
+Validate that all testees have size == 3 and start with 'b' and they are Strings
+```
+testees = ['boo', 'bar', :baz]
+Valligator.new(*testees).has(:size){self == 3}.has(:[], 0){self == 'b'}.is_instance_of(String)
+   #=> Valligator::ValidationError: at testee#3.has.has.is_instance_of'
+```
+
+Validate that all hash values are Integers <= 2
+```
+h = { foo: 1, bar: 2, baz: 3 }
+Valligator.new(*h.values, names: h.keys).is_instance_of(Integer).asserts(:<= , 2)
+  #=> Valligator::ValidationError: at `baz.is_instance_of.asserts'
+```
+
+## More examples
+
+How about a completely synthetic example:
+
+```
+def charge!(payee, payment_gateway, order, currency, logger)
+  # FIXME: I want validations before processing to the charge method
+  charge(payee, payment_gateway, order, currency, logger)
+end
+
+```
+
+And we would like to make sure that:
+
+  * Payee:
+    - is an instance of either a User or a RemoteSystem model
+    - it is not blocked
+    - it is a confirmed user
+    - it has payment method registred
+    - it can pay in a requested currency
+  * Payment gateway:
+    - is active
+    - it can accept payment in the payment method that the user supports
+  * Order
+    - is not deleted
+    - its status is set to :pending
+    - its corresponding OrderItem records are not empty
+  * OrderItems
+    - are in the same currency that was passed with the method call
+    - their price makes sence
+  * Logger
+    - is an IO object
+    - it is not closed
+    - the file it writes to is not '/dev/null'
+  * Currency
+    - equal to :usd
+
+The most straightforward way to code this may look like the one below (yeah, Sandi Metz would hate it starting from the line # [6](https://robots.thoughtbot.com/sandi-metz-rules-for-developers)):
+
+```
+def charge!(payee, payment_gateway, order, currency, logger)
+  if !(payee.is_a?(User) || payee.is_a?(RemoteSystem)) || payee.blocked? || !payee.confirmed? || !payee.payment_method || !payee.can_pay_in?(currency)
+    raise(ArgumentError, 'Payee is not either a User or a RemoteSystem or is blocked or is not confirmed, or does not have a payment method set')
+  end
+  if !payment_gateway.active? || !payment_gateway.respond_to?(payee.payment_method)
+    raise(ArgumentError, 'Payment gateway cannot charge users or is not active')
+  end
+  if order.deleted? || order.status != :pending || order.order_items.empty?
+    raise(ArgumentError, 'Order is deleted or is not in pending state or does not have any items in it')
+  end
+  order.order_items.each do |item|
+    if item.currency != currency || item.price <= 0
+      raise(ArgumentError, 'There are order items not in USD or with a negative price')
+    end
+  end
+  if !logger.is_a?(IO) || logger.closed? || logger.path == '/dev/null'
+    raise(ArgumentError, 'Logger is not an IO instance or closed or writes to nowhere')
+  end
+  if currency != :usd
+    raise(ArgumentError, 'Currency is expected to be set to USD')
+  end
+
+  charge(payee, payment_gateway, order, currency, logger)
+end
+```
+
+Using the Valligator we can write all above as:
+
+```
+require 'valligator'
+
+def charge!(payee, payment_gateway, order, currency, logger)
+  Valligator.new(user).is_instance_of(User, RemoteSystem).is_not(:blocked?).is(:confirmed?).has(:payment_method).asserts(:can_pay_in?, currency)
+  Valligator.new(payment_gateway).is(:active?).speaks(payee.payment_method)
+  Valligator.new(order).is_not(:deleted?).has(:status) { self == :pending }.does_not_have(:order_items) { empty? }
+  Valligator.new(*order.items).has(:currency){ self == currency }.has(:price) { self > 0 }
+  Valligator.new(logger).is_instance_of(IO).is_not(:closed?).has(:path) { self != 'dev/null'}
+  Valligator.new(currency).asserts(:==, :usd)
+
+  charge(payee, payment_gateway, order, currency, logger)
+end
+```
+
+or a little bit shorter using a handy _v_ method, provided by _Valligator::Helper_, and a more natural way of
+writing statements:
+
+```
+require 'valligator'
+include Valligator::Helper
+
+def charge!(payee, payment_gateway, order, logger, currency)
+  v(user).is_instance_of(User, RemoteSystem).is_not_blocked?.is_confirmed?.has_payment_method.asserts_can_pay_in?(currency)
+  v(payment_gateway).is_active?.speaks(payee.payment_method)
+  v(order).is_not_deleted?.has_status{ self == :pending }.does_not_have_order_items { empty? }
+  v(*order.items).has_currency{ self == :usd }.has_price { self > 0 }
+  v(logger).is_instance_of(IO).is_not_closed?.has_path { self != 'dev/null'}
+  v(currency).asserts(:==, :usd)
+
+  charge(payee, payment_gateway, order, currency, logger)
+end
+```
+
+## Tests
+
+```
+rake test
+```
+
+## License
+
+[MIT](https://opensource.org/licenses/mit-license.php) <br/>
+
+
+## Author
+
+Konstantin Dzreev, [konstantin-dzreev](https://github.com/konstantin-dzreev)

data/Rakefile

@@ -0,0 +1,5 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.pattern = "test/**/*_test.rb"
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.1

data/lib/valligator.rb

@@ -0,0 +1,393 @@
+require_relative 'valligator_helper'
+
+class Valligator
+  Error            = Class.new(StandardError)
+  ValidationError = Class.new(Error)
+
+  INFINITY = 1/0.0
+
+  attr_reader :testees
+  attr_reader :names
+  attr_reader :stack
+
+
+  # Creates a new Valligator instance
+  #
+  # @param [Array<Object>] testees  One or more objects to be tested
+  # @param option [Array<String>] :names  Testee names
+  # @return [Valligator]
+  #
+  # @example
+  #   # validate that testee is an instance of String
+  #   Valligator.new('foo').is_instance_of(String) #=> OK
+  #
+  # @example
+  #   # validate that all testees respond to :to_s and :upcase methods
+  #   Valligator.new('foo', 'bar', :baz).speaks(:to_s, :upcase) #=> OK
+  #
+  # @example
+  #   # validate that all testees have size == 3 and start with 'b' and they are Strings
+  #   testees = ['boo', 'bar', :baz]
+  #   Valligator.new(*testees).has(:size){self == 3}.has(:[], 0){self == 'b'}.is_instance_of(String)
+  #     #=> Valligator::ValidationError: at `testee#3.has.has.is_instance_of'
+  #
+  # @example
+  #   # validate that all hash values are Integers <= 2
+  #   h = { foo: 1, bar: 2, baz: 3 }
+  #   Valligator.new(*h.values, names: h.keys).is_instance_of(Integer).asserts(:<= , 2)
+  #     #=> Valligator::ValidationError: at `baz.is_instance_of.asserts'
+  #
+  def initialize(*testees, names: nil)
+    @testees = testees
+    @names   = Array(names)
+    @stack   = []
+  end
+
+
+  # @private
+  def method_missing(method, *args, &block)
+    case
+    when method[/^does_not_speak_(.+)?$/] then does_not_speak(*args.unshift($1.to_sym))
+    when method[/^speaks_(.+)?$/ ]        then speaks(*args.unshift($1.to_sym))
+    when method[/^asserts_not_(.+)?$/]    then asserts_not($1.to_sym, *args, &block)
+    when method[/^asserts_(.+)?$/]        then asserts($1.to_sym, *args, &block)
+    when method[/^does_not_have_(.+)?$/]  then does_not_have($1.to_sym, *args, &block)
+    when method[/^has_(.+)?$/]            then has($1.to_sym, *args, &block)
+    when method[/^is_not_(.+)?$/]         then is_not($1.to_sym, *args, &block)
+    when method[/^is_(.+)?$/]             then is($1.to_sym, *args, &block)
+    else super(method, *args, &block)
+    end
+  end
+
+
+  # Passes when the testee is an instance of either of the classes
+  #
+  # @param [Array<Class>] classes
+  # @return [Valligator]
+  # @raise [Valligator::ValidationError]
+  #
+  # @example
+  #   Valligator.new('foo').is_instance_of(Integer, String) #=> OK
+  #   Valligator.new('foo').is_instance_of(Integer, Array)  #=> Valligator::ValidationError
+  #
+  def is_instance_of(*classes)
+    clone._is_instance_of(__method__, *classes)
+  end
+
+
+  # Passes when the testee is not an instance of all of the classes
+  #
+  # @param [Array<Class>] classes
+  # @return [Valligator]
+  # @raise [Valligator::ValidationError]
+  #
+  # @example
+  #   Valligator.new('foo').is_not_instance_of(Integer, String) #=> Valligator::ValidationError
+  #   Valligator.new('foo').is_not_instance_of(Integer, Array) #=> OK
+  #
+  def is_not_instance_of(*classes)
+    clone._is_instance_of(__method__, *classes)
+  end
+
+
+  # Passes when the testee responds to all the methods
+  #
+  # @param [Array<Symbols>] methods
+  # @return [Valligator]
+  # @raise [Valligator::ValidationError]
+  #
+  # @example
+  #   Valligator.new('foo').speaks(:size, :empty?) #=> OK
+  #   Valligator.new('foo').speaks(:size, :foo)    #=> Valligator::ValidationError
+  #
+  def speaks(*methods)
+    clone._speaks(__method__, *methods)
+  end
+
+
+  # Passes when the testee does not respond to all the methods
+  #
+  # @param [Array<Symbols>] methods
+  # @return [Valligator]
+  # @raise [Valligator::ValidationError]
+  #
+  # @example
+  #   Valligator.new('foo').does_not_speak(:foo, :boo)  #=> OK
+  #   Valligator.new('foo').does_not_speak(:foo, :size) #=> Valligator::ValidationError
+  #
+  def does_not_speak(*methods)
+    clone._speaks(__method__, *methods)
+  end
+
+
+  # When no block given it passes if the testee, called with a given method and arguments, returns truthy value.
+  #
+  # When block is given then it calls the testee with the given method and arguments.
+  # Then it calls the block in the context of the value returned above, and if the block returns truthy value the
+  # validation passes.
+  #
+  # P.S. Truthy value is anything but nil or false.
+  #
+  # @param [Symbol] method
+  # @param [Array<Object>] args
+  # @yield [Object]
+  # @raise [Valligator::ValidationError]
+  #
+  # @example
+  #   Valligator.new('foo').asserts(:size)                #=> OK
+  #   Valligator.new('foo').asserts(:[], 0)               #=> OK
+  #   Valligator.new('foo').asserts(:[], 0) {self == 'f'} #=> OK
+  #   Valligator.new('foo').asserts(:empty?)              #=> Valligator::ValidationError
+  #   Valligator.new('foo').asserts(:[], 100)             #=> Valligator::ValidationError
+  #   Valligator.new('foo').asserts(:[], 0) {self == 'F'} #=> Valligator::ValidationError
+  #
+  # @see #is
+  # @see #has
+  #
+  def asserts(method, *args, &block)
+    clone._asserts(__method__, method, *args, &block)
+  end
+
+
+  # When no block given it passes if the testee, called with a given method and arguments, returns falsy value.
+  #
+  # When block is given then it calls the testee with the given method and arguments.
+  # Then it calls the block in the context of the value returned above, and if the block returns falsy value the
+  # validation passes.
+  #
+  # P.S. Falsy value is either nil or false.
+  #
+  # @param [Symbol] method
+  # @param [Array<Object>] args
+  # @yield [Object]
+  # @raise [Valligator::ValidationError]
+  #
+  # @example
+  #   Valligator.new('foo').asserts_not(:size)                #=> Valligator::ValidationError
+  #   Valligator.new('foo').asserts_not(:[], 0)               #=> Valligator::ValidationError
+  #   Valligator.new('foo').asserts_not(:[], 0) {self == 'f'} #=> Valligator::ValidationError
+  #   Valligator.new('foo').asserts_not(:empty?)              #=> OK
+  #   Valligator.new('foo').asserts_not(:[], 100)             #=> OK
+  #   Valligator.new('foo').asserts_not(:[], 0) {self == 'F'} #=> OK
+  #
+  # @see #is_not
+  # @see #does_not_have
+  #
+  def asserts_not(method, *args, &block)
+    clone._asserts(__method__, method, *args, &block)
+  end
+
+
+  # Is an alias for {#asserts} method
+  #
+  def is(method, *args, &block)
+    clone._asserts(__method__, method, *args, &block)
+  end
+
+
+  # Is an alias for {#asserts_not} method
+  #
+  def is_not(method, *args, &block)
+    clone._asserts(__method__, method, *args, &block)
+  end
+
+
+  # Is an alias for {#asserts} method
+  #
+  def has(method, *args, &block)
+    clone._asserts(__method__, method, *args, &block)
+  end
+
+
+  # Is an alias for {#asserts_not} method
+  #
+  def does_not_have(method, *args, &block)
+    clone._asserts(__method__, method, *args, &block)
+  end
+
+
+  protected
+
+
+  # Returns testee name by its index
+  #
+  # @param [Integer] idx
+  # @return [String]
+  #
+  def name_by_idx(idx)
+    @names && @names[idx] || ('testee#%d' % (idx+1))
+  end
+
+
+  # Adds method to the stack of the tested ones
+  #
+  # @param [Symbol] method_name
+  # @return [void]
+  #
+  def push(method_name)
+    @stack << method_name
+  end
+
+
+  # Raises requested exception
+  #
+  # @param [Class] exception
+  # @param option [Integer] idx  Testee index
+  # @param option [nil,String] msg Error explanation (when required)
+  #
+  def error(exception, idx=0, msg=nil)
+    msg += ' ' if msg
+    raise(exception, "%sat `%s.%s'" % [msg, name_by_idx(idx), @stack.join('.')])
+  end
+
+
+  # Calls the given block for each testee and each item from the list.
+  #
+  # @param optional list [Array]
+  #
+  # @yield [testee, idx, list_item]
+  # @yieldparam testee [Object]
+  # @yieldparam idx [Integer] testee index
+  # @yieldparam optional list_item [Integer] when list is given
+  #
+  # @return [void]
+  #
+  def each(*list)
+    list << nil if list.empty?
+    @testees.each_with_index do |testee, idx|
+      list.each do |list_item|
+        yield(testee, idx, list_item)
+      end
+    end
+  end
+
+
+  # Clones current instance.
+  #
+  # @return [Valligator]
+  #
+  def clone
+    self.class.new(*@testees, names: @names).tap do |v|
+      v.stack.push(*stack)
+    end
+  end
+
+
+  #------------------------------------------
+  # Validations
+  #------------------------------------------
+
+
+  # Validates number of arguments
+  #
+  # @param [Array<Object>] args
+  # @param [Integer] expected
+  # @return [void]
+  # @raise [ArgumentError]
+  #
+  def validate_number_of_arguments(args, expected)
+    return if expected === args.size
+
+    expected == expected.first if expected.is_a?(Range) && expected.size == 1
+    error(ArgumentError, 0, 'wrong number of arguments (%s for %s)' % [args.size, expected])
+  end
+
+
+  # Validates argument type
+  #
+  # @param [Array<Class>] classes
+  # @param [Array<Object>] args
+  # @param [Integer] arg_idx
+  # @return [void]
+  # @raise [ArgumentError]
+  #
+  def validate_argument_type(classes, arg, arg_idx)
+    return if classes.any? { |klass| arg.is_a?(klass) }
+    classes = classes.map { |klass| klass.inspect }.join(' or ')
+    error(ArgumentError, 0, 'wrong argument type (arg#%d is a %s instead of %s)' % [arg_idx, arg.class.name, classes])
+  end
+
+
+  # Validates if object responds to a method
+  #
+  # @param [Object] object
+  # @param [Array<Object>] args
+  # @param [Integer] idx
+  # @return [void]
+  # @raise [ArgumentError]
+  #
+  def validate_respond_to(object, method, idx)
+    return if object.respond_to?(method)
+    str = object.to_s
+    str = str[0..-1] + '...' if str.size > 20
+    error(NoMethodError, idx, 'undefined method `%s\' for %s:%s' % [method, str, object.class.name])
+  end
+
+
+  #------------------------------------------
+  # Statements
+  #------------------------------------------
+
+
+  # @private
+  # @see #is_instance_of
+  #
+  def _is_instance_of(statement, *classes)
+    push(statement)
+    equality = !statement[/not/]
+
+    matches = [false] * @testees.count
+
+    validate_number_of_arguments(classes, 1..INFINITY)
+    classes.each_with_index { |klass, idx| validate_argument_type([Class], klass, idx+1) }
+
+    each(*classes)          { |testee, idx, klass|  matches[idx] = true if testee.is_a?(klass) }
+    matches.each_with_index { |match, idx| error(ValidationError, idx) if matches[idx] != equality }
+    self
+  end
+
+
+  # @private
+  # @see #speaks
+  #
+  def _speaks(statement, *methods)
+    push(statement)
+    equality = !statement[/not/]
+
+    validate_number_of_arguments(methods, 1..INFINITY)
+
+    methods.each_with_index do |arg, idx|
+      validate_argument_type([Symbol], arg, idx+1)
+    end
+
+    each(*methods) do |testee, idx, method|
+      next if testee.respond_to?(method) == equality
+
+      error(ValidationError, idx)
+    end
+    self
+  end
+
+
+  # @private
+  # @see #speaks
+  #
+  def _asserts(statement, method, *args, &block)
+    push(statement)
+    equality = !statement[/not/]
+
+    each do |testee, idx|
+      validate_respond_to(testee, method, idx)
+      response = testee.__send__(method, *args)
+      begin
+        # Execute block in the context on the response so that one could retrieve it using self keyword.
+        response = response.instance_eval(&block) if block
+      rescue
+        # This error will have 'cause' set to the original exception raised in the block
+        error(ValidationError, idx)
+      end
+      error(ValidationError, idx) if !!response != equality
+    end
+    self
+  end
+end

data/lib/valligator_helper.rb

@@ -0,0 +1,12 @@
+class Valligator
+  module Helper
+
+    def valligate(*testees, names: nil)
+      Valligator.new(*testees, names: names)
+    end
+
+
+    alias_method :v, :valligate
+
+  end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+class Valligator
+  VERSION = '1.0'
+end

data/test/lib/valligator/asserts_test.rb

@@ -0,0 +1,60 @@
+require_relative '../../test_helper'
+
+
+class TestAsserts < Minitest::Test
+  include Valligator::Helper
+
+  def error
+    Valligator::ValidationError
+  end
+
+
+  positive_statements = [:asserts, :has, :is]
+  negative_statements = [:asserts_not, :does_not_have, :is_not]
+
+
+  positive_statements.each do |method|
+    define_method 'test_that__%s__returns_an_instance_of_valligator' % method do
+      assert_instance_of Valligator, v(:a).send(method, :size)
+    end
+
+
+    define_method 'test_that__%s__passes_when_testee_returns_truthy_value' % method do
+      v(:a).send(method, :to_s)
+      v(:a).send(method, :[], 0)
+      v(:a).send(method, :size){self == 1}
+      v(:a).send(method, :to_s).send(method, :[], 0).send(method, :size){self == 1}
+    end
+
+
+    define_method 'test_that__%s__fails_when_testee_returns_falsy_value' % method do
+      assert_raises(error) { v(:a).send(method, :empty?) }
+      assert_raises(error) { v(:a).send(method, :[], 1) }
+      assert_raises(error) { v(:a).send(method, :size){self != 1} }
+      assert_raises(error) { v(:a).send(method, :to_s).send(method, :[], 0).send(method, :size){self != 1} }
+    end
+  end
+
+
+  negative_statements.each do |method|
+    define_method 'test_that__%s__returns_an_instance_of_valligator' % method do
+      assert_instance_of Valligator, v(:a).send(method, :empty?)
+    end
+
+
+    define_method 'test_that__%s__passes_when_testee_returns_falsy_value' % method do
+      v(:a).send(method, :empty?)
+      v(:a).send(method, :[], 1)
+      v(:a).send(method, :size){self != 1}
+      v(:a).send(method, :empty?).send(method, :[], 1).send(method, :size){self != 1}
+    end
+
+
+    define_method 'test_that__%s__fails_when_testee_returns_truthy_value' % method do
+      assert_raises(error) { v(:a).send(method, :to_s) }
+      assert_raises(error) { v(:a).send(method, :[], 0) }
+      assert_raises(error) { v(:a).send(method, :size){self == 1} }
+      assert_raises(error) { v(:a).send(method, :empty?).send(method, :[], 1).send(method, :size){self == 1} }
+    end
+  end
+end

data/test/lib/valligator/errors_test.rb

@@ -0,0 +1,40 @@
+require_relative '../../test_helper'
+
+
+class TestMethodMissing < Minitest::Test
+  include Valligator::Helper
+
+
+  def error
+    Valligator::ValidationError
+  end
+
+
+  def test_without_testee_name
+    expected = "at `testee#1.speaks'"
+    err = assert_raises(error) { v(:foo).speaks(:foo) }
+    assert_equal expected, err.message
+  end
+
+
+  def test_with_testee_name
+    expected = "at `i-have-a-name.speaks'"
+    err = assert_raises(error) { v(:foo, names: 'i-have-a-name').speaks(:foo) }
+    assert_equal expected, err.message
+  end
+
+
+  def test_long_path
+    expected = "at `testee#1.speaks.asserts_not.has.is_instance_of.speaks'"
+    err = assert_raises(error) do |variable|
+      v(:foo).speaks(:to_s).\
+              asserts_not(:empty?).\
+              has(:size){self > 1}.\
+              is_instance_of(Symbol).\
+              speaks(:it_dies_here).\
+              asserts(:thould_not_reach_this)
+    end
+    assert_equal expected, err.message
+  end
+
+end

data/test/lib/valligator/is_instance_of_test.rb

@@ -0,0 +1,58 @@
+require_relative '../../test_helper'
+
+
+class TestIsInstanceOf < Minitest::Test
+  include Valligator::Helper
+
+  def error
+    Valligator::ValidationError
+  end
+
+
+  def test_that__is_instance_of__fails_on_wrong_number_of_arguments
+    expected = "wrong number of arguments (0 for 1..Infinity) at `testee#1.is_instance_of'"
+    err = assert_raises(ArgumentError) { v(:a).is_instance_of }
+    assert_equal expected, err.message
+  end
+
+
+  def test_that__is_instance_of__fails_on_wrong_argument_type
+    expected = "wrong argument type (arg#1 is a Fixnum instead of Class) at `testee#1.is_instance_of'"
+    err = assert_raises(ArgumentError) { v(:a).is_instance_of(1) }
+    assert_equal expected, err.message
+  end
+
+
+  def test_that__is_instance_of__returns_an_instance_of_valligator
+    assert_instance_of Valligator, v(:a).is_instance_of(Symbol)
+  end
+
+
+  def test_that__is_instance_of__passes_when_there_is_a_match
+    v(:a).is_instance_of(Symbol)
+    v(:a).is_instance_of(String, Symbol)
+    v(:a).is_instance_of(Symbol).is_instance_of(Symbol)
+  end
+
+
+  def test_that__is_instance_of__fails_when_there_is_no_match
+    assert_raises(error) { v(:a).is_instance_of(String) }
+    assert_raises(error) { v(:a).is_instance_of(String, Integer) }
+    assert_raises(error) { v(:a).is_instance_of(Symbol).is_instance_of(String) }
+  end
+
+
+  def test_that__is_not_instance_of__passes_when_there_is_no_match
+    v(:a).is_not_instance_of(String)
+    v(:a).is_not_instance_of(String, Integer)
+    v(:a).is_not_instance_of(String).is_not_instance_of(NilClass)
+  end
+
+
+  def test_that__is_not_instance_of__fails_when_there_is_a_match
+    assert_raises(error) { v(:a).is_not_instance_of(Symbol) }
+    assert_raises(error) { v(:a).is_not_instance_of(String, Symbol) }
+    assert_raises(error) { v(:a).is_not_instance_of(String).is_not_instance_of(Symbol) }
+  end
+
+end

data/test/lib/valligator/method_missing_test.rb

@@ -0,0 +1,43 @@
+require_relative '../../test_helper'
+
+
+class TestMethodMissing < Minitest::Test
+  include Valligator::Helper
+
+
+  def error
+    Valligator::ValidationError
+  end
+
+
+  def test__speaks_something
+    v(:foo).speaks_to_s
+    assert_raises(error) { v(:foo).speaks_to_i }
+  end
+
+
+  def test__does_not_speak_something
+    v(:foo).does_not_speak_to_i
+    assert_raises(error) { v(:foo).does_not_speak_to_s }
+  end
+
+
+  [:asserts, :is, :has].each do |method|
+    define_method 'test__%s_something' % method do
+      m1 = '%s_to_s' % method
+      m2 = '%s_empty?' % method
+      v(:foo).send(m1)
+      assert_raises(error) { v(:foo).send(m2) }
+    end
+  end
+
+
+  [:asserts_not, :is_not, :does_not_have].each do |method|
+    define_method 'test__%s_something' % method do
+      m1 = '%s_empty?' % method
+      m2 = '%s_to_s'   % method
+      v(:foo).send(m1)
+      assert_raises(error) { v(:foo).send(m2) }
+    end
+  end
+end

data/test/lib/valligator/speaks_test.rb

@@ -0,0 +1,58 @@
+require_relative '../../test_helper'
+
+
+class TestSpeaks < Minitest::Test
+  include Valligator::Helper
+
+  def error
+    Valligator::ValidationError
+  end
+
+
+  def test_that__speaks__fails_on_wrong_number_of_arguments
+    expected = "wrong number of arguments (0 for 1..Infinity) at `testee#1.speaks'"
+    err = assert_raises(ArgumentError) { v(:a).speaks }
+    assert_equal expected, err.message
+  end
+
+
+  def test_that__speaks__fails_on_wrong_argument_type
+    expected = "wrong argument type (arg#1 is a Fixnum instead of Symbol) at `testee#1.speaks'"
+    err = assert_raises(ArgumentError) { v(:a).speaks(1) }
+    assert_equal expected, err.message
+  end
+
+
+  def test_that__speaks__returns_an_instance_of_valligator
+    assert_instance_of Valligator, v(:a).speaks(:to_s)
+  end
+
+
+  def test_that__speaks__passes_when_there_is_a_match
+    v(:a).speaks(:to_s)
+    v(:a).speaks(:to_s, :size)
+    v(:a).speaks(:to_s).speaks(:size)
+  end
+
+
+  def test_that__speaks__fails_when_there_is_no_match
+    assert_raises(error) { v(:a).speaks(:to_i) }
+    assert_raises(error) { v(:a).speaks(:to_s, :foo) }
+    assert_raises(error) { v(:a).speaks(:to_s).speaks(:foo) }
+  end
+
+
+  def test_that__does_not_speak__passes_when_there_is_no_match
+    v(:a).does_not_speak(:foo)
+    v(:a).does_not_speak(:foo, :boo)
+    v(:a).does_not_speak(:foo).does_not_speak(:boo)
+  end
+
+
+  def test_that__does_not_speak__fails_when_there_is_a_match
+    assert_raises(error) { v(:a).does_not_speak(:to_s) }
+    assert_raises(error) { v(:a).does_not_speak(:foo, :to_s) }
+    assert_raises(error) { v(:a).does_not_speak(:foo).does_not_speak(:to_s) }
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+require 'minitest/autorun'
+require 'minitest/reporters'
+require_relative '../lib/valligator'
+
+Minitest::Reporters.use! [Minitest::Reporters::DefaultReporter.new({ color: true })]

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: valligator
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Konstantin Dzreev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-09-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Allows one to implement object validations without writing too much code
+email: k.dzreyev@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.md
+- Rakefile
+- VERSION
+- lib/valligator.rb
+- lib/valligator_helper.rb
+- lib/version.rb
+- test/lib/valligator/asserts_test.rb
+- test/lib/valligator/errors_test.rb
+- test/lib/valligator/is_instance_of_test.rb
+- test/lib/valligator/method_missing_test.rb
+- test/lib/valligator/speaks_test.rb
+- test/test_helper.rb
+homepage: https://github.com/konstantin-dzreev/valligator
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Ruby objects validator
+test_files: []