valligator 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4c57e3ef079cd6494f2b67e9abe8b5e46336805d
-  data.tar.gz: a6bfdaad97a85777458cc6219b901cea77269b74
+  metadata.gz: 86beebd4198e35c0e7accf7e5ae49e8e100793f7
+  data.tar.gz: 3d1cf322859147e0c6e238cdc74b7d3a3a32f482
 SHA512:
-  metadata.gz: 95a39fb2d9a3b89483587da462de9c593841e2963b8ed4a36ab076182b833ef4f1e360afac7188bbef3b68ebd98a5b837792e699f30c239b6c670962195307f5
-  data.tar.gz: d821f39b08f9974b2fa6ec2793a7d5b53dcadee4aaf936bfb4a32e9c87641af9e8fe44452841947d9361722934e58eaa12d2b06fe5ffc8a9cb197a0e22883e64
+  metadata.gz: 46e30c31a694e91f20d1488b32b619b08cd0e2aad583f7a6c20cf97d77d245c5f7299f60eccfb972e3ead9a0bdff20377949eae2c15b181de7e998b017b39799
+  data.tar.gz: 8a794b107f51b596f1bb3de90c280e3d1170db81ee9188b54a434f004fac43744028cc0ffcb46cb3d6718dd2d0388acb6570baa687d3932ec51443c19da74338

data/Gemfile

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

data/HISTORY.md

@@ -1,4 +1,12 @@
-#### 1.0.2
+#### 1.0.3
+  - **is_instance_of** renamed to **is_kind_of**
+  - **is_not_instance_of** renamed to **is_not_kind_of**
+  - new helper method: Valligator::Helper#vh(Hash)
 
+#### 1.0.2
   - **is_instance_of** got alias **is_a**
-  - **is_not_instance_of** got alias **is_not_a**
+  - **is_not_instance_of** got alias **is_not_a**
+
+#### 1.0.3
+  - **is_instance_of** renamed to **is_kind_of**
+  - **is_not_instance_of** renamed to **is_not_kind_of**

data/README.md

@@ -1,5 +1,4 @@
-# Valligator
-
+# Valligator [![Build Status](https://travis-ci.org/konstantin-dzreev/valligator.svg?branch=master)](https://travis-ci.org/konstantin-dzreev/valligator) [![Gem Version](https://badge.fury.io/rb/valligator.svg)](https://rubygems.org/gems/valligator)
 
 ## Ruby objects validator
 
@@ -28,35 +27,48 @@ gem install valligator
 
 ## Statements
 
-There are 3 validations (a.k.a. statements) that the Valligator supports:
+There are 3 positive and 3 negative validations (a.k.a. statements) that the Valligator supports:
+
 
-#### speaks
+#### speaks, does_not_speak
 
 ```
   testee.speaks(*methods)
   testee.does_not_speak(*methods)
+
+  # a method to be tested can be included into the validation name:
+  testee.speaks_<method>
+  testee.does_not_speak_<method>
 ```
-  - _methods_ are symbols
+  - _methods_ is a list of symbols
 
 The validations passes when testee responds to all (or none in negative case) the methods from the list.
 
-#### is_instance_of, is_a
+
+#### is_kind_of, is_not_kind_of
+Aliases: **is_a** and **is_not_a**.
+
 ```
-  testee.is_instance_of(*classes)
-  testee.is_not_instance_of(*classes)
+  testee.is_kind_of(*classes)
+  testee.is_not_kind_of(*classes)
 ```
-  - _classes_ a list of ruby classes
+  - _classes_ is 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).
 
-**is_instance_of** and **is_not_instance_of** have aliases **is_a** and **is_not_a**
 
-#### asserts, is, has
+#### asserts, asserts_not
+Aliases: **is**, **has** and **is_not**, **does_not_have**. All of them are absolutely identical, you can use what ever sounds more grammatically correct: _is(:active?)_, _has(:apples)_, _asserts(:respond_to?, :foo)_, etc.
+
 ```
   testee.asserts(method, *method_args, &block)
   testee.asserts_not(method, *method_args, &block)
+
+  # a method to be tested can be included into the validation name:
+  testee.asserts_<method>(*method_args, &block)
+  testee.asserts_not_<method>(*method_args, &block)
 ```
-  - _method_ a method to be calld on testee
+  - _method_ a method to be called on testee
   - _method_args_ (optional) the method arguments
   - _block_ (optional) a block to be invoked in the context of the _method_ response
 
@@ -75,9 +87,8 @@ If it does not sound clear, then it is something like this:
   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 }).
+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
 
@@ -89,25 +100,19 @@ Each statement, if it does not fail, returns an instance of the Valligator, so t
 
 ## 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_a_ statement the error message wold look like:
