contracts 0.14.0 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bb93546d34391727b5f9e866f193cddea67ac952
-  data.tar.gz: c214e45aba01fe36d90b3b74f670ccc3254c4b6b
+  metadata.gz: 5f95ed9c9dca3e23e9feb707360335388730304e
+  data.tar.gz: 634613562833a5f69e2171163eb71e64314ae252
 SHA512:
-  metadata.gz: 855e9377f9637943e20ebbf82b522bb915208523bfa3bc6bd23b939b613fe860354e9fabdc4d8d3ef3d61d0cbde7f2aa716c6274055d4d948ec998f92f8185e4
-  data.tar.gz: 20341d6090d35f0abc1bee62d9eccb618530d78a2e68a60bd67c22d85776a0a2dd7afaf9899088c77e03e84aa2b576804d52990ab614546a6a04eb0bf20b67bb
+  metadata.gz: 3e9393b9202596fbd5df5a53c1e4fd963ed9f5d881277f7705415fce911cba40c47ad0cf6ce993b1f94670fb8e5c7ab4ff9bcff9c20990826600969b686f7cce
+  data.tar.gz: 30bddf252a1e2da5a53223189bae378e834087ba3e1813c5acb8ad96bd62f75878d9bcf1afd4e861d87c63d1195af26ca1f9d89248b7089a54913090b52d1449

data/CHANGELOG.markdown

