contracts 0.9 → 0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c872d0fc055f6b1ace99f6793c436ee222111992
-  data.tar.gz: 0bc9d2a28a4dd77395932974fe46e9175818fa73
+  metadata.gz: bb8713bcd0175e6069a34ede6834e012395e11a4
+  data.tar.gz: 185ac772d51ee7a5fb80c3c4058155aae7094e08
 SHA512:
-  metadata.gz: 2c2eb482b3c7b2e697ff29076734fa9ec74dc93b9f8344514fdfab3a999a1b40dff0d57bbf487dcd82eaf51b7b503c55cc55a6573745b36314f09f3ce2f5778c
-  data.tar.gz: 3535f6d2ceea6e1382b9810679fcb619b94ed9788434022b597f120165a534383c306e6d5ce305ac0808a1b0d34dd0f1b1ca1ec53e3e61f3481a860197e8be5a
+  metadata.gz: bd78da1e9ed5f3af971fdabab93faa1924c9b74619b36298852ddbfb3b525f161678cd34d2d9a619aff0c958bf3da3694afcee05b0d1bf76b07bd9a69400561a
+  data.tar.gz: 6295dd08adbc49c431b8e2cc234f500592c035c1b9547c6c7fe6ab63b0b91420b323b8d57385d9685aee1510645b881bdd1b575637efa848f3e2175f4ccfca03

data/CHANGELOG.markdown

@@ -2,14 +2,17 @@
 - MAJOR fix in pattern-matching: If the return contract for a pattern-matched function fails, it should NOT try the next pattern-match function. Pattern-matching is only for params, not return values.
 - raise an error if multiple defns have the same contract for pattern matching.
 
-- New syntax for functions with no input params.
+- New syntax for functions with no input params (the old style still works)  
   Old way:
+  ```ruby
   Contract nil => 1
   def one
-
+  ```
   New way:
+  ```
   Contract 1
   def one
+  ```
 
 - Prettier HashOf contract can now be written like this: `HashOf[Num => String]`
 - Add `SetOf` contract

data/TUTORIAL.md

@@ -67,24 +67,40 @@ This can be useful if you're in a REPL and want to figure out how a function sho
 
 contracts.ruby comes with a lot of built-in contracts, including the following:
 