+When validation fails a Valligator::ValidationError is raised.
 
 ```
-Valligator::ValidationError: at testee#1.is_a
-```
-
-but if it would fail on _has_ then the error would be
-
-```
-Valligator::ValidationError: at testee#1.is_a.is_not.has
+Valligator.new(:foo).is_empty? #=>
+    Valligator::ValidationError: `testee#1': method `empty?' returned falsy value
 ```
 
 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_a(String).has(:size){self > 10}
-  #=> Valligator::ValidationError: at `short.is_a.has'
+testee.is_a(String).has(:size){self > 10} #=>
+  Valligator::ValidationError: `short': method `size' returned falsy value
 ```
 
 ## Examples
@@ -126,15 +131,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_a(String)
-   #=> Valligator::ValidationError: at testee#3.has.has.is_a'
+Valligator.new(*testees).has(:size){self == 3}.has(:[], 0){self == 'b'}.is_a(String) #=>
+  Valligator::ValidationError: `testee#3': should be Symbol
 ```
 
 Validate that all hash values are Integers <= 2
 ```
 h = { foo: 1, bar: 2, baz: 3 }
-Valligator.new(*h.values, names: h.keys).is_a(Integer).asserts(:<= , 2)
-  #=> Valligator::ValidationError: at `baz.is_a.asserts'
+Valligator.new(*h.values, names: h.keys).is_a(Integer).asserts(:<= , 2) #=>
+  Valligator::ValidationError: `baz': method `<=' returned falsy value
 ```
 
 ## More examples
@@ -245,6 +250,11 @@ end
 rake test
 ```
 
+## API contract
+
+Until version 1.1.0 API contract is a subject to change
+
+
 ## License
 
 [MIT](https://opensource.org/licenses/mit-license.php) <br/>

data/Rakefile

@@ -2,4 +2,6 @@ require 'rake/testtask'
 
 Rake::TestTask.new do |t|
   t.pattern = "test/**/*_test.rb"
-end
+end
+
+task :default => :test

data/VERSION

@@ -1 +1 @@
-1.0.2
+1.0.3

data/lib/valligator.rb

@@ -1,7 +1,10 @@
+require 'pathname'
 require_relative 'valligator_helper'
 
 class Valligator
-  Error            = Class.new(StandardError)
+  VERSION         = File.read(Pathname(__FILE__).dirname.join('../VERSION')).strip
+
+  Error           = Class.new(StandardError)
   ValidationError = Class.new(Error)
 
   INFINITY = 1/0.0
@@ -19,7 +22,7 @@ class Valligator
   #
   # @example
   #   # validate that testee is an instance of String
-  #   Valligator.new('foo').is_instance_of(String) #=> OK
+  #   Valligator.new('foo').is_kind_of(String) #=> OK
   #
   # @example
   #   # validate that all testees respond to :to_s and :upcase methods
@@ -28,14 +31,14 @@ class Valligator
   # @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'
+  #   Valligator.new(*testees).has(:size){self == 3}.has(:[], 0){self == 'b'}.is_kind_of(String)
+  #     #=> Valligator::ValidationError: at `testee#3.has.has.is_kind_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'
+  #   Valligator.new(*h.values, names: h.keys).is_kind_of(Integer).asserts(:<= , 2)
+  #     #=> Valligator::ValidationError: at `baz.is_kind_of.asserts'
   #
   def initialize(*testees, names: nil)
     @testees = testees
@@ -67,13 +70,13 @@ class Valligator
   # @raise [Valligator::ValidationError]
   #
   # @example
-  #   Valligator.new('foo').is_instance_of(Integer, String) #=> OK
-  #   Valligator.new('foo').is_instance_of(Integer, Array)  #=> Valligator::ValidationError
+  #   Valligator.new('foo').is_kind_of(Integer, String) #=> OK
+  #   Valligator.new('foo').is_kind_of(Integer, Array)  #=> Valligator::ValidationError
   #
   # @see #is_a
   #
-  def is_instance_of(*classes)
-    clone._is_instance_of(__method__, *classes)
+  def is_kind_of(*classes)
+    clone._is_kind_of(__method__, *classes)
   end
 
 
@@ -84,27 +87,27 @@ class 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
+  #   Valligator.new('foo').is_not_kind_of(Integer, String) #=> Valligator::ValidationError
+  #   Valligator.new('foo').is_not_kind_of(Integer, Array) #=> OK
   #
   # @see #is_not_a
   #
-  def is_not_instance_of(*classes)
-    clone._is_instance_of(__method__, *classes)
+  def is_not_kind_of(*classes)
+    clone._is_kind_of(__method__, *classes)
   end
 
 
-  # Is an alias for {#is_instance_of} method
+  # Is an alias for {#is_kind_of} method
   #
   def is_a(*classes)
-    clone._is_instance_of(__method__, *classes)
+    clone._is_kind_of(__method__, *classes)
   end
 
 
-  # Is an alias for {#is_not_instance_of} method
+  # Is an alias for {#is_not_kind_of} method
   #
   def is_not_a(*classes)
-    clone._is_instance_of(__method__, *classes)
+    clone._is_kind_of(__method__, *classes)
   end
 
 
@@ -247,18 +250,6 @@ class Valligator
   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]
