rspec-be_valid_when_matcher 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 86228876cf3d02d0970138b1f12029189ccb9d0c
-  data.tar.gz: 9f536b03bfae63f0e9150473b9462d2c47a3cf56
+  metadata.gz: bfa5bfc671b2323ea01bdb96e8961cdfd28e9d4e
+  data.tar.gz: 000086bef61468b32d52a46e26f1ddb08b0d41bd
 SHA512:
-  metadata.gz: 6c71c832bd4e6e75c0d262904a516c618f9fd662776a175a3702cd88eefc1a81df090dca16ef4c87e025944cd87b70b93dd405d2ef1fa430e4d0c8c9b9f11b4f
-  data.tar.gz: 51ad0846d177728091992445fbf404169b5d155bbf86321578c7c00dceb88ec9cc96713147b26845a40876f2db3e92de44d1917639de310406148d95aed6653d
+  metadata.gz: f912c394bfcca9bf3b0c2954ce498cf63c1676915494afc2c1cd7787d7be83d33946d7f0ab468d5b391d5ceef50e720ed219d17df40bc8133eea917d55812921
+  data.tar.gz: b10fc3102760625bb6d5c427911889e5a3b22f780b38d9604c133efb939bcf602e969780a12d087a580ddc2e5be03f7e26467f0efe8976f964126a9a47e251f4

data/README.md

@@ -118,6 +118,11 @@ be_valid_when(:field).is_float      # Defaults to 3.14
 be_valid_when(:field).is_complex    # Defaults to 42+0i
 be_valid_when(:field).is_rational   # Defaults to 42/1
 be_valid_when(:field).is_bigdecimal # Defaults to 0.42E2
