valligator 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 901e61d04df742c8b66f23ae13d25fe593b1f67a
-  data.tar.gz: c51339d7634a55baa18c4d2f66deb7f28a7ba2a0
+  metadata.gz: 4c57e3ef079cd6494f2b67e9abe8b5e46336805d
+  data.tar.gz: a6bfdaad97a85777458cc6219b901cea77269b74
 SHA512:
-  metadata.gz: e12044a5195fb8e1eded23cf1cedbfed7dd28e248815bb40f6ecc9ec491f0f4531bbbf544a8ba2dfd0ef1a4496b0282f135fe6377c92d987e1f3ec3df6f556c4
-  data.tar.gz: 7e2c676687fae5c74f833663dd533c8dda491fe471a680ffe5cfdd2a074ab2b7a19e4c02effbb75193dbb88970f4fe6b96ef5c553de0251f4fe25d1b1c0a1572
+  metadata.gz: 95a39fb2d9a3b89483587da462de9c593841e2963b8ed4a36ab076182b833ef4f1e360afac7188bbef3b68ebd98a5b837792e699f30c239b6c670962195307f5
+  data.tar.gz: d821f39b08f9974b2fa6ec2793a7d5b53dcadee4aaf936bfb4a32e9c87641af9e8fe44452841947d9361722934e58eaa12d2b06fe5ffc8a9cb197a0e22883e64

data/HISTORY.md

@@ -0,0 +1,4 @@
+#### 1.0.2
+
+  - **is_instance_of** got alias **is_a**
+  - **is_not_instance_of** got alias **is_not_a**

data/README.md

@@ -40,7 +40,7 @@ There are 3 validations (a.k.a. statements) that the Valligator supports:
 
 The validations passes when testee responds to all (or none in negative case) the methods from the list.
 
-#### is_instance_of
+#### is_instance_of, is_a
 ```
   testee.is_instance_of(*classes)
   testee.is_not_instance_of(*classes)
@@ -49,7 +49,9 @@ The validations passes when testee responds to all (or none in negative case) th
 
 The validations passes when testee is an instance of any class (or not an instance of all the classes in negative case).
 
-#### asserts
+**is_instance_of** and **is_not_instance_of** have aliases **is_a** and **is_not_a**
+
+#### asserts, is, has
 ```
   testee.asserts(method, *method_args, &block)
   testee.asserts_not(method, *method_args, &block)
@@ -82,38 +84,37 @@ I use _instance_eval_ so that the _value_ could be assessed as _self_, and one w
 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)