@@ -292,10 +283,21 @@ class Valligator
 
 
   #------------------------------------------
-  # Validations
+  # Validations and Errors
   #------------------------------------------
 
 
+  # Raises ArgumentError exception
+  #
+  # @param [Class] exception
+  # @param [Integer] idx  Testee index
+  # @param [nil,String] msg Error explanation (when required)
+  #
+  def argument_error(exception, idx, msg)
+    raise(exception, "%s at `%s.%s'" % [msg, name_by_idx(idx), @stack.join('.')])
+  end
+
+
   # Validates number of arguments
   #
   # @param [Array<Object>] args
@@ -307,7 +309,7 @@ class Valligator
     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])
+    argument_error(ArgumentError, 0, 'wrong number of arguments (%s for %s)' % [args.size, expected])
   end
 
 
@@ -322,7 +324,7 @@ class Valligator
   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])
+    argument_error(ArgumentError, 0, 'wrong argument type (arg#%d is a %s instead of %s)' % [arg_idx, arg.class.name, classes])
   end
 
 
@@ -338,19 +340,53 @@ class Valligator
     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])
+    argument_error(NoMethodError, idx, 'undefined method `%s\' for %s:%s' % [method, str, object.class.name])
+  end
+
+
+  # Raises ValidationError exception
+  #
+  # @param [Class] exception
+  # @param option [Integer] idx  Testee index
+  # @param option [nil,String] msg Error explanation (when required)
+  #
+  def validation_error(idx, msg)
+    raise(ValidationError, "`%s': %s" % [name_by_idx(idx), msg])
+  end
+
+
+  def raise_is_kind_of_validation_error(equality, idx, classes)
+    validation_error(idx, "should not be %s" % [@testees[idx].class.name])
+  end
+
+
+  def raise_speaks_validation_error(equality, idx, method)
+    verb = equality ? "should" : "should not"
+    validation_error(idx, "%s respond to method `%s'" % [verb, method])
   end
 
 
+  def raise_asserts_validation_error(equality, idx, method, args, block, error)
+    msg = "method `%s' " % method
+    if error
+      msg += 'failed: %s: %s' % [error.class.name, error.message]
+    else
+      msg += 'returned %s value' % (equality ? 'falsy' : 'truthy')
+    end
+    validation_error(idx, msg)
+  end
+
+
+
   #------------------------------------------
   # Statements
   #------------------------------------------
 
 
   # @private
-  # @see #is_instance_of
+  # @see #is_kind_of
   #
-  def _is_instance_of(statement, *classes)
+  def _is_kind_of(statement, *classes)
     push(statement)
     equality = !statement[/not/]
 
@@ -360,7 +396,10 @@ class Valligator
     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 }
+    matches.each_with_index do |match, idx|
+      next if matches[idx] == equality
+      raise_is_kind_of_validation_error(equality, idx, classes)
+    end
     self
   end
 
@@ -380,8 +419,7 @@ class Valligator
 
     each(*methods) do |testee, idx, method|
       next if testee.respond_to?(method) == equality
-
-      error(ValidationError, idx)
+      raise_speaks_validation_error(equality, idx, method)
     end
     self
   end
@@ -396,15 +434,13 @@ class Valligator
 
     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 = testee.__send__(method, *args)
         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)
+      rescue => e
+        response = !equality
       end
-      error(ValidationError, idx) if !!response != equality
+      raise_asserts_validation_error(equality, idx, method, args, block, e) if !!response != equality
     end
     self
   end

data/lib/valligator_helper.rb

@@ -1,12 +1,26 @@
 class Valligator
   module Helper
 
+    # Returns a new Valligator instance
+    #
+    # @param [Array<Object>] testees  One or more objects to be tested
+    # @param option [Array<String>] :names  Testee names
+    # @return [Valligator]
+    #
     def valligate(*testees, names: nil)
       Valligator.new(*testees, names: names)
     end
+    alias_method :v, :valligate
 
 
-    alias_method :v, :valligate
+    # Returns a new Valligator instance created from a hash, where hash values are testees and hash keys are their names.
+    #
+    # @param [Hash] hash
+    # @return [Valligator]
+    #
+    def vh(hash)
+      Valligator.new(*hash.values, names: hash.keys)
+    end
 
   end
 end

data/test/lib/valligator/errors_test.rb

@@ -10,30 +10,96 @@ class TestErrors < Minitest::Test
   end
 
 