-* [`Num`](http://www.rubydoc.info/gems/contracts/Contracts/Num) – checks that the argument is `Numeric`
-* [`Pos`](http://www.rubydoc.info/gems/contracts/Contracts/Pos) – checks that the argument is a positive number
-* [`Neg`](http://www.rubydoc.info/gems/contracts/Contracts/Neg) – checks that the argument is a negative number
-* [`Nat`](http://www.rubydoc.info/gems/contracts/Contracts/Nat) – checks that the argument is a natural number
-* [`Bool`](http://www.rubydoc.info/gems/contracts/Contracts/Bool) – checks that the argument is `true` or `false`
-* [`Any`](http://www.rubydoc.info/gems/contracts/Contracts/Any) – Passes for any argument. Use when the argument has no constraints.
-* [`None`](http://www.rubydoc.info/gems/contracts/Contracts/None) – Fails for any argument. Use when the method takes no arguments.
-* [`Or`](http://www.rubydoc.info/gems/contracts/Contracts/Or) – passes if any of the given contracts pass, e.g. `Or[Fixnum, Float]`
-* [`Xor`](http://www.rubydoc.info/gems/contracts/Contracts/Xor) – passes if exactly one of the given contracts pass, e.g. `Xor[Fixnum, Float]`
-* [`And`](http://www.rubydoc.info/gems/contracts/Contracts/And) – passes if all contracts pass, e.g. `And[Fixnum, Float]`
-* [`Not`](http://www.rubydoc.info/gems/contracts/Contracts/Not) – passes if all contracts fail for the given argument, e.g. `Not[nil]`
-* [`ArrayOf`](http://www.rubydoc.info/gems/contracts/Contracts/ArrayOf) – checks that the argument is an array, and all elements pass the given contract, e.g. `ArrayOf[Num]`
-* [`SetOf`](http://www.rubydoc.info/gems/contracts/Contracts/SetOf) – checks that the argument is a set, and all elements pass the given contract, e.g. `SetOf[Num]`
-* [`HashOf`](http://www.rubydoc.info/gems/contracts/Contracts/HashOf) – checks that the argument is a hash, and all keys and values pass the given contract, e.g. `HashOf[Symbol => String]`
-* [`Maybe`](http://www.rubydoc.info/gems/contracts/Contracts/Maybe) – passes if the argument is `nil`, or if the given contract passes
-* [`RespondTo`](http://www.rubydoc.info/gems/contracts/Contracts/RespondTo) – checks that the argument responds to all of the given methods, e.g. `RespondTo[:password, :credit_card]`
-* [`Send`](http://www.rubydoc.info/gems/contracts/Contracts/Send) – checks that all named methods return true, e.g. `Send[:valid?]`
-* [`Exactly`](http://www.rubydoc.info/gems/contracts/Contracts/Exactly) – checks that the argument has the given type, not accepting sub-classes, e.g. `Exactly[Numeric]`.
+* Basic types
+  * [`Num`](http://www.rubydoc.info/gems/contracts/Contracts/Num) – checks that the argument is `Numeric`
+  * [`Pos`](http://www.rubydoc.info/gems/contracts/Contracts/Pos) – checks that the argument is a positive number
+  * [`Neg`](http://www.rubydoc.info/gems/contracts/Contracts/Neg) – checks that the argument is a negative number
+  * [`Nat`](http://www.rubydoc.info/gems/contracts/Contracts/Nat) – checks that the argument is a natural number (>= 0)
+  * [`Bool`](http://www.rubydoc.info/gems/contracts/Contracts/Bool) – checks that the argument is `true` or `false`
+  * [`Any`](http://www.rubydoc.info/gems/contracts/Contracts/Any) – Passes for any argument. Use when the argument has no constraints.
+  * [`None`](http://www.rubydoc.info/gems/contracts/Contracts/None) – Fails for any argument. Use when the method takes no arguments.
+
+* Logical combinations
+  * [`Maybe`](http://www.rubydoc.info/gems/contracts/Contracts/Maybe) – specifies that a value _may be_ nil, e.g. `Maybe[String]` (equivalent to `Or[String,nil]`)
+  * [`Or`](http://www.rubydoc.info/gems/contracts/Contracts/Or) – passes if any of the given contracts pass, e.g. `Or[Fixnum, Float]`
+  * [`Xor`](http://www.rubydoc.info/gems/contracts/Contracts/Xor) – passes if exactly one of the given contracts pass, e.g. `Xor[Fixnum, Float]`
+  * [`And`](http://www.rubydoc.info/gems/contracts/Contracts/And) – passes if all contracts pass, e.g. `And[Nat, -> (n) { n.even? }]`
+  * [`Not`](http://www.rubydoc.info/gems/contracts/Contracts/Not) – passes if all contracts fail for the given argument, e.g. `Not[nil]`
+
+* Collections
+  * [`ArrayOf`](http://www.rubydoc.info/gems/contracts/Contracts/ArrayOf) – checks that the argument is an array, and all elements pass the given contract, e.g. `ArrayOf[Num]`
+  * [`SetOf`](http://www.rubydoc.info/gems/contracts/Contracts/SetOf) – checks that the argument is a set, and all elements pass the given contract, e.g. `SetOf[Num]`
+  * [`HashOf`](http://www.rubydoc.info/gems/contracts/Contracts/HashOf) – checks that the argument is a hash, and all keys and values pass the given contract, e.g. `HashOf[Symbol => String]` or `HashOf[Symbol,String]`
+  * [`RangeOf`](http://www.rubydoc.info/gems/contracts/Contracts/RangeOf) – checks that the argument is a range whose elements (#first and #last) pass the given contract, e.g. `RangeOf[Date]`
+
+* Keyword arguments
+  * [`KeywordArgs`](http://www.rubydoc.info/gems/contracts/Contracts/KeywordArgs) – checks that the argument is an options hash, and all required keyword arguments are present, and all values pass their respective contracts, e.g. `KeywordArgs[:number => Num, :description => Optional[String]]`
+  * [`Optional`](http://www.rubydoc.info/gems/contracts/Contracts/Optional) – checks that the keyword argument is either not present or pass the given contract, can not be used outside of `KeywordArgs` contract, e.g. `Optional[Num]`
+
+* Duck typing
+  * [`RespondTo`](http://www.rubydoc.info/gems/contracts/Contracts/RespondTo) – checks that the argument responds to all of the given methods, e.g. `RespondTo[:password, :credit_card]`
+  * [`Send`](http://www.rubydoc.info/gems/contracts/Contracts/Send) – checks that all named methods return a truthy value, e.g. `Send[:valid?]`
+
+* Miscellaneous
+  * [`Exactly`](http://www.rubydoc.info/gems/contracts/Contracts/Exactly) – checks that the argument has the given type, not accepting sub-classes, e.g. `Exactly[Numeric]`.
+  * [`Eq`](http://www.rubydoc.info/gems/contracts/Contracts/Eq) – checks that the argument is precisely equal to the given value, e.g. `Eq[String]` matches the class `String` and not a string instance.
+  * [`Func`](http://www.rubydoc.info/gems/contracts/Contracts/Func) – specifies the contract for a proc/lambda e.g. `Contract ArrayOf[Num], Func[Num => Num] => ArrayOf[Num]`. See section "Contracts On Functions".
 
 To see all the built-in contracts and their full descriptions, check out the [RDoc](http://rubydoc.info/gems/contracts/Contracts).
 
@@ -239,6 +255,59 @@ give_largest_value(a: 1, b: 2, c: 3) # returns 3
 give_largest_value("a" => 1, 2 => 2, c: 3)
 ```
 
+### Contracts On Keyword Arguments
+
+ruby 2.0+, but can be used for normal hashes too, when keyword arguments are
+not available
+
+Lets say you are writing a simple function and require a bunch of keyword arguments:
+
+```ruby
+def connect(host, port:, user:, password:)
+```
+
+You can of course put `Hash` contract on it:
+
+```ruby
+Contract String, { :port => Num, :user => String, :password => String } => Connection
+def connect(host, port:, user:, password:)
+```
+
+But this will not quite work if you want to have a default values:
+
+```ruby
+Contract String, { :port => Num, :user => String, :password => String } => Connection
+def connect(host, port: 5000, user:, password:)
+  # ...
+end
+
+# No value is passed for port
+connect("example.org", user: "me", password: "none")
+```
+
+Results in:
+
+```
+ContractError: Contract violation for argument 2 of 2:
+        Expected: {:port=>Num, :user=>String, :password=>String},
+        Actual: {:user=>"me", :password=>"none"}
+        Value guarded in: Object::connect
+        With Contract: String, Hash => Connection
+        At: (irb):12
+```
+
+This can be fixed with contract `{ :port => Maybe[Num], ... }`, but that will
+allow `nil` to be passed in, which is not the original intent.
+
+So that is where `KeywordArgs` and `Optional` contracts jump in:
+
+```ruby
+Contract String, KeywordArgs[ :port => Optional[Num], :user => String, :password => String ] => Connection
+def connect(host, port: 5000, user:, password:)
+```
+
+It looks just like the hash contract, but wrapped in `KeywordArgs` contract. Notice the usage of `Optional` contract - this way you specify that `:port` argument is optional. And it will not fail, when you omit this argument, but it will fail when you pass in `nil`.
+
 ### Contracts On Functions
 
 Lets say you are writing a simple map function:
@@ -260,7 +329,7 @@ This says that the second argument should be a `Proc`. You can call the function
 p map([1, 2, 3], lambda { |x| x + 1 }) # works
 ```
 
-But suppose you want to have a contract on the Proc too! Suppose you want to make sure that the Proc returns a number. Use the `Func` contract. `Func` takes a contract as it's argument, and uses that contract on the function that you pass in.
+But suppose you want to have a contract on the Proc too! Suppose you want to make sure that the Proc returns a number. Use the `Func` contract. `Func` takes a contract as its argument, and uses that contract on the function that you pass in.
 
 Here's a `map` function that requires an array of numbers, and a function that takes a number and returns a number:
 
@@ -284,6 +353,12 @@ p map([1, 2, 3], lambda { |x| x + 1 }) # works
 p map([1, 2, 3], lambda { |x| "oops" }) # fails, the lambda returns a string.
 ```
 
+The above examples showed a method accepting a `Proc` as the last argument, but the same contract works on methods that accept a block:
+
+```ruby
+def map(arr, &block)
+```
+
 NOTE: This is not valid:
 
 ```ruby
@@ -448,6 +523,36 @@ end
 
 If your failure callback returns `false`, the method that the contract is guarding will not be called (the default behaviour).
 
+## Providing your own custom validators
+
+This can be done with `Contract.override_validator`:
+
+```ruby
+# Make contracts accept all RSpec doubles
+Contract.override_validator(:class) do |contract|
+  lambda do |arg|
+    arg.is_a?(RSpec::Mocks::Double) ||
+      arg.is_a?(contract)
+  end
+end
+```
+
+The block you provide should always return lambda accepting one argument - validated argument. Block itself accepts contract as an argument.
+
+Possible validator overrides:
+
+- `override_validator(MyCustomContract)` - allows to add some special behaviour for custom contracts,
+- `override_validator(Proc)` - e.g. `lambda { true }`,
+- `override_validator(Array)` - e.g. `[Num, String]`,
+- `override_validator(Hash)` - e.g. `{ :a => Num, :b => String }`,
+- `override_validator(Contracts::Args)` - e.g. `Args[Num]`,
+- `override_validator(Contracts::Func)` - e.g. `Func[Num => Num]`,
+- `override_validator(:valid)` - allows to override how contracts that respond to `:valid?` are handled,
+- `override_validator(:class)` - allows to override how class/module contract constants are handled,
+- `override_validator(:default)` - otherwise, raw value contracts.
+
+Default validators can be found here: [lib/contracts/validators.rb](https://github.com/egonSchiele/contracts.ruby/blob/master/lib/contracts/validators.rb).
+
 ## Disabling contracts
 
 If you want to disable contracts, set the `NO_CONTRACTS` environment variable. This will disable contracts and you won't have a performance hit. Pattern matching will still work if you disable contracts in this way! With NO_CONTRACTS only pattern-matching contracts are defined.
@@ -510,12 +615,11 @@ This is because the first contract eliminated the possibility of `age` being les
 
 ## Contracts in modules
 
-To use contracts on module you need to include both `Contracts` and `Contracts::Modules` into it:
+Usage is the same as contracts in classes:
 
 ```ruby
 module M
   include Contracts
-  include Contracts::Modules
 
   Contract String => String
   def self.parse
@@ -562,6 +666,17 @@ If you run it, last line will generate invariant violation:
 
 Which means, that after `#silly_next_day!` all checks specified in `invariant` statement will be verified, and if at least one fail, then invariant violation error will be raised.
 
+## Using contracts within your own code
+
+contracts.ruby is obviously designed to check method parameters and return values. But if you want to check whether some other data obeys a contract, you can use `Contract.valid?(value, contract)`. For instance:
+
+```ruby
+data = parse(user_input)
+unless Contract.valid?(data, HashOf[String,Nat])
+  raise UserInputError.new(user_input)
+end
+```
+
 ## Auto-generate documentation using contracts
 
 If you are generating documentation for your code with [YARD](http://yardoc.org/), check out [yard-contracts](https://github.com/sfcgeorge/yard-contracts). It will automatically annotate your functions with contracts information. Instead of documenting each parameter for a function yourself, you can just add a contract and yard-contracts will generate the documentation for you!

data/benchmarks/hash.rb

@@ -0,0 +1,69 @@
+require "./lib/contracts"
+require "benchmark"
+require "rubygems"
+require "method_profiler"
+require "ruby-prof"
+
+include Contracts
+
+def add opts
+  opts[:a] + opts[:b]
+end
+
+Contract ({ :a => Num, :b => Num}) => Num
+def contracts_add opts
+  opts[:a] + opts[:b]
+end
+
+def explicit_add opts
+  a = opts[:a]
+  b = opts[:b]
+  fail unless a.is_a?(Numeric)
+  fail unless b.is_a?(Numeric)
+  c = a + b
+  fail unless c.is_a?(Numeric)
+  c
+end
+
+def benchmark
+  Benchmark.bm 30 do |x|
+    x.report "testing add" do
+      1_000_000.times do |_|
+        add(:a => rand(1000), :b => rand(1000))
+      end
+    end
+    x.report "testing contracts add" do
+      1_000_000.times do |_|
+        contracts_add(:a => rand(1000), :b => rand(1000))
+      end
+    end
+  end
+end
+
+def profile
+  profilers = []
+  profilers << MethodProfiler.observe(Contract)
+  profilers << MethodProfiler.observe(Object)
+  profilers << MethodProfiler.observe(Contracts::MethodDecorators)
+  profilers << MethodProfiler.observe(Contracts::Decorator)
+  profilers << MethodProfiler.observe(Contracts::Support)
+  profilers << MethodProfiler.observe(UnboundMethod)
+  10_000.times do |_|
+    contracts_add(:a => rand(1000), :b => rand(1000))
+  end
+  profilers.each { |p| puts p.report }
+end
+
+def ruby_prof
+  RubyProf.start
+  100_000.times do |_|
+    contracts_add(:a => rand(1000), :b => rand(1000))
+  end
+  result = RubyProf.stop
+  printer = RubyProf::FlatPrinter.new(result)
+  printer.print(STDOUT)
+end
+
+benchmark
+profile
+ruby_prof if ENV["FULL_BENCH"] # takes some time

data/lib/contracts.rb

@@ -1,12 +1,14 @@
 require "contracts/builtin_contracts"
 require "contracts/decorators"
-require "contracts/eigenclass"
 require "contracts/errors"
 require "contracts/formatters"
 require "contracts/invariants"
 require "contracts/method_reference"
-require "contracts/modules"
 require "contracts/support"
+require "contracts/engine"
+require "contracts/method_handler"
+require "contracts/validators"
+require "contracts/call_with"
 
 module Contracts
   def self.included(base)
@@ -18,15 +20,13 @@ module Contracts
   end
 
   def self.common(base)
-    Eigenclass.lift(base)
-
     return if base.respond_to?(:Contract)
 
     base.extend(MethodDecorators)
 
     base.instance_eval do
       def functype(funcname)
-        contracts = decorated_methods[:class_methods][funcname]
+        contracts = Engine.fetch_from(self).decorated_methods_for(:class_methods, funcname)
         if contracts.nil?
           "No contract for #{self}.#{funcname}"
         else
@@ -36,22 +36,14 @@ module Contracts
     end
 
     base.class_eval do
-      unless base.instance_of?(Module)
-        def Contract(*args)
-          return if ENV["NO_CONTRACTS"]
-          if self.class == Module
-            puts %{
-Warning: You have added a Contract on a module function
-without including Contracts::Modules. Your Contract will
-just be ignored. Please include Contracts::Modules into
-your module.}
-          end
-          self.class.Contract(*args)
-        end
+      # TODO: deprecate
+      # Required when contracts are included in global scope
+      def Contract(*args)
+        self.class.Contract(*args)
       end
 
       def functype(funcname)
-        contracts = self.class.decorated_methods[:instance_methods][funcname]
+        contracts = Engine.fetch_from(self.class).decorated_methods_for(:instance_methods, funcname)
         if contracts.nil?
           "No contract for #{self.class}.#{funcname}"
         else
@@ -68,7 +60,15 @@ end
 #   Contract [contract names] => return_value
 #
 # This class also provides useful callbacks and a validation method.
+#
+# For #make_validator and related logic see file
+# lib/contracts/validators.rb
+# For #call_with and related logic see file
+# lib/contracts/call_with.rb
 class Contract < Contracts::Decorator
+  extend Contracts::Validators
+  include Contracts::CallWith
+
   # Default implementation of failure_callback. Provided as a block to be able
   # to monkey patch #failure_callback only temporary and then switch it back.
   # First important usage - for specs.
@@ -113,8 +113,9 @@ class Contract < Contracts::Decorator
     # == @has_proc_contract
     last_contract = args_contracts.last
     is_a_proc = last_contract.is_a?(Class) && (last_contract <= Proc || last_contract <= Method)
+    maybe_a_proc = last_contract.is_a?(Contracts::Maybe) && last_contract.include_proc?
 
-    @has_proc_contract = is_a_proc || last_contract.is_a?(Contracts::Func)
+    @has_proc_contract = is_a_proc || maybe_a_proc || last_contract.is_a?(Contracts::Func)
     # ====
 
     # == @has_options_contract
@@ -218,54 +219,6 @@ class Contract < Contracts::Decorator
     make_validator(contract)[arg]
   end
 
-  # This is a little weird. For each contract
-  # we pre-make a proc to validate it so we
-  # don't have to go through this decision tree every time.
-  # Seems silly but it saves us a bunch of time (4.3sec vs 5.2sec)
-  def self.make_validator(contract)
-    # if is faster than case!
-    klass = contract.class
-    if klass == Proc
-      # e.g. lambda {true}
-      contract
-    elsif klass == Array
-      # e.g. [Num, String]
-      # TODO: account for these errors too
-      lambda do |arg|
-        return false unless arg.is_a?(Array) && arg.length == contract.length
-        arg.zip(contract).all? do |_arg, _contract|
-          Contract.valid?(_arg, _contract)
-        end
-      end
-    elsif klass == Hash
-      # e.g. { :a => Num, :b => String }
-      lambda do |arg|
-        return false unless arg.is_a?(Hash)
-        contract.keys.all? do |k|
-          Contract.valid?(arg[k], contract[k])
-        end
-      end
-    elsif klass == Contracts::Args
-      lambda do |arg|
-        Contract.valid?(arg, contract.contract)
-      end
-    elsif klass == Contracts::Func
-      lambda do |arg|
-        arg.is_a?(Method) || arg.is_a?(Proc)
-      end
-    else
-      # classes and everything else
-      # e.g. Fixnum, Num
-      if contract.respond_to? :valid?
-        lambda { |arg| contract.valid?(arg) }
-      elsif klass == Class
-        lambda { |arg| arg.is_a?(contract) }
-      else
-        lambda { |arg| contract == arg }
-      end
-    end
-  end
-
   def [](*args, &blk)
     call(*args, &blk)
   end
@@ -296,95 +249,6 @@ class Contract < Contracts::Decorator
     end
   end
 
-  def call_with(this, *args, &blk)
-    args << blk if blk
-
-    # Explicitly append blk=nil if nil != Proc contract violation anticipated
-    maybe_append_block!(args, blk)
-
-    # Explicitly append options={} if Hash contract is present
-    maybe_append_options!(args, blk)
-
-    # Loop forward validating the arguments up to the splat (if there is one)
-    (@args_contract_index || args.size).times do |i|
-      contract = args_contracts[i]
-      arg = args[i]
-      validator = @args_validators[i]
-
-      unless validator && validator[arg]
-        return unless Contract.failure_callback(:arg => arg,
-                                                :contract => contract,
-                                                :class => klass,
-                                                :method => method,
-                                                :contracts => self,
-                                                :arg_pos => i+1,
-                                                :total_args => args.size,
-                                                :return_value => false)
-      end
-
-      if contract.is_a?(Contracts::Func)
-        args[i] = Contract.new(klass, arg, *contract.contracts)
-      end
-    end
-
-    # If there is a splat loop backwards to the lower index of the splat
-    # Once we hit the splat in this direction set its upper index
-    # Keep validating but use this upper index to get the splat validator.
-    if @args_contract_index
-      splat_upper_index = @args_contract_index
-      (args.size - @args_contract_index).times do |i|
-        arg = args[args.size - 1 - i]
-
-        if args_contracts[args_contracts.size - 1 - i].is_a?(Contracts::Args)
-          splat_upper_index = i
-        end
-
-        # Each arg after the spat is found must use the splat validator
-        j = i < splat_upper_index ? i : splat_upper_index
-        contract = args_contracts[args_contracts.size - 1 - j]
-        validator = @args_validators[args_contracts.size - 1 - j]
-
-        unless validator && validator[arg]
-          return unless Contract.failure_callback(:arg => arg,
-                                                  :contract => contract,
-                                                  :class => klass,
-                                                  :method => method,
-                                                  :contracts => self,
-                                                  :arg_pos => i-1,
-                                                  :total_args => args.size,
-                                                  :return_value => false)
-        end
-
-        if contract.is_a?(Contracts::Func)
-          args[args.size - 1 - i] = Contract.new(klass, arg, *contract.contracts)
-        end
-      end
-    end
-
-    # If we put the block into args for validating, restore the args
-    args.slice!(-1) if blk
-    result = if method.respond_to?(:call)
-               # proc, block, lambda, etc
-               method.call(*args, &blk)
-             else
-               # original method name referrence
-               method.send_to(this, *args, &blk)
-             end
-
-    unless @ret_validator[result]
-      Contract.failure_callback(:arg => result,
-                                :contract => ret_contract,
-                                :class => klass,
-                                :method => method,
-                                :contracts => self,
-                                :return_value => true)
-    end
-
-    this.verify_invariants!(method) if this.respond_to?(:verify_invariants!)
-
-    result
-  end
-
   # Used to determine type of failure exception this contract should raise in case of failure
   def failure_exception
     if @pattern_match