@@ -1,3 +1,7 @@
+## v0.15.0
+- Bugfix: Func contract's return value isn't enforced with blocks - [Piotr Szmielew](https://github.com/esse) [#251](https://github.com/egonSchiele/contracts.ruby/pull/251)
+- Bugfx: Fix contracts used in AR-models - [Gert Goet](https://github.com/eval) [#237](https://github.com/egonSchiele/contracts.ruby/pull/237)
+
 ## v0.14.0
 - Enhancement: Add StrictHash contract - [Fyodor](https://github.com/cbrwizard) [#236](https://github.com/egonSchiele/contracts.ruby/pull/236)
 - Bugfix: dont fail if something other than a hash is passed to a KeywordArgs - [Dan Padilha](https://github.com/dpad) [#234](https://github.com/egonSchiele/contracts.ruby/pull/234)

data/Gemfile

@@ -6,7 +6,7 @@ group :test do
   gem "rspec"
   gem "aruba"
   gem "cucumber", "~> 1.3.20"
-  gem "rubocop", "~> 0.29.1", :platform => [:ruby_20, :ruby_21, :ruby_22, :ruby_23]
+  gem "rubocop", "~> 0.29.1" if RUBY_VERSION >= "2"
 end
 
 group :development do

data/README.md

@@ -69,8 +69,12 @@ To get started do the following:
 
 2. Run our test suite
 
-  `bundle exec rake`
-
+  `bundle exec rspec`
+  
+3. Run our code style checks
+  
+  `bundle exec rubocop`
+  
 ## Performance
 
 Using contracts.ruby results in very little slowdown. Check out [this blog post](http://adit.io/posts/2013-03-04-How-I-Made-My-Ruby-Project-10x-Faster.html#seconds-6) for more info.

data/lib/contracts/builtin_contracts.rb

@@ -441,7 +441,7 @@ module Contracts
     end
 
     # Use this for specifying contracts for class arguments
-    # Example: <tt>Descendant[ e: Range, f: Optional[Num] ]</tt>
+    # Example: <tt>DescendantOf[ e: Range, f: Optional[Num] ]</tt>
     class DescendantOf < CallableClass
       def initialize(parent_class)
         @parent_class = parent_class

data/lib/contracts/call_with.rb

@@ -26,7 +26,9 @@ module Contracts
                                                   :return_value => false)
         end
 
-        if contract.is_a?(Contracts::Func)
+        if contract.is_a?(Contracts::Func) && blk && !nil_block_appended
+          blk = Contract.new(klass, arg, *contract.contracts)
+        elsif contract.is_a?(Contracts::Func)
           args[i] = Contract.new(klass, arg, *contract.contracts)
         end
       end
@@ -73,7 +75,8 @@ module Contracts
                  method.call(*args, &blk)
                else
                  # original method name referrence
-                 method.send_to(this, *args, &blk)
+                 added_block = blk ? lambda { |*params| blk.call(*params) } : nil
+                 method.send_to(this, *args, &added_block)
                end
 
       unless @ret_validator[result]

data/lib/contracts/decorators.rb

@@ -6,6 +6,7 @@ module Contracts
 
     def inherited(subclass)
       Engine.fetch_from(subclass).set_eigenclass_owner
+      super
     end
 
     def method_added(name)

data/lib/contracts/version.rb

@@ -1,3 +1,3 @@
 module Contracts
-  VERSION = "0.14.0"
+  VERSION = "0.15.0"
 end

data/spec/builtin_contracts_spec.rb

@@ -3,296 +3,304 @@ RSpec.describe "Contracts:" do
     @o = GenericExample.new
   end
 
+  def fails(&some)
+    expect { some.call }.to raise_error(ContractError)
+  end
+
+  def passes(&some)
+    expect { some.call }.to_not raise_error
+  end
+
   describe "DescendantOf:" do
     it "should pass for Array" do
-      expect { @o.enumerable_descendant_test(Array) }.to_not raise_error
+      passes { @o.enumerable_descendant_test(Array) }
     end
 
     it "should pass for a hash" do
-      expect { @o.enumerable_descendant_test(Hash) }.to_not raise_error
+      passes { @o.enumerable_descendant_test(Hash) }
     end
 
     it "should fail for a number class" do
-      expect { @o.enumerable_descendant_test(Integer) }.to raise_error(ContractError)
+      fails { @o.enumerable_descendant_test(Integer) }
     end
 
     it "should fail for a non-class" do
-      expect { @o.enumerable_descendant_test(1) }.to raise_error(ContractError)
+      fails { @o.enumerable_descendant_test(1) }
     end
   end
 
   describe "Num:" do
     it "should pass for Fixnums" do
-      expect { @o.double(2) }.to_not raise_error
+      passes { @o.double(2) }
     end
 
     it "should pass for Floats" do
-      expect { @o.double(2.2) }.to_not raise_error
+      passes { @o.double(2.2) }
     end
 
     it "should fail for nil and other data types" do
-      expect { @o.double(nil) }.to raise_error(ContractError)
-      expect { @o.double(:x)  }.to raise_error(ContractError)
-      expect { @o.double("x") }.to raise_error(ContractError)
-      expect { @o.double(/x/) }.to raise_error(ContractError)
+      fails { @o.double(nil) }
+      fails { @o.double(:x) }
+      fails { @o.double("x") }
+      fails { @o.double(/x/) }
     end
   end
 
   describe "Pos:" do
     it "should pass for positive numbers" do
-      expect { @o.pos_test(1) }.to_not raise_error
-      expect { @o.pos_test(1.6) }.to_not raise_error
+      passes { @o.pos_test(1) }
+      passes { @o.pos_test(1.6) }
     end
 
     it "should fail for 0" do
-      expect { @o.pos_test(0) }.to raise_error(ContractError)
+      fails { @o.pos_test(0) }
     end
 
     it "should fail for negative numbers" do
-      expect { @o.pos_test(-1) }.to raise_error(ContractError)
-      expect { @o.pos_test(-1.6) }.to raise_error(ContractError)
+      fails { @o.pos_test(-1) }
+      fails { @o.pos_test(-1.6) }
     end
 
     it "should fail for nil and other data types" do
-      expect { @o.pos_test(nil) }.to raise_error(ContractError)
-      expect { @o.pos_test(:x)  }.to raise_error(ContractError)
-      expect { @o.pos_test("x") }.to raise_error(ContractError)
-      expect { @o.pos_test(/x/) }.to raise_error(ContractError)
+      fails { @o.pos_test(nil) }
+      fails { @o.pos_test(:x)  }
+      fails { @o.pos_test("x") }
+      fails { @o.pos_test(/x/) }
     end
   end
 
   describe "Neg:" do
     it "should pass for negative numbers" do
-      expect { @o.neg_test(-1) }.to_not raise_error
-      expect { @o.neg_test(-1.6) }.to_not raise_error
+      passes { @o.neg_test(-1) }
+      passes { @o.neg_test(-1.6) }
     end
 
     it "should fail for 0" do
-      expect { @o.neg_test(0) }.to raise_error(ContractError)
+      fails { @o.neg_test(0) }
     end
 
     it "should fail for positive numbers" do
-      expect { @o.neg_test(1) }.to raise_error(ContractError)
-      expect { @o.neg_test(1.6) }.to raise_error(ContractError)
+      fails { @o.neg_test(1) }
+      fails { @o.neg_test(1.6) }
     end
 
     it "should fail for nil and other data types" do
-      expect { @o.neg_test(nil) }.to raise_error(ContractError)
-      expect { @o.neg_test(:x)  }.to raise_error(ContractError)
-      expect { @o.neg_test("x") }.to raise_error(ContractError)
-      expect { @o.neg_test(/x/) }.to raise_error(ContractError)
+      fails { @o.neg_test(nil) }
+      fails { @o.neg_test(:x)  }
+      fails { @o.neg_test("x") }
+      fails { @o.neg_test(/x/) }
     end
   end
 
   describe "Nat:" do
     it "should pass for 0" do
-      expect { @o.nat_test(0) }.to_not raise_error
+      passes { @o.nat_test(0) }
     end
 
     it "should pass for positive whole numbers" do
-      expect { @o.nat_test(1) }.to_not raise_error
+      passes { @o.nat_test(1) }
     end
 
     it "should fail for positive non-whole numbers" do
-      expect { @o.nat_test(1.5) }.to raise_error(ContractError)
+      fails { @o.nat_test(1.5) }
     end
 
     it "should fail for negative numbers" do
-      expect { @o.nat_test(-1) }.to raise_error(ContractError)
-      expect { @o.nat_test(-1.6) }.to raise_error(ContractError)
+      fails { @o.nat_test(-1) }
+      fails { @o.nat_test(-1.6) }
     end
 
     it "should fail for nil and other data types" do
-      expect { @o.nat_test(nil) }.to raise_error(ContractError)
-      expect { @o.nat_test(:x)  }.to raise_error(ContractError)
-      expect { @o.nat_test("x") }.to raise_error(ContractError)
-      expect { @o.nat_test(/x/) }.to raise_error(ContractError)
+      fails { @o.nat_test(nil) }
+      fails { @o.nat_test(:x)  }
+      fails { @o.nat_test("x") }
+      fails { @o.nat_test(/x/) }
     end
   end
 
   describe "Any:" do
     it "should pass for numbers" do
-      expect { @o.show(1) }.to_not raise_error
+      passes { @o.show(1) }
     end
     it "should pass for strings" do
-      expect { @o.show("bad") }.to_not raise_error
+      passes { @o.show("bad") }
     end
     it "should pass for procs" do
-      expect { @o.show(lambda {}) }.to_not raise_error
+      passes { @o.show(lambda {}) }
     end
     it "should pass for nil" do
-      expect { @o.show(nil) }.to_not raise_error
+      passes { @o.show(nil) }
     end
   end
 
   describe "None:" do
     it "should fail for numbers" do
-      expect { @o.fail_all(1) }.to raise_error(ContractError)
+      fails { @o.fail_all(1) }
     end
     it "should fail for strings" do
-      expect { @o.fail_all("bad") }.to raise_error(ContractError)
+      fails { @o.fail_all("bad") }
     end
     it "should fail for procs" do
-      expect { @o.fail_all(lambda {}) }.to raise_error(ContractError)
+      fails { @o.fail_all(lambda {}) }
     end
     it "should fail for nil" do
-      expect { @o.fail_all(nil) }.to raise_error(ContractError)
+      fails { @o.fail_all(nil) }
     end
   end
 
   describe "Or:" do
     it "should pass for nums" do
-      expect { @o.num_or_string(1) }.to_not raise_error
+      passes { @o.num_or_string(1) }
     end
 
     it "should pass for strings" do
-      expect { @o.num_or_string("bad") }.to_not raise_error
+      passes { @o.num_or_string("bad") }
     end
 
     it "should fail for nil" do
-      expect { @o.num_or_string(nil) }.to raise_error(ContractError)
+      fails { @o.num_or_string(nil) }
     end
   end
 
   describe "Xor:" do
     it "should pass for an object with a method :good" do
-      expect { @o.xor_test(A.new) }.to_not raise_error
+      passes { @o.xor_test(A.new) }
     end
 
     it "should pass for an object with a method :bad" do
-      expect { @o.xor_test(B.new) }.to_not raise_error
+      passes { @o.xor_test(B.new) }
     end
 
     it "should fail for an object with neither method" do
-      expect { @o.xor_test(1) }.to raise_error(ContractError)
+      fails { @o.xor_test(1) }
     end
 
     it "should fail for an object with both methods :good and :bad" do
-      expect { @o.xor_test(F.new) }.to raise_error(ContractError)
+      fails { @o.xor_test(F.new) }
     end
   end
 
   describe "And:" do
     it "should pass for an object of class A that has a method :good" do
-      expect { @o.and_test(A.new) }.to_not raise_error
+      passes { @o.and_test(A.new) }
     end
 
     it "should fail for an object that has a method :good but isn't of class A" do
-      expect { @o.and_test(F.new) }.to raise_error(ContractError)
+      fails { @o.and_test(F.new) }
     end
   end
 
   describe "Enum:" do
     it "should pass for an object that is included" do
-      expect { @o.enum_test(:a) }.to_not raise_error
+      passes { @o.enum_test(:a) }
     end
 
     it "should fail for an object that is not included" do
-      expect { @o.enum_test(:z) }.to raise_error(ContractError)
+      fails { @o.enum_test(:z) }
     end
   end
 
   describe "RespondTo:" do
     it "should pass for an object that responds to :good" do
-      expect { @o.responds_test(A.new) }.to_not raise_error
+      passes { @o.responds_test(A.new) }
     end
 
     it "should fail for an object that doesn't respond to :good" do
-      expect { @o.responds_test(B.new) }.to raise_error(ContractError)
+      fails { @o.responds_test(B.new) }
     end
   end
 
   describe "Send:" do
     it "should pass for an object that returns true for method :good" do
-      expect { @o.send_test(A.new) }.to_not raise_error
+      passes { @o.send_test(A.new) }
     end
 
     it "should fail for an object that returns false for method :good" do
-      expect { @o.send_test(F.new) }.to raise_error(ContractError)
+      fails { @o.send_test(F.new) }
     end
   end
 
   describe "Exactly:" do
     it "should pass for an object that is exactly a Parent" do
-      expect { @o.exactly_test(Parent.new) }.to_not raise_error
+      passes { @o.exactly_test(Parent.new) }
     end
 
     it "should fail for an object that inherits from Parent" do
-      expect { @o.exactly_test(Child.new) }.to raise_error(ContractError)
+      fails { @o.exactly_test(Child.new) }
     end
 
     it "should fail for an object that is not related to Parent at all" do
-      expect { @o.exactly_test(A.new) }.to raise_error(ContractError)
+      fails { @o.exactly_test(A.new) }
     end
   end
 
   describe "Eq:" do
     it "should pass for a class" do
-      expect { @o.eq_class_test(Foo) }
+      passes { @o.eq_class_test(Foo) }
     end
 
     it "should pass for a module" do
-      expect { @o.eq_module_test(Bar) }
+      passes { @o.eq_module_test(Bar) }
     end
 
     it "should pass for other values" do
-      expect { @o.eq_value_test(Baz) }
+      passes { @o.eq_value_test(Baz) }
     end
 
     it "should fail when not equal" do
-      expect { @o.eq_class_test(Bar) }.to raise_error(ContractError)
+      fails { @o.eq_class_test(Bar) }
     end
 
     it "should fail when given instance of class" do
-      expect { @o.eq_class_test(Foo.new) }.to raise_error(ContractError)
+      fails { @o.eq_class_test(Foo.new) }
     end
   end
 
   describe "Not:" do
     it "should pass for an argument that isn't nil" do
-      expect { @o.not_nil(1) }.to_not raise_error
+      passes { @o.not_nil(1) }
     end
 
     it "should fail for nil" do
-      expect { @o.not_nil(nil) }.to raise_error(ContractError)
+      fails { @o.not_nil(nil) }
     end
   end
 
   describe "ArrayOf:" do
     it "should pass for an array of nums" do
-      expect { @o.product([1, 2, 3]) }.to_not raise_error
+      passes { @o.product([1, 2, 3]) }
     end
 
     it "should fail for an array with one non-num" do
-      expect { @o.product([1, 2, 3, "bad"]) }.to raise_error(ContractError)
+      fails { @o.product([1, 2, 3, "bad"]) }
     end
 
     it "should fail for a non-array" do
-      expect { @o.product(1) }.to raise_error(ContractError)
+      fails { @o.product(1) }
     end
   end
 
   describe "RangeOf:" do
     require "date"
     it "should pass for a range of nums" do
-      expect { @o.first_in_range_num(3..10) }.to_not raise_error
+      passes { @o.first_in_range_num(3..10) }
     end
 
     it "should pass for a range of dates" do
       d1 = Date.today
       d2 = d1 + 18
-      expect { @o.first_in_range_date(d1..d2) }.to_not raise_error
+      passes { @o.first_in_range_date(d1..d2) }
     end
 
     it "should fail for a non-range" do
-      expect { @o.first_in_range_num("foo") }.to raise_error(ContractError)
-      expect { @o.first_in_range_num(:foo) }.to raise_error(ContractError)
-      expect { @o.first_in_range_num(5) }.to raise_error(ContractError)
-      expect { @o.first_in_range_num(nil) }.to raise_error(ContractError)
+      fails { @o.first_in_range_num("foo") }
+      fails { @o.first_in_range_num(:foo) }
+      fails { @o.first_in_range_num(5) }
+      fails { @o.first_in_range_num(nil) }
     end
 
     it "should fail for a range with incorrect data type" do
-      expect { @o.first_in_range_num("a".."z") }.to raise_error(ContractError)
+      fails { @o.first_in_range_num("a".."z") }
     end
 
     it "should fail for a badly-defined range" do
@@ -302,8 +310,8 @@ RSpec.describe "Contracts:" do
       # This test guards against ranges with inconsistent data types.
       begin
         d1 = Date.today
-        expect { @o.first_in_range_date(d1..10).to raise_error(ContractError) }
-        expect { @o.first_in_range_num(d1..10).to raise_error(ContractError) }
+        fails { @o.first_in_range_date(d1..10) }
+        fails { @o.first_in_range_num(d1..10) }
       rescue ArgumentError
         # If Ruby doesn't like the range, we ignore the test.
         :nop
@@ -313,26 +321,26 @@ RSpec.describe "Contracts:" do
 
   describe "SetOf:" do
     it "should pass for a set of nums" do
-      expect { @o.product_from_set(Set.new([1, 2, 3])) }.to_not raise_error
+      passes { @o.product_from_set(Set.new([1, 2, 3])) }
     end
 
     it "should fail for an array with one non-num" do
-      expect { @o.product_from_set(Set.new([1, 2, 3, "bad"])) }.to raise_error(ContractError)
+      fails { @o.product_from_set(Set.new([1, 2, 3, "bad"])) }
     end
 
     it "should fail for a non-array" do
-      expect { @o.product_from_set(1) }.to raise_error(ContractError)
+      fails { @o.product_from_set(1) }
     end
   end
 
   describe "Bool:" do
     it "should pass for an argument that is a boolean" do
-      expect { @o.bool_test(true) }.to_not raise_error
-      expect { @o.bool_test(false) }.to_not raise_error
+      passes { @o.bool_test(true) }
+      passes { @o.bool_test(false) }
     end
 
     it "should fail for nil" do
-      expect { @o.bool_test(nil) }.to raise_error(ContractError)
+      fails { @o.bool_test(nil) }
     end
   end
 
@@ -346,31 +354,31 @@ RSpec.describe "Contracts:" do
     end
 
     it "should fail for strings" do
-      expect { @o.maybe_double("foo") }.to raise_error(ContractError)
+      fails { @o.maybe_double("foo") }
     end
   end
 
   describe "KeywordArgs:" do
     it "should pass for exact correct input" do
-      expect { @o.person_keywordargs(:name => "calvin", :age => 10) }.to_not raise_error
+      passes { @o.person_keywordargs(:name => "calvin", :age => 10) }
     end
 
     it "should fail if some keys don't have contracts" do
-      expect { @o.person_keywordargs(:name => "calvin", :age => 10, :foo => "bar") }.to raise_error(ContractError)
+      fails { @o.person_keywordargs(:name => "calvin", :age => 10, :foo => "bar") }
     end
 
     it "should fail if a key with a contract on it isn't provided" do
-      expect { @o.person_keywordargs(:name => "calvin") }.to raise_error(ContractError)
+      fails { @o.person_keywordargs(:name => "calvin") }
     end
 
     it "should fail for incorrect input" do
-      expect { @o.person_keywordargs(:name => 50, :age => 10) }.to raise_error(ContractError)
-      expect { @o.hash_keywordargs(:hash => nil) }.to raise_error(ContractError)
-      expect { @o.hash_keywordargs(:hash => 1) }.to raise_error(ContractError)
+      fails { @o.person_keywordargs(:name => 50, :age => 10) }
+      fails { @o.hash_keywordargs(:hash => nil) }
+      fails { @o.hash_keywordargs(:hash => 1) }
     end
 
     it "should pass if a method is overloaded with non-KeywordArgs" do
-      expect { @o.person_keywordargs("name", 10) }.to_not raise_error
+      passes { @o.person_keywordargs("name", 10) }
     end
   end
 
@@ -402,10 +410,10 @@ RSpec.describe "Contracts:" do
     end
 
     context "given an unfulfilled contract" do
-      it { expect { @o.gives_max_value(:panda => "1", :bamboo => "2") }.to raise_error(ContractError) }
-      it { expect { @o.gives_max_value(nil) }.to raise_error(ContractError) }
-      it { expect { @o.gives_max_value(1) }.to raise_error(ContractError) }
-      it { expect { @o.pretty_gives_max_value(:panda => "1", :bamboo => "2") }.to raise_error(ContractError) }
+      it { fails { @o.gives_max_value(:panda => "1", :bamboo => "2") }  }
+      it { fails { @o.gives_max_value(nil) } }
+      it { fails { @o.gives_max_value(1) } }
+      it { fails { @o.pretty_gives_max_value(:panda => "1", :bamboo => "2") } }
     end
 
     describe "#to_s" do
@@ -422,39 +430,31 @@ RSpec.describe "Contracts:" do
   describe "StrictHash:" do
     context "when given an exact correct input" do
       it "does not raise an error" do
-        expect do
-          @o.strict_person(:name => "calvin", :age => 10)
-        end.to_not raise_error
+        passes { @o.strict_person(:name => "calvin", :age => 10) }
       end
     end
 
     context "when given an input with correct keys but wrong types" do
       it "raises an error" do
-        expect do
-          @o.strict_person(:name => "calvin", :age => "10")
-        end.to raise_error(ContractError)
+        fails { @o.strict_person(:name => "calvin", :age => "10") }
       end
     end
 
     context "when given an input with missing keys" do
       it "raises an error" do
-        expect do
-          @o.strict_person(:name => "calvin")
-        end.to raise_error(ContractError)
+        fails { @o.strict_person(:name => "calvin") }
       end
     end
 
     context "when given an input with extra keys" do
       it "raises an error" do
-        expect do
-          @o.strict_person(:name => "calvin", :age => "10", :soft => true)
-        end.to raise_error(ContractError)
+        fails { @o.strict_person(:name => "calvin", :age => "10", :soft => true) }
       end
     end
 
     context "when given not a hash" do
       it "raises an error" do
-        expect { @o.strict_person(1337) }.to raise_error(ContractError)
+        fails { @o.strict_person(1337) }
       end
     end
   end

data/spec/methods_spec.rb

@@ -0,0 +1,54 @@
+RSpec.describe "Contracts:" do
+  describe "method called with blocks" do
+    module FuncTest
+      include Contracts::Core
+      include Contracts::Builtin
+
+      Contract Func[Num=>Num] => nil
+      def foo(&blk)
+        _ = blk.call(2)
+        nil
+      end
+
+      Contract Num, Func[Num=>Num] => nil
+      def foo2(a, &blk)
+        _ = blk.call(2)
+        nil
+      end
+
+      Contract Func[Num=>Num] => nil
+      def bar(blk)
+        _ = blk.call(2)
+        nil
+      end
+
+      Contract Num, Func[Num=>Num] => nil
+      def bar2(a, blk)
+        _ = blk.call(2)
+        nil
+      end
+    end
+
+    def obj
+      Object.new.tap do |o|
+        o.extend(FuncTest)
+      end
+    end
+
+    it "should enforce return value inside block with no other parameter" do
+      expect { obj.foo(&:to_s) }.to raise_error
+    end
+
+    it "should enforce return value inside block with other parameter" do
+      expect { obj.foo2(2) { |x| x.to_s } }.to raise_error
+    end
+
+    it "should enforce return value inside lambda with no other parameter" do
+      expect { obj.bar lambda { |x| x.to_s } }.to raise_error
+    end
+
+    it "should enforce return value inside lambda with other parameter" do
+      expect { obj.bar2(2, lambda { |x| x.to_s }) }.to raise_error
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: contracts
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.15.0
 platform: ruby
 authors:
 - Aditya Bhargava
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-26 00:00:00.000000000 Z
+date: 2017-02-24 00:00:00.000000000 Z
 dependencies: []
 description: This library provides contracts for Ruby. Contracts let you clearly express
   how your code behaves, and free you from writing tons of boilerplate, defensive
@@ -92,6 +92,7 @@ files:
 - spec/contracts_spec.rb
 - spec/fixtures/fixtures.rb
 - spec/invariants_spec.rb
+- spec/methods_spec.rb
 - spec/module_spec.rb
 - spec/override_validators_spec.rb
 - spec/ruby_version_specific/contracts_spec_1.9.rb
@@ -121,7 +122,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Contracts for Ruby.