-  def test_without_testee_name
-    expected = "at `testee#1.speaks'"
-    err = assert_raises(error) { v(:foo).speaks(:foo) }
+  #-------------------------------------
+  # is_kind_of
+  #-------------------------------------
+
+
+  def test__is_kind_of__error__single
+    expected = "`testee#1': should not be Symbol"
+    err = assert_raises(error) { v(:foo).is_kind_of(String) }
+    assert_equal expected, err.message
+  end
+
+
+  def test__is_kind_of__error__multiple
+    expected = "`testee#1': should not be Symbol"
+    err = assert_raises(error) { v(:foo).is_kind_of(String, Hash, Array) }
+    assert_equal expected, err.message
+  end
+
+
+  def test__is_not_kind_of__error__single
+    expected = "`testee#1': should not be Symbol"
+    err = assert_raises(error) { v(:foo).is_not_kind_of(Symbol) }
     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) }
+  def test__is_not_kind_of__error__multiple
+    expected = "`testee#1': should not be Symbol"
+    err = assert_raises(error) { v(:foo).is_not_kind_of(Symbol, Hash, Array) }
     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
+  #-------------------------------------
+  # speaks
+  #-------------------------------------
+
+
+  def test__speaks__error
+    expected = "`testee#1': should respond to method `bar'"
+    err = assert_raises(error) { v(:foo).speaks(:bar) }
+    assert_equal expected, err.message
+  end
+
+
+  def test__does_not_speak__error
+    expected = "`testee#1': should not respond to method `to_s'"
+    err = assert_raises(error) { v(:foo).does_not_speak(:to_s) }
+    assert_equal expected, err.message
+  end
+
+
+  #-------------------------------------
+  # asserts
+  #-------------------------------------
+
+
+  def test__asserts__error__without_block
+    expected = "`testee#1': method `empty?' returned falsy value"
+    err = assert_raises(error) { v(:foo).asserts(:empty?) }
+    assert_equal expected, err.message
+  end
+
+  def test__asserts__error__with_block
+    expected = "`testee#1': method `size' returned falsy value"
+    err = assert_raises(error) { v(:foo).asserts(:size) { false } }
+    assert_equal expected, err.message
+  end
+
+  def test__asserts__error__with_block_and_exception
+    expected = "`testee#1': method `size' failed: ZeroDivisionError: divided by 0"
+    err = assert_raises(error) { v(:foo).asserts(:size) { 1/0 } }
+    assert_equal expected, err.message
+  end
+
+  def test__asserts_not__error__without_block
+    expected = "`testee#1': method `size' returned truthy value"
+    err = assert_raises(error) { v(:foo).asserts_not(:size) }
+    assert_equal expected, err.message
+  end
+
+  def test__asserts_not__error__with_block
+    expected = "`testee#1': method `empty?' returned truthy value"
+    err = assert_raises(error) { v(:foo).asserts_not(:empty?) { true } }
+    assert_equal expected, err.message
+  end
+
+  def test__assertsnot__error__with_block_and_exception
+    expected = "`testee#1': method `empty?' failed: ZeroDivisionError: divided by 0"
+    err = assert_raises(error) { v(:foo).asserts_not(:empty?) { 1/0 } }
     assert_equal expected, err.message
   end
 

data/test/lib/valligator/is_instance_of_test.rb

@@ -8,8 +8,8 @@ class TestIsInstanceOf < Minitest::Test
     Valligator::ValidationError
   end
 
-  positive_statements = [:is_instance_of, :is_a]
-  negative_statements = [:is_not_instance_of, :is_not_a]
+  positive_statements = [:is_kind_of, :is_a]
+  negative_statements = [:is_not_kind_of, :is_not_a]
   all_statements = positive_statements + negative_statements
 
   all_statements.each do |method|
@@ -21,8 +21,8 @@ class TestIsInstanceOf < Minitest::Test
 
 
     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) }
+      expected = "wrong argument type (arg#1 is a NilClass instead of Class) at `testee#1.%s'" % method
+      err = assert_raises(ArgumentError) { v(:a).send(method, nil) }
       assert_equal expected, err.message
     end
   end

data/test/lib/valligator/speaks_test.rb

@@ -17,8 +17,8 @@ class TestSpeaks < Minitest::Test
 
 
   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) }
+    expected = "wrong argument type (arg#1 is a NilClass instead of Symbol) at `testee#1.speaks'"
+    err = assert_raises(ArgumentError) { v(:a).speaks(nil) }
     assert_equal expected, err.message
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: valligator
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors:
 - Konstantin Dzreev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-18 00:00:00.000000000 Z
+date: 2017-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -51,7 +51,6 @@ files:
 - 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
@@ -59,7 +58,8 @@ files:
 - test/lib/valligator/speaks_test.rb
 - test/test_helper.rb
 homepage: https://github.com/konstantin-dzreev/valligator
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -67,9 +67,9 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - "~>"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/version.rb

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