+  testee.is_a(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:
+passed validations. If the validation above would fail on _is_a_ statement the error message wold look like:
 
 ```
-Valligator::ValidationError: at testee#1.is_instance_of
+Valligator::ValidationError: at testee#1.is_a
 ```
 
-but if it would fail on _has_ then the erro would be
-
+but if it would fail on _has_ then the error would be
 
 ```
-Valligator::ValidationError: at testee#1.is_instance_of.is_not.has
+Valligator::ValidationError: at testee#1.is_a.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'
+testee.is_a(String).has(:size){self > 10}
+  #=> Valligator::ValidationError: at `short.is_a.has'
 ```
 
 ## Examples
 
 Validate that testee is an instance of String
 ```
-Valligator.new('foo').is_instance_of(String) #=> OK
+Valligator.new('foo').is_a(String) #=> OK
 ```
 
 Validate that all testees respond to :to_s and :upcase methods
@@ -125,15 +126,15 @@ 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'
+Valligator.new(*testees).has(:size){self == 3}.has(:[], 0){self == 'b'}.is_a(String)
+   #=> Valligator::ValidationError: at testee#3.has.has.is_a'
 ```
 
 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'
+Valligator.new(*h.values, names: h.keys).is_a(Integer).asserts(:<= , 2)
+  #=> Valligator::ValidationError: at `baz.is_a.asserts'
 ```
 
 ## More examples
@@ -208,11 +209,11 @@ 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(user).is_a(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(logger).is_a(IO).is_not(:closed?).has(:path) { self != 'dev/null'}
   Valligator.new(currency).asserts(:==, :usd)
 
   charge(payee, payment_gateway, order, currency, logger)
@@ -227,11 +228,11 @@ 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(user).is_a(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(logger).is_a(IO).is_not_closed?.has_path { self != 'dev/null'}
   v(currency).asserts(:==, :usd)
 
   charge(payee, payment_gateway, order, currency, logger)

data/VERSION

@@ -1 +1 @@
-1.0.1
+1.0.2

data/lib/valligator.rb

@@ -70,6 +70,8 @@ class Valligator
   #   Valligator.new('foo').is_instance_of(Integer, String) #=> OK
   #   Valligator.new('foo').is_instance_of(Integer, Array)  #=> Valligator::ValidationError
   #
+  # @see #is_a
+  #
   def is_instance_of(*classes)
     clone._is_instance_of(__method__, *classes)
   end
@@ -85,11 +87,27 @@ class Valligator
   #   Valligator.new('foo').is_not_instance_of(Integer, String) #=> Valligator::ValidationError
   #   Valligator.new('foo').is_not_instance_of(Integer, Array) #=> OK
   #
+  # @see #is_not_a
+  #
   def is_not_instance_of(*classes)
     clone._is_instance_of(__method__, *classes)
   end
 
 
+  # Is an alias for {#is_instance_of} method
+  #
+  def is_a(*classes)
+    clone._is_instance_of(__method__, *classes)
+  end
+
+
+  # Is an alias for {#is_not_instance_of} method
+  #
+  def is_not_a(*classes)
+    clone._is_instance_of(__method__, *classes)
+  end
+
+
   # Passes when the testee responds to all the methods
   #
   # @param [Array<Symbols>] methods

data/test/lib/valligator/errors_test.rb

@@ -1,7 +1,7 @@
 require_relative '../../test_helper'
 
 
-class TestMethodMissing < Minitest::Test
+class TestErrors < Minitest::Test
   include Valligator::Helper
 
 

data/test/lib/valligator/is_instance_of_test.rb

@@ -8,51 +8,65 @@ class TestIsInstanceOf < Minitest::Test
     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
+  positive_statements = [:is_instance_of, :is_a]
+  negative_statements = [:is_not_instance_of, :is_not_a]
+  all_statements = positive_statements + negative_statements
+
+  all_statements.each do |method|
+    define_method 'test_that__%s__fails_on_wrong_number_of_arguments' % method do
+      expected = "wrong number of arguments (0 for 1..Infinity) at `testee#1.%s'" % method
+      err = assert_raises(ArgumentError) { v(:a).send(method) }
+      assert_equal expected, err.message
+    end
+
+
+    define_method 'test_that__%s__fails_on_wrong_argument_type' % method do
+      expected = "wrong argument type (arg#1 is a Fixnum instead of Class) at `testee#1.%s'" % method
+      err = assert_raises(ArgumentError) { v(:a).send(method, 1) }
+      assert_equal expected, err.message
+    end
   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
+  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, Symbol)
+    end
 
 
-  def test_that__is_instance_of__returns_an_instance_of_valligator
-    assert_instance_of Valligator, v(:a).is_instance_of(Symbol)
-  end
+    define_method 'test_that__%s__passes_when_there_is_a_match' % method do
+      v(:a).send(method, Symbol)
+      v(:a).send(method, String, Symbol)
+      v(:a).send(method, Symbol).send(method, 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)
+    define_method 'test_that__%s__fails_when_there_is_no_match' % method do
+      assert_raises(error) { v(:a).send(method, String) }
+      assert_raises(error) { v(:a).send(method, String, Integer) }
+      assert_raises(error) { v(:a).send(method, Symbol).send(method, String) }
+    end
   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
+  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, 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
+    define_method 'test_that__%s__passes_when_there_is_no_match' % method do
+      v(:a).send(method, String)
+      v(:a).send(method, String, Integer)
+      v(:a).send(method, String).send(method, 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) }
+    define_method 'test_that__%s__fails_when_there_is_a_match' % method do
+      assert_raises(error) { v(:a).send(method, Symbol) }
+      assert_raises(error) { v(:a).send(method, String, Symbol) }
+      assert_raises(error) { v(:a).send(method, String).send(method, Symbol) }
+    end
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: valligator
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Konstantin Dzreev
@@ -45,6 +45,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - Gemfile
+- HISTORY.md
 - README.md
 - Rakefile
 - VERSION