+be_valid_when(:field).is_string     # Defaults to 'value'
+be_valid_when(:field).is_regexp     # Defaults to /^value$/
+be_valid_when(:field).is_array      # Defaults to [42]
+be_valid_when(:field).is_hash       # Defaults to { value: 42 }
+be_valid_when(:field).is_symbol     # Defaults to :value
 ```
 
 ## MIT Licensed

data/lib/rspec/be_valid_when_matcher.rb

@@ -125,18 +125,23 @@ module RSpec
         is(nil, 'not present')
       end
 
-      # Generate #is_* numeric methods.
+      # Generate #is_*(type) methods.
       { number: { value: 42, type: Numeric },
         fixnum: { value: 42, type: Fixnum },
         bignum: { value: 42**13, type: Bignum },
         float: { value: Math::PI, type: Float },
         complex: { value: 42.to_c, type: Complex },
         rational: { value: 42.to_r, type: Rational },
-        bigdecimal: { value: BigDecimal.new('42'), type: BigDecimal } }.each do |name, properties|
-        define_method "is_#{name}" do |number = properties[:value]|
-          fail ArgumentError, "should be #{name}" unless number.is_a? properties[:type]
-
-          is(number, "a #{name}")
+        bigdecimal: { value: BigDecimal.new('42'), type: BigDecimal },
+        string: { value: 'value', type: String },
+        regexp: { value: /^value$/, type: Regexp },
+        array: { value: [42], type: Array },
+        hash: { value: { value: 42 }, type: Hash },
+        symbol: { value: :value, type: Symbol } }.each do |name, properties|
+        define_method "is_#{name}" do |value = properties[:value]|
+          fail ArgumentError, "should be #{name}" unless value.is_a? properties[:type]
+
+          is(value, "a #{name}")
         end
       end
 

data/spec/examples.cache

@@ -1,82 +1,105 @@
 example_id                                              | status | run_time        |
 ------------------------------------------------------- | ------ | --------------- |
-./spec/rspec/be_valid_when/is_bigdecimal_spec.rb[1:1:1] | passed | 0.00012 seconds |
-./spec/rspec/be_valid_when/is_bigdecimal_spec.rb[1:1:2] | passed | 0.0149 seconds  |
+./spec/rspec/be_valid_when/is_array_spec.rb[1:1:1]      | passed | 0.00015 seconds |
+./spec/rspec/be_valid_when/is_array_spec.rb[1:1:2]      | passed | 0.02028 seconds |
+./spec/rspec/be_valid_when/is_array_spec.rb[1:2:1]      | passed | 0.00018 seconds |
+./spec/rspec/be_valid_when/is_array_spec.rb[1:2:2]      | passed | 0.01674 seconds |
+./spec/rspec/be_valid_when/is_array_spec.rb[1:2:3]      | passed | 0.00063 seconds |
+./spec/rspec/be_valid_when/is_bigdecimal_spec.rb[1:1:1] | passed | 0.00014 seconds |
+./spec/rspec/be_valid_when/is_bigdecimal_spec.rb[1:1:2] | passed | 0.01514 seconds |
 ./spec/rspec/be_valid_when/is_bigdecimal_spec.rb[1:2:1] | passed | 0.00014 seconds |
-./spec/rspec/be_valid_when/is_bigdecimal_spec.rb[1:2:2] | passed | 0.01487 seconds |
-./spec/rspec/be_valid_when/is_bigdecimal_spec.rb[1:2:3] | passed | 0.00014 seconds |
+./spec/rspec/be_valid_when/is_bigdecimal_spec.rb[1:2:2] | passed | 0.01668 seconds |
+./spec/rspec/be_valid_when/is_bigdecimal_spec.rb[1:2:3] | passed | 0.00038 seconds |
 ./spec/rspec/be_valid_when/is_bignum_spec.rb[1:1:1]     | passed | 0.00019 seconds |
-./spec/rspec/be_valid_when/is_bignum_spec.rb[1:1:2]     | passed | 0.01449 seconds |
-./spec/rspec/be_valid_when/is_bignum_spec.rb[1:2:1]     | passed | 0.0002 seconds  |
-./spec/rspec/be_valid_when/is_bignum_spec.rb[1:2:2]     | passed | 0.0162 seconds  |
-./spec/rspec/be_valid_when/is_bignum_spec.rb[1:2:3]     | passed | 0.0002 seconds  |
-./spec/rspec/be_valid_when/is_complex_spec.rb[1:1:1]    | passed | 0.00017 seconds |
-./spec/rspec/be_valid_when/is_complex_spec.rb[1:1:2]    | passed | 0.01427 seconds |
-./spec/rspec/be_valid_when/is_complex_spec.rb[1:2:1]    | passed | 0.00017 seconds |
-./spec/rspec/be_valid_when/is_complex_spec.rb[1:2:2]    | passed | 0.01682 seconds |
-./spec/rspec/be_valid_when/is_complex_spec.rb[1:2:3]    | passed | 0.0002 seconds  |
-./spec/rspec/be_valid_when/is_fixnum_spec.rb[1:1:1]     | passed | 0.00017 seconds |
-./spec/rspec/be_valid_when/is_fixnum_spec.rb[1:1:2]     | passed | 0.01927 seconds |
-./spec/rspec/be_valid_when/is_fixnum_spec.rb[1:2:1]     | passed | 0.00012 seconds |
-./spec/rspec/be_valid_when/is_fixnum_spec.rb[1:2:2]     | passed | 0.01536 seconds |
-./spec/rspec/be_valid_when/is_fixnum_spec.rb[1:2:3]     | passed | 0.00016 seconds |
-./spec/rspec/be_valid_when/is_float_spec.rb[1:1:1]      | passed | 0.00014 seconds |
-./spec/rspec/be_valid_when/is_float_spec.rb[1:1:2]      | passed | 0.01379 seconds |
-./spec/rspec/be_valid_when/is_float_spec.rb[1:2:1]      | passed | 0.00014 seconds |
-./spec/rspec/be_valid_when/is_float_spec.rb[1:2:2]      | passed | 0.01466 seconds |
-./spec/rspec/be_valid_when/is_float_spec.rb[1:2:3]      | passed | 0.00019 seconds |
-./spec/rspec/be_valid_when/is_not_present_spec.rb[1:1]  | passed | 0.00012 seconds |
-./spec/rspec/be_valid_when/is_not_present_spec.rb[1:2]  | passed | 0.01479 seconds |
-./spec/rspec/be_valid_when/is_number_spec.rb[1:1:1]     | passed | 0.00045 seconds |
-./spec/rspec/be_valid_when/is_number_spec.rb[1:1:2]     | passed | 0.05618 seconds |
-./spec/rspec/be_valid_when/is_number_spec.rb[1:2:1]     | passed | 0.00015 seconds |
-./spec/rspec/be_valid_when/is_number_spec.rb[1:2:2]     | passed | 0.01527 seconds |
-./spec/rspec/be_valid_when/is_number_spec.rb[1:2:3]     | passed | 0.00106 seconds |
-./spec/rspec/be_valid_when/is_rational_spec.rb[1:1:1]   | passed | 0.00015 seconds |
-./spec/rspec/be_valid_when/is_rational_spec.rb[1:1:2]   | passed | 0.01414 seconds |
-./spec/rspec/be_valid_when/is_rational_spec.rb[1:2:1]   | passed | 0.00011 seconds |
-./spec/rspec/be_valid_when/is_rational_spec.rb[1:2:2]   | passed | 0.01516 seconds |
-./spec/rspec/be_valid_when/is_rational_spec.rb[1:2:3]   | passed | 0.00022 seconds |
-./spec/rspec/be_valid_when/is_spec.rb[1:1]              | passed | 0.00011 seconds |
-./spec/rspec/be_valid_when/is_spec.rb[1:2:1]            | passed | 0.01265 seconds |
-./spec/rspec/be_valid_when/is_spec.rb[1:3:1]            | passed | 0.01573 seconds |
-./spec/rspec/be_valid_when/is_spec.rb[1:3:2]            | passed | 0.00344 seconds |
-./spec/rspec/be_valid_when/is_spec.rb[1:4]              | passed | 0.00016 seconds |
-./spec/rspec/be_valid_when_matcher_spec.rb[1:1]         | passed | 0.00024 seconds |
-./spec/rspec/be_valid_when_matcher_spec.rb[1:2]         | passed | 0.00076 seconds |
-./spec/rspec/be_valid_when_matcher_spec.rb[1:3]         | failed | 0.01192 seconds |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:1:1]       | passed | 0.00035 seconds |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:1:2]       | passed | 0.00057 seconds |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:1:3]       | passed | 0.0001 seconds  |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:1:4]       | passed | 0.00008 seconds |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:1:5]       | passed | 0.00012 seconds |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:1:6]       | passed | 0.00008 seconds |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:1:7]       | passed | 0.00011 seconds |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:1:8]       | passed | 0.00008 seconds |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:1:9]       | passed | 0.0001 seconds  |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:1:10]      | passed | 0.00007 seconds |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:2:1]       | passed | 0.00009 seconds |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:2:2]       | passed | 0.0001 seconds  |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:2:3:1]     | passed | 0.00012 seconds |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:2:3:2]     | passed | 0.00009 seconds |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:2:3:3]     | passed | 0.00014 seconds |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:2:3:4]     | passed | 0.00011 seconds |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:2:3:5]     | passed | 0.0001 seconds  |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:3:1]       | passed | 0.00012 seconds |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:3:2:1]     | passed | 0.0038 seconds  |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:3:2:2]     | passed | 0.0037 seconds  |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:4:1]       | passed | 0.0001 seconds  |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:4:2:1]     | passed | 0.00359 seconds |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:4:2:2]     | passed | 0.0036 seconds  |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:5]         | passed | 0.00015 seconds |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:6:1]       | passed | 0.00017 seconds |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:6:2]       | passed | 0.00015 seconds |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:6:3]       | passed | 0.00009 seconds |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:6:4]       | passed | 0.0001 seconds  |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:7:1:1]     | passed | 0.00363 seconds |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:7:1:2]     | passed | 0.00886 seconds |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:7:2:1]     | passed | 0.00385 seconds |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:7:2:2]     | passed | 0.00826 seconds |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:8:1]       | passed | 0.00374 seconds |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:8:2:1]     | passed | 0.00484 seconds |
-./spec/rspec/be_valid_when_matcher_spec.rb[2:9:1]       | passed | 0.00012 seconds |
+./spec/rspec/be_valid_when/is_bignum_spec.rb[1:1:2]     | passed | 0.0274 seconds  |
+./spec/rspec/be_valid_when/is_bignum_spec.rb[1:2:1]     | passed | 0.00014 seconds |
+./spec/rspec/be_valid_when/is_bignum_spec.rb[1:2:2]     | passed | 0.01933 seconds |
+./spec/rspec/be_valid_when/is_bignum_spec.rb[1:2:3]     | passed | 0.00042 seconds |
+./spec/rspec/be_valid_when/is_complex_spec.rb[1:1:1]    | passed | 0.00015 seconds |
+./spec/rspec/be_valid_when/is_complex_spec.rb[1:1:2]    | passed | 0.01652 seconds |
+./spec/rspec/be_valid_when/is_complex_spec.rb[1:2:1]    | passed | 0.00014 seconds |
+./spec/rspec/be_valid_when/is_complex_spec.rb[1:2:2]    | passed | 0.01823 seconds |
+./spec/rspec/be_valid_when/is_complex_spec.rb[1:2:3]    | passed | 0.00033 seconds |
+./spec/rspec/be_valid_when/is_fixnum_spec.rb[1:1:1]     | passed | 0.00014 seconds |
+./spec/rspec/be_valid_when/is_fixnum_spec.rb[1:1:2]     | passed | 0.01832 seconds |
+./spec/rspec/be_valid_when/is_fixnum_spec.rb[1:2:1]     | passed | 0.00014 seconds |
+./spec/rspec/be_valid_when/is_fixnum_spec.rb[1:2:2]     | passed | 0.01675 seconds |
+./spec/rspec/be_valid_when/is_fixnum_spec.rb[1:2:3]     | passed | 0.0003 seconds  |
+./spec/rspec/be_valid_when/is_float_spec.rb[1:1:1]      | passed | 0.00016 seconds |
+./spec/rspec/be_valid_when/is_float_spec.rb[1:1:2]      | passed | 0.01634 seconds |
+./spec/rspec/be_valid_when/is_float_spec.rb[1:2:1]      | passed | 0.00016 seconds |
+./spec/rspec/be_valid_when/is_float_spec.rb[1:2:2]      | passed | 0.01804 seconds |
+./spec/rspec/be_valid_when/is_float_spec.rb[1:2:3]      | passed | 0.00129 seconds |
+./spec/rspec/be_valid_when/is_hash_spec.rb[1:1:1]       | passed | 0.00012 seconds |
+./spec/rspec/be_valid_when/is_hash_spec.rb[1:1:2]       | passed | 0.02788 seconds |
+./spec/rspec/be_valid_when/is_hash_spec.rb[1:2:1]       | passed | 0.00016 seconds |
+./spec/rspec/be_valid_when/is_hash_spec.rb[1:2:2]       | passed | 0.01855 seconds |
+./spec/rspec/be_valid_when/is_hash_spec.rb[1:2:3]       | passed | 0.00028 seconds |
+./spec/rspec/be_valid_when/is_not_present_spec.rb[1:1]  | passed | 0.00013 seconds |
+./spec/rspec/be_valid_when/is_not_present_spec.rb[1:2]  | passed | 0.01722 seconds |
+./spec/rspec/be_valid_when/is_not_present_spec.rb[1:3]  | passed | 0.00016 seconds |
+./spec/rspec/be_valid_when/is_number_spec.rb[1:1:1]     | passed | 0.00035 seconds |
+./spec/rspec/be_valid_when/is_number_spec.rb[1:1:2]     | passed | 0.02018 seconds |
+./spec/rspec/be_valid_when/is_number_spec.rb[1:2:1]     | passed | 0.00035 seconds |
+./spec/rspec/be_valid_when/is_number_spec.rb[1:2:2]     | passed | 0.02383 seconds |
+./spec/rspec/be_valid_when/is_number_spec.rb[1:2:3]     | passed | 0.00027 seconds |
+./spec/rspec/be_valid_when/is_rational_spec.rb[1:1:1]   | passed | 0.00012 seconds |
+./spec/rspec/be_valid_when/is_rational_spec.rb[1:1:2]   | passed | 0.0147 seconds  |
+./spec/rspec/be_valid_when/is_rational_spec.rb[1:2:1]   | passed | 0.00013 seconds |
+./spec/rspec/be_valid_when/is_rational_spec.rb[1:2:2]   | passed | 0.01734 seconds |
+./spec/rspec/be_valid_when/is_rational_spec.rb[1:2:3]   | passed | 0.00028 seconds |
+./spec/rspec/be_valid_when/is_regex_spec.rb[1:1:1]      | passed | 0.00011 seconds |
+./spec/rspec/be_valid_when/is_regex_spec.rb[1:1:2]      | passed | 0.01755 seconds |
+./spec/rspec/be_valid_when/is_regex_spec.rb[1:2:1]      | passed | 0.00015 seconds |
+./spec/rspec/be_valid_when/is_regex_spec.rb[1:2:2]      | passed | 0.01728 seconds |
+./spec/rspec/be_valid_when/is_regex_spec.rb[1:2:3]      | passed | 0.00031 seconds |
+./spec/rspec/be_valid_when/is_spec.rb[1:1]              | passed | 0.00012 seconds |
+./spec/rspec/be_valid_when/is_spec.rb[1:2:1]            | passed | 0.01421 seconds |
+./spec/rspec/be_valid_when/is_spec.rb[1:3:1]            | passed | 0.01404 seconds |
+./spec/rspec/be_valid_when/is_spec.rb[1:3:2]            | passed | 0.00399 seconds |
+./spec/rspec/be_valid_when/is_spec.rb[1:4]              | passed | 0.0001 seconds  |
+./spec/rspec/be_valid_when/is_string_spec.rb[1:1:1]     | passed | 0.00012 seconds |
+./spec/rspec/be_valid_when/is_string_spec.rb[1:1:2]     | passed | 0.01625 seconds |
+./spec/rspec/be_valid_when/is_string_spec.rb[1:2:1]     | passed | 0.00012 seconds |
+./spec/rspec/be_valid_when/is_string_spec.rb[1:2:2]     | passed | 0.01559 seconds |
+./spec/rspec/be_valid_when/is_string_spec.rb[1:2:3]     | passed | 0.00025 seconds |
+./spec/rspec/be_valid_when/is_symbol_spec.rb[1:1:1]     | passed | 0.00014 seconds |
+./spec/rspec/be_valid_when/is_symbol_spec.rb[1:1:2]     | passed | 0.01691 seconds |
+./spec/rspec/be_valid_when/is_symbol_spec.rb[1:2:1]     | passed | 0.00044 seconds |
+./spec/rspec/be_valid_when/is_symbol_spec.rb[1:2:2]     | passed | 0.05517 seconds |
+./spec/rspec/be_valid_when/is_symbol_spec.rb[1:2:3]     | passed | 0.0011 seconds  |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:1:1]       | passed | 0.00034 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:1:2]       | passed | 0.00067 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:1:3]       | passed | 0.00011 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:1:4]       | passed | 0.00011 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:1:5]       | passed | 0.00009 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:1:6]       | passed | 0.0001 seconds  |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:1:7]       | passed | 0.00009 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:1:8]       | passed | 0.00011 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:1:9]       | passed | 0.0001 seconds  |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:1:10]      | passed | 0.00011 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:2:1]       | passed | 0.00013 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:2:2]       | passed | 0.00014 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:2:3:1]     | passed | 0.00013 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:2:3:2]     | passed | 0.00012 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:2:3:3]     | passed | 0.00014 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:2:3:4]     | passed | 0.00013 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:2:3:5]     | passed | 0.00012 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:3:1]       | passed | 0.00011 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:3:2:1]     | passed | 0.004 seconds   |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:3:2:2]     | passed | 0.0039 seconds  |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:4:1]       | passed | 0.0001 seconds  |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:4:2:1]     | passed | 0.00376 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:4:2:2]     | passed | 0.00394 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:5]         | passed | 0.00016 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:6:1]       | passed | 0.00019 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:6:2]       | passed | 0.00017 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:6:3]       | passed | 0.00013 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:6:4]       | passed | 0.00013 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:7:1:1]     | passed | 0.00408 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:7:1:2]     | passed | 0.00794 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:7:2:1]     | passed | 0.00383 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:7:2:2]     | passed | 0.00828 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:8:1]       | passed | 0.0039 seconds  |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:8:2:1]     | passed | 0.00385 seconds |
+./spec/rspec/be_valid_when_matcher_spec.rb[1:9:1]       | passed | 0.00012 seconds |

data/spec/rspec/be_valid_when/is_array_spec.rb

@@ -0,0 +1,80 @@
+require 'active_model'
+
+# @private
+class FakeModel
+  include ActiveModel::Validations
+
+  attr_accessor :array_field
+  attr_accessor :not_array_field
+
+  validate :array_field_should_be_array,
+           :array_field_cannot_be_empty,
+           :not_array_field_cannot_be_array
+
+  private
+
+  def array_field_should_be_array
+    errors.add(:array_field, 'should be array') unless array_field.is_a? Array
+  end
+
+  def array_field_cannot_be_empty
+    errors.add(:array_field, "can't be empty") if !array_field.nil? && array_field.length == 0
+  end
+
+  def not_array_field_cannot_be_array
+    errors.add(:not_array_field, "can't be array") if not_array_field.is_a? Array
+  end
+end
+
+describe 'be_valid_when#is_array' do
+  let(:model) { FakeModel.new }
+
+  context 'with no arguments' do
+    let(:description) { /^be valid when #array_field is a array \(\[42\]\)$/ }
+
+    let(:passing_matcher) { be_valid_when(:array_field).is_array }
+    let(:failing_matcher) { be_valid_when(:not_array_field).is_array }
+
+    it 'has the correct description' do
+      expect(passing_matcher.description).to match description
+    end
+
+    it 'returns proper result' do
+      expect(passing_matcher.matches? model).to eq true
+      expect(passing_matcher.does_not_match? model).to eq false
+      expect(failing_matcher.matches? model).to eq false
+      expect(failing_matcher.does_not_match? model).to eq true
+    end
+  end
+
+  context 'with one argument' do
+    let(:description) { /^be valid when #array_field is a array \(\[1, 2\]\)$/ }
+
+    let(:passing_matcher) { be_valid_when(:array_field).is_array [1, 2] }
+    let(:failing_matcher) { be_valid_when(:array_field).is_array [] }
+
+    it 'has the correct description' do
+      expect(passing_matcher.description).to match description
+    end
+
+    it 'returns proper result' do
+      expect(passing_matcher.matches? model).to eq true
+      expect(passing_matcher.does_not_match? model).to eq false
+      expect(failing_matcher.matches? model).to eq false
+      expect(failing_matcher.does_not_match? model).to eq true
+    end
+
+    it 'should fail if passed non array' do
+      expect { be_valid_when(:array_field).is_array 42 }.to raise_error ArgumentError
+      expect { be_valid_when(:array_field).is_array 42**42 }.to raise_error ArgumentError
+      expect { be_valid_when(:array_field).is_array 3.14 }.to raise_error ArgumentError
+      expect { be_valid_when(:array_field).is_array 42.to_c }.to raise_error ArgumentError
+      expect { be_valid_when(:array_field).is_array 42.to_r }.to raise_error ArgumentError
+      expect { be_valid_when(:array_field).is_array 'value' }.to raise_error ArgumentError
+      expect { be_valid_when(:array_field).is_array '42' }.to raise_error ArgumentError
+      expect { be_valid_when(:array_field).is_array(/^value$/) }.to raise_error ArgumentError
+      expect { be_valid_when(:array_field).is_array({}) }.to raise_error ArgumentError
+      expect { be_valid_when(:array_field).is_array :value }.to raise_error ArgumentError
+    end
+  end
+end

data/spec/rspec/be_valid_when/is_bigdecimal_spec.rb

@@ -57,11 +57,24 @@ describe 'be_valid_when#is_bigdecimal' do
     end
 
     it 'should fail if passed non bigdecimal' do
+      expect { be_valid_when(:bigdecimal_field).is_bigdecimal 42 }.to raise_error ArgumentError
+      expect { be_valid_when(:bigdecimal_field).is_bigdecimal 42**42 }.to raise_error ArgumentError
+      expect { be_valid_when(:bigdecimal_field).is_bigdecimal 3.14 }.to raise_error ArgumentError
+      expect do
+        be_valid_when(:bigdecimal_field).is_bigdecimal 42.to_c
+      end.to raise_error ArgumentError
+      expect do
+        be_valid_when(:bigdecimal_field).is_bigdecimal 42.to_r
+      end.to raise_error ArgumentError
       expect do
         be_valid_when(:bigdecimal_field).is_bigdecimal 'value'
       end.to raise_error ArgumentError
       expect { be_valid_when(:bigdecimal_field).is_bigdecimal '42' }.to raise_error ArgumentError
-      expect { be_valid_when(:bigdecimal_field).is_bigdecimal 3.14 }.to raise_error ArgumentError
+      expect do
+        be_valid_when(:bigdecimal_field).is_bigdecimal(/^value$/)
+      end.to raise_error ArgumentError
+      expect { be_valid_when(:bigdecimal_field).is_bigdecimal [1, 2] }.to raise_error ArgumentError
+      expect { be_valid_when(:bigdecimal_field).is_bigdecimal({}) }.to raise_error ArgumentError
       expect { be_valid_when(:bigdecimal_field).is_bigdecimal :value }.to raise_error ArgumentError
     end
   end

data/spec/rspec/be_valid_when/is_bignum_spec.rb

@@ -56,10 +56,16 @@ describe 'be_valid_when#is_bignum' do
     end
 
     it 'should fail if passed non bignum' do
-      expect { be_valid_when(:bignum_field).is_bignum 'value' }.to raise_error ArgumentError
-      expect { be_valid_when(:bignum_field).is_bignum '42' }.to raise_error ArgumentError
       expect { be_valid_when(:bignum_field).is_bignum 42 }.to raise_error ArgumentError
       expect { be_valid_when(:bignum_field).is_bignum 3.14 }.to raise_error ArgumentError
+      expect { be_valid_when(:bignum_field).is_bignum 42.to_c }.to raise_error ArgumentError
+      expect { be_valid_when(:bignum_field).is_bignum 42.to_r }.to raise_error ArgumentError
+      expect { be_valid_when(:bignum_field).is_bignum BigDecimal.new }.to raise_error ArgumentError
+      expect { be_valid_when(:bignum_field).is_bignum 'value' }.to raise_error ArgumentError
+      expect { be_valid_when(:bignum_field).is_bignum '42' }.to raise_error ArgumentError
+      expect { be_valid_when(:bignum_field).is_bignum(/^value$/) }.to raise_error ArgumentError
+      expect { be_valid_when(:bignum_field).is_bignum [1, 2] }.to raise_error ArgumentError
+      expect { be_valid_when(:bignum_field).is_bignum({}) }.to raise_error ArgumentError
       expect { be_valid_when(:bignum_field).is_bignum :value }.to raise_error ArgumentError
     end
   end

data/spec/rspec/be_valid_when/is_complex_spec.rb

@@ -56,11 +56,18 @@ describe 'be_valid_when#is_complex' do
     end
 
     it 'should fail if passed non complex' do
-      expect { be_valid_when(:complex_field).is_complex 'value' }.to raise_error ArgumentError
-      expect { be_valid_when(:complex_field).is_complex '42' }.to raise_error ArgumentError
       expect { be_valid_when(:complex_field).is_complex 42 }.to raise_error ArgumentError
       expect { be_valid_when(:complex_field).is_complex 42**42 }.to raise_error ArgumentError
       expect { be_valid_when(:complex_field).is_complex 3.14 }.to raise_error ArgumentError
+      expect { be_valid_when(:complex_field).is_complex 42.to_r }.to raise_error ArgumentError
+      expect do
+        be_valid_when(:complex_field).is_complex BigDecimal.new
+      end.to raise_error ArgumentError
+      expect { be_valid_when(:complex_field).is_complex 'value' }.to raise_error ArgumentError
+      expect { be_valid_when(:complex_field).is_complex '42' }.to raise_error ArgumentError
+      expect { be_valid_when(:complex_field).is_complex(/^value$/) }.to raise_error ArgumentError
+      expect { be_valid_when(:complex_field).is_complex [1, 2] }.to raise_error ArgumentError
+      expect { be_valid_when(:complex_field).is_complex({}) }.to raise_error ArgumentError
       expect { be_valid_when(:complex_field).is_complex :value }.to raise_error ArgumentError
     end
   end

data/spec/rspec/be_valid_when/is_fixnum_spec.rb

@@ -56,9 +56,16 @@ describe 'be_valid_when#is_fixnum' do
     end
 
     it 'should fail if passed non fixnum' do
+      expect { be_valid_when(:fixnum_field).is_fixnum 42**42 }.to raise_error ArgumentError
+      expect { be_valid_when(:fixnum_field).is_fixnum 3.14 }.to raise_error ArgumentError
+      expect { be_valid_when(:fixnum_field).is_fixnum 42.to_c }.to raise_error ArgumentError
+      expect { be_valid_when(:fixnum_field).is_fixnum 42.to_r }.to raise_error ArgumentError
+      expect { be_valid_when(:fixnum_field).is_fixnum BigDecimal.new }.to raise_error ArgumentError
       expect { be_valid_when(:fixnum_field).is_fixnum 'value' }.to raise_error ArgumentError
       expect { be_valid_when(:fixnum_field).is_fixnum '42' }.to raise_error ArgumentError
-      expect { be_valid_when(:fixnum_field).is_fixnum 3.14 }.to raise_error ArgumentError
+      expect { be_valid_when(:fixnum_field).is_fixnum(/^value$/) }.to raise_error ArgumentError
+      expect { be_valid_when(:fixnum_field).is_fixnum [1, 2] }.to raise_error ArgumentError
+      expect { be_valid_when(:fixnum_field).is_fixnum({}) }.to raise_error ArgumentError
       expect { be_valid_when(:fixnum_field).is_fixnum :value }.to raise_error ArgumentError
     end
   end

data/spec/rspec/be_valid_when/is_float_spec.rb

@@ -56,10 +56,16 @@ describe 'be_valid_when#is_float' do
     end
 
     it 'should fail if passed non float' do
-      expect { be_valid_when(:float_field).is_float 'value' }.to raise_error ArgumentError
-      expect { be_valid_when(:float_field).is_float '42' }.to raise_error ArgumentError
       expect { be_valid_when(:float_field).is_float 42 }.to raise_error ArgumentError
       expect { be_valid_when(:float_field).is_float 42**42 }.to raise_error ArgumentError
+      expect { be_valid_when(:float_field).is_float 42.to_c }.to raise_error ArgumentError
+      expect { be_valid_when(:float_field).is_float 42.to_r }.to raise_error ArgumentError
+      expect { be_valid_when(:float_field).is_float BigDecimal.new }.to raise_error ArgumentError
+      expect { be_valid_when(:float_field).is_float 'value' }.to raise_error ArgumentError
+      expect { be_valid_when(:float_field).is_float '42' }.to raise_error ArgumentError
+      expect { be_valid_when(:float_field).is_float(/^value$/) }.to raise_error ArgumentError
+      expect { be_valid_when(:float_field).is_float [1, 2] }.to raise_error ArgumentError
+      expect { be_valid_when(:float_field).is_float({}) }.to raise_error ArgumentError
       expect { be_valid_when(:float_field).is_float :value }.to raise_error ArgumentError
     end
   end

data/spec/rspec/be_valid_when/is_hash_spec.rb

@@ -0,0 +1,80 @@
+require 'active_model'
+
+# @private
+class FakeModel
+  include ActiveModel::Validations
+
+  attr_accessor :hash_field
+  attr_accessor :not_hash_field
+
+  validate :hash_field_should_be_hash,
+           :hash_field_cannot_be_empty,
+           :not_hash_field_cannot_be_hash
+
+  private
+
+  def hash_field_should_be_hash
+    errors.add(:hash_field, 'should be hash') unless hash_field.is_a? Hash
+  end
+
+  def hash_field_cannot_be_empty
+    errors.add(:hash_field, "can't be empty") if !hash_field.nil? && hash_field.keys.length == 0
+  end
+
+  def not_hash_field_cannot_be_hash
+    errors.add(:not_hash_field, "can't be hash") if not_hash_field.is_a? Hash
+  end
+end
+
+describe 'be_valid_when#is_hash' do
+  let(:model) { FakeModel.new }
+
+  context 'with no arguments' do
+    let(:description) { /^be valid when #hash_field is a hash \(\{:value=>42\}\)$/ }
+
+    let(:passing_matcher) { be_valid_when(:hash_field).is_hash }
+    let(:failing_matcher) { be_valid_when(:not_hash_field).is_hash }
+
+    it 'has the correct description' do
+      expect(passing_matcher.description).to match description
+    end
+
+    it 'returns proper result' do
+      expect(passing_matcher.matches? model).to eq true
+      expect(passing_matcher.does_not_match? model).to eq false
+      expect(failing_matcher.matches? model).to eq false
+      expect(failing_matcher.does_not_match? model).to eq true
+    end
+  end
+
+  context 'with one argument' do
+    let(:description) { /^be valid when #hash_field is a hash \({:a=>1\}\)$/ }
+
+    let(:passing_matcher) { be_valid_when(:hash_field).is_hash(a: 1) }
+    let(:failing_matcher) { be_valid_when(:hash_field).is_hash({}) }
+
+    it 'has the correct description' do
+      expect(passing_matcher.description).to match description
+    end
+
+    it 'returns proper result' do
+      expect(passing_matcher.matches? model).to eq true
+      expect(passing_matcher.does_not_match? model).to eq false
+      expect(failing_matcher.matches? model).to eq false
+      expect(failing_matcher.does_not_match? model).to eq true
+    end
+
+    it 'should fail if passed non hash' do
+      expect { be_valid_when(:hash_field).is_hash 42 }.to raise_error ArgumentError
+      expect { be_valid_when(:hash_field).is_hash 42**42 }.to raise_error ArgumentError
+      expect { be_valid_when(:hash_field).is_hash 3.14 }.to raise_error ArgumentError
+      expect { be_valid_when(:hash_field).is_hash 42.to_c }.to raise_error ArgumentError
+      expect { be_valid_when(:hash_field).is_hash 42.to_r }.to raise_error ArgumentError
+      expect { be_valid_when(:hash_field).is_hash 'value' }.to raise_error ArgumentError
+      expect { be_valid_when(:hash_field).is_hash '42' }.to raise_error ArgumentError
+      expect { be_valid_when(:hash_field).is_hash(/^value$/) }.to raise_error ArgumentError
+      expect { be_valid_when(:hash_field).is_hash [1, 2] }.to raise_error ArgumentError
+      expect { be_valid_when(:hash_field).is_hash :value }.to raise_error ArgumentError
+    end
+  end
+end

data/spec/rspec/be_valid_when/is_not_present_spec.rb

@@ -29,4 +29,8 @@ describe 'be_valid_when#is_not_present' do
     expect(failing_matcher.matches? model).to eq false
     expect(failing_matcher.does_not_match? model).to eq true
   end
+
+  it 'does not accept any arguments' do
+    expect { be_valid_when(:field).is_not_present 'value' }.to raise_error ArgumentError
+  end
 end

data/spec/rspec/be_valid_when/is_number_spec.rb

@@ -52,6 +52,9 @@ describe 'be_valid_when#is_number' do
     it 'should fail if passed non number' do
       expect { be_valid_when(:number_field).is_number 'value' }.to raise_error ArgumentError
       expect { be_valid_when(:number_field).is_number '42' }.to raise_error ArgumentError
+      expect { be_valid_when(:number_field).is_number(/^value$/) }.to raise_error ArgumentError
+      expect { be_valid_when(:number_field).is_number [1, 2] }.to raise_error ArgumentError
+      expect { be_valid_when(:number_field).is_number({}) }.to raise_error ArgumentError
       expect { be_valid_when(:number_field).is_number :value }.to raise_error ArgumentError
     end
   end

data/spec/rspec/be_valid_when/is_rational_spec.rb

@@ -56,11 +56,18 @@ describe 'be_valid_when#is_rational' do
     end
 
     it 'should fail if passed non rational' do
-      expect { be_valid_when(:rational_field).is_rational 'value' }.to raise_error ArgumentError
-      expect { be_valid_when(:rational_field).is_rational '42' }.to raise_error ArgumentError
-      expect { be_valid_when(:rational_field).is_rational 3.14 }.to raise_error ArgumentError
+      expect { be_valid_when(:rational_field).is_rational 42 }.to raise_error ArgumentError
       expect { be_valid_when(:rational_field).is_rational 42**42 }.to raise_error ArgumentError
+      expect { be_valid_when(:rational_field).is_rational 3.14 }.to raise_error ArgumentError
       expect { be_valid_when(:rational_field).is_rational 42.to_c }.to raise_error ArgumentError
+      expect do
+        be_valid_when(:rational_field).is_rational BigDecimal.new
+      end.to raise_error ArgumentError
+      expect { be_valid_when(:rational_field).is_rational 'value' }.to raise_error ArgumentError
+      expect { be_valid_when(:rational_field).is_rational '42' }.to raise_error ArgumentError
+      expect { be_valid_when(:rational_field).is_rational(/^value$/) }.to raise_error ArgumentError
+      expect { be_valid_when(:rational_field).is_rational [1, 2] }.to raise_error ArgumentError
+      expect { be_valid_when(:rational_field).is_rational({}) }.to raise_error ArgumentError
       expect { be_valid_when(:rational_field).is_rational :value }.to raise_error ArgumentError
     end
   end

data/spec/rspec/be_valid_when/is_regex_spec.rb

@@ -0,0 +1,80 @@
+require 'active_model'
+
+# @private
+class FakeModel
+  include ActiveModel::Validations
+
+  attr_accessor :regexp_field
+  attr_accessor :not_regexp_field
+
+  validate :regexp_field_should_be_regexp,
+           :regexp_field_cannot_be_empty,
+           :not_regexp_field_cannot_be_regexp
+
+  private
+
+  def regexp_field_should_be_regexp
+    errors.add(:regexp_field, 'should be regexp') unless regexp_field.is_a? Regexp
+  end
+
+  def regexp_field_cannot_be_empty
+    errors.add(:regexp_field, "can't be empty") if regexp_field.inspect.length < 3
+  end
+
+  def not_regexp_field_cannot_be_regexp
+    errors.add(:not_regexp_field, "can't be regexp") if not_regexp_field.is_a? Regexp
+  end
+end
+
+describe 'be_valid_when#is_regexp' do
+  let(:model) { FakeModel.new }
+
+  context 'with no arguments' do
+    let(:description) { %r{^be valid when #regexp_field is a regexp \(/\^value\$/\)$} }
+
+    let(:passing_matcher) { be_valid_when(:regexp_field).is_regexp }
+    let(:failing_matcher) { be_valid_when(:not_regexp_field).is_regexp }
+
+    it 'has the correct description' do
+      expect(passing_matcher.description).to match description
+    end
+
+    it 'returns proper result' do
+      expect(passing_matcher.matches? model).to eq true
+      expect(passing_matcher.does_not_match? model).to eq false
+      expect(failing_matcher.matches? model).to eq false
+      expect(failing_matcher.does_not_match? model).to eq true
+    end
+  end
+
+  context 'with one argument' do
+    let(:description) { %r{^be valid when #regexp_field is a regexp \(/some regexp/\)$} }
+
+    let(:passing_matcher) { be_valid_when(:regexp_field).is_regexp(/some regexp/) }
+    let(:failing_matcher) { be_valid_when(:regexp_field).is_regexp(//) }
+
+    it 'has the correct description' do
+      expect(passing_matcher.description).to match description
+    end
+
+    it 'returns proper result' do
+      expect(passing_matcher.matches? model).to eq true
+      expect(passing_matcher.does_not_match? model).to eq false
+      expect(failing_matcher.matches? model).to eq false
+      expect(failing_matcher.does_not_match? model).to eq true
+    end
+
+    it 'should fail if passed non regexp' do
+      expect { be_valid_when(:regexp_field).is_regexp 42 }.to raise_error ArgumentError
+      expect { be_valid_when(:regexp_field).is_regexp 42**42 }.to raise_error ArgumentError
+      expect { be_valid_when(:regexp_field).is_regexp 3.14 }.to raise_error ArgumentError
+      expect { be_valid_when(:regexp_field).is_regexp 42.to_c }.to raise_error ArgumentError
+      expect { be_valid_when(:regexp_field).is_regexp 42.to_r }.to raise_error ArgumentError
+      expect { be_valid_when(:regexp_field).is_regexp 'value' }.to raise_error ArgumentError
+      expect { be_valid_when(:regexp_field).is_regexp '42' }.to raise_error ArgumentError
+      expect { be_valid_when(:regexp_field).is_regexp [1, 2] }.to raise_error ArgumentError
+      expect { be_valid_when(:regexp_field).is_regexp({}) }.to raise_error ArgumentError
+      expect { be_valid_when(:regexp_field).is_regexp :value }.to raise_error ArgumentError
+    end
+  end
+end

data/spec/rspec/be_valid_when/is_string_spec.rb

@@ -0,0 +1,70 @@
+require 'active_model'
+
+# @private
+class FakeModel
+  include ActiveModel::Validations
+
+  attr_accessor :string_field
+  attr_accessor :not_string_field
+
+  validates_length_of :string_field, minimum: 4
+  validate :not_string_field_cannot_be_string
+
+  private
+
+  def not_string_field_cannot_be_string
+    errors.add(:not_string_field, "can't be string") if not_string_field.is_a? String
+  end
+end
+
+describe 'be_valid_when#is_string' do
+  let(:model) { FakeModel.new }
+
+  context 'with no arguments' do
+    let(:description) { /^be valid when #string_field is a string \("value"\)$/ }
+
+    let(:passing_matcher) { be_valid_when(:string_field).is_string }
+    let(:failing_matcher) { be_valid_when(:not_string_field).is_string }
+
+    it 'has the correct description' do
+      expect(passing_matcher.description).to match description
+    end
+
+    it 'returns proper result' do
+      expect(passing_matcher.matches? model).to eq true
+      expect(passing_matcher.does_not_match? model).to eq false
+      expect(failing_matcher.matches? model).to eq false
+      expect(failing_matcher.does_not_match? model).to eq true
+    end
+  end
+
+  context 'with one argument' do
+    let(:description) { /^be valid when #string_field is a string \("some string"\)$/ }
+
+    let(:passing_matcher) { be_valid_when(:string_field).is_string 'some string' }
+    let(:failing_matcher) { be_valid_when(:string_field).is_string 'a' }
+
+    it 'has the correct description' do
+      expect(passing_matcher.description).to match description
+    end
+
+    it 'returns proper result' do
+      expect(passing_matcher.matches? model).to eq true
+      expect(passing_matcher.does_not_match? model).to eq false
+      expect(failing_matcher.matches? model).to eq false
+      expect(failing_matcher.does_not_match? model).to eq true
+    end
+
+    it 'should fail if passed non string' do
+      expect { be_valid_when(:string_field).is_string 42 }.to raise_error ArgumentError
+      expect { be_valid_when(:string_field).is_string 42**42 }.to raise_error ArgumentError
+      expect { be_valid_when(:string_field).is_string 3.14 }.to raise_error ArgumentError
+      expect { be_valid_when(:string_field).is_string 42.to_c }.to raise_error ArgumentError
+      expect { be_valid_when(:string_field).is_string 42.to_r }.to raise_error ArgumentError
+      expect { be_valid_when(:string_field).is_string(/^value$/) }.to raise_error ArgumentError
+      expect { be_valid_when(:string_field).is_string [1, 2] }.to raise_error ArgumentError
+      expect { be_valid_when(:string_field).is_string({}) }.to raise_error ArgumentError
+      expect { be_valid_when(:string_field).is_string :value }.to raise_error ArgumentError
+    end
+  end
+end

data/spec/rspec/be_valid_when/is_symbol_spec.rb

@@ -0,0 +1,80 @@
+require 'active_model'
+
+# @private
+class FakeModel
+  include ActiveModel::Validations
+
+  attr_accessor :symbol_field
+  attr_accessor :not_symbol_field
+
+  validate :symbol_field_should_be_symbol,
+           :symbol_field_cannot_be_short,
+           :not_symbol_field_cannot_be_symbol
+
+  private
+
+  def symbol_field_should_be_symbol
+    errors.add(:symbol_field, 'should be symbol') unless symbol_field.is_a? Symbol
+  end
+
+  def symbol_field_cannot_be_short
+    errors.add(:symbol_field, "can't be short") if !symbol_field.nil? && symbol_field.length < 2
+  end
+
+  def not_symbol_field_cannot_be_symbol
+    errors.add(:not_symbol_field, "can't be symbol") if not_symbol_field.is_a? Symbol
+  end
+end
+
+describe 'be_valid_when#is_symbol' do
+  let(:model) { FakeModel.new }
+
+  context 'with no arguments' do
+    let(:description) { /^be valid when #symbol_field is a symbol \(:value\)$/ }
+
+    let(:passing_matcher) { be_valid_when(:symbol_field).is_symbol }
+    let(:failing_matcher) { be_valid_when(:not_symbol_field).is_symbol }
+
+    it 'has the correct description' do
+      expect(passing_matcher.description).to match description
+    end
+
+    it 'returns proper result' do
+      expect(passing_matcher.matches? model).to eq true
+      expect(passing_matcher.does_not_match? model).to eq false
+      expect(failing_matcher.matches? model).to eq false
+      expect(failing_matcher.does_not_match? model).to eq true
+    end
+  end
+
+  context 'with one argument' do
+    let(:description) { /^be valid when #symbol_field is a symbol \(:some_symbol\)$/ }
+
+    let(:passing_matcher) { be_valid_when(:symbol_field).is_symbol :some_symbol }
+    let(:failing_matcher) { be_valid_when(:symbol_field).is_symbol :a }
+
+    it 'has the correct description' do
+      expect(passing_matcher.description).to match description
+    end
+
+    it 'returns proper result' do
+      expect(passing_matcher.matches? model).to eq true
+      expect(passing_matcher.does_not_match? model).to eq false
+      expect(failing_matcher.matches? model).to eq false
+      expect(failing_matcher.does_not_match? model).to eq true
+    end
+
+    it 'should fail if passed non symbol' do
+      expect { be_valid_when(:symbol_field).is_symbol 42 }.to raise_error ArgumentError
+      expect { be_valid_when(:symbol_field).is_symbol 42**42 }.to raise_error ArgumentError
+      expect { be_valid_when(:symbol_field).is_symbol 3.14 }.to raise_error ArgumentError
+      expect { be_valid_when(:symbol_field).is_symbol 42.to_c }.to raise_error ArgumentError
+      expect { be_valid_when(:symbol_field).is_symbol 42.to_r }.to raise_error ArgumentError
+      expect { be_valid_when(:symbol_field).is_symbol 'value' }.to raise_error ArgumentError
+      expect { be_valid_when(:symbol_field).is_symbol '42' }.to raise_error ArgumentError
+      expect { be_valid_when(:symbol_field).is_symbol(/^value$/) }.to raise_error ArgumentError
+      expect { be_valid_when(:symbol_field).is_symbol [1, 2] }.to raise_error ArgumentError
+      expect { be_valid_when(:symbol_field).is_symbol({}) }.to raise_error ArgumentError
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rspec-be_valid_when_matcher
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Marek Tuchowski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-16 00:00:00.000000000 Z
+date: 2015-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -50,15 +50,20 @@ files:
 - README.md
 - lib/rspec/be_valid_when_matcher.rb
 - spec/examples.cache
+- spec/rspec/be_valid_when/is_array_spec.rb
 - spec/rspec/be_valid_when/is_bigdecimal_spec.rb
 - spec/rspec/be_valid_when/is_bignum_spec.rb
 - spec/rspec/be_valid_when/is_complex_spec.rb
 - spec/rspec/be_valid_when/is_fixnum_spec.rb
 - spec/rspec/be_valid_when/is_float_spec.rb
+- spec/rspec/be_valid_when/is_hash_spec.rb
 - spec/rspec/be_valid_when/is_not_present_spec.rb
 - spec/rspec/be_valid_when/is_number_spec.rb
 - spec/rspec/be_valid_when/is_rational_spec.rb
+- spec/rspec/be_valid_when/is_regex_spec.rb
 - spec/rspec/be_valid_when/is_spec.rb
+- spec/rspec/be_valid_when/is_string_spec.rb
+- spec/rspec/be_valid_when/is_symbol_spec.rb
 - spec/rspec/be_valid_when_matcher_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/mtuchowski/rspec-be_valid_when_matcher
@@ -90,6 +95,7 @@ summary: RSpec be_valid_when matcher for ActiveRecord models.
 test_files:
 - spec/spec_helper.rb
 - spec/rspec/be_valid_when_matcher_spec.rb
+- spec/rspec/be_valid_when/is_symbol_spec.rb
 - spec/rspec/be_valid_when/is_number_spec.rb
 - spec/rspec/be_valid_when/is_float_spec.rb
 - spec/rspec/be_valid_when/is_rational_spec.rb
@@ -97,7 +103,11 @@ test_files:
 - spec/rspec/be_valid_when/is_spec.rb
 - spec/rspec/be_valid_when/is_not_present_spec.rb
 - spec/rspec/be_valid_when/is_fixnum_spec.rb
+- spec/rspec/be_valid_when/is_array_spec.rb
 - spec/rspec/be_valid_when/is_bigdecimal_spec.rb
 - spec/rspec/be_valid_when/is_complex_spec.rb
+- spec/rspec/be_valid_when/is_string_spec.rb
+- spec/rspec/be_valid_when/is_regex_spec.rb
+- spec/rspec/be_valid_when/is_hash_spec.rb
 - spec/examples.cache
 has_rdoc: