contracts 0.4 → 0.5

data/benchmarks/bench.rb

@@ -0,0 +1,67 @@
+require './lib/contracts'
+require 'benchmark'
+require 'rubygems'
+require 'method_profiler'
+require 'ruby-prof'
+
+include Contracts
+
+def add a, b
+  a + b
+end
+
+Contract Num, Num => Num
+def contracts_add a, b
+  a + b
+end
+
+def explicit_add a, b
+  raise unless a.is_a?(Numeric)
+  raise unless b.is_a?(Numeric)
+  c = a + b
+  raise unless c.is_a?(Numeric)
+  c
+end
+
+def benchmark
+  Benchmark.bm 30 do |x|
+    x.report 'testing add' do
+      1000000.times do |_|
+        add(rand(1000), rand(1000))
+      end
+    end
+    x.report 'testing contracts add' do
+      1000000.times do |_|
+        contracts_add(rand(1000), 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)
+  10000.times do |_|
+    contracts_add(rand(1000), rand(1000))
+  end  
+  profilers.each { |p| puts p.report }
+end
+
+def ruby_prof
+RubyProf.start  
+    100000.times do |_|
+      contracts_add(rand(1000), 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/benchmarks/invariants.rb

@@ -0,0 +1,81 @@
+require './lib/contracts'
+require 'benchmark'
+require 'rubygems'
+require 'method_profiler'
+require 'ruby-prof'
+
+class Obj < Struct.new(:value)
+  include Contracts
+
+  Contract Num, Num => Num
+  def contracts_add a, b
+    a + b
+  end
+end
+
+class ObjWithInvariants < Struct.new(:value)
+  include Contracts
+  include Contracts::Invariants
+
+  Invariant(:value_not_nil) { value != nil }
+  Invariant(:value_not_string) { !value.is_a?(String) }
+
+  Contract Num, Num => Num
+  def contracts_add a, b
+    a + b
+  end
+end
+
+def benchmark
+  obj = Obj.new(3)
+  obj_with_invariants = ObjWithInvariants.new(3)
+
+  Benchmark.bm 30 do |x|
+    x.report 'testing contracts add' do
+      1000000.times do |_|
+        obj.contracts_add(rand(1000), rand(1000))
+      end
+    end
+    x.report 'testing contracts add with invariants' do
+      1000000.times do |_|
+        obj_with_invariants.contracts_add(rand(1000), rand(1000))
+      end
+    end  
+  end
+end
+
+def profile
+  obj_with_invariants = ObjWithInvariants.new(3)
+
+  profilers = []
+  profilers << MethodProfiler.observe(Contract)
+  profilers << MethodProfiler.observe(Object)
+  profilers << MethodProfiler.observe(Contracts::Support)
+  profilers << MethodProfiler.observe(Contracts::Invariants)
+  profilers << MethodProfiler.observe(Contracts::Invariants::InvariantExtension)
+  profilers << MethodProfiler.observe(UnboundMethod)
+
+  10000.times do |_|
+    obj_with_invariants.contracts_add(rand(1000), rand(1000))
+  end  
+
+  profilers.each { |p| puts p.report }
+end
+
+def ruby_prof
+  RubyProf.start  
+
+  obj_with_invariants = ObjWithInvariants.new(3)
+
+  100000.times do |_|
+    obj_with_invariants.contracts_add(rand(1000), 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/benchmarks/wrap_test.rb

@@ -0,0 +1,59 @@
+require 'benchmark'
+
+module Wrapper
+  def self.extended(klass)
+    klass.class_eval do
+      @@methods = {}
+      def self.methods
+        @@methods
+      end
+      def self.set_method k, v
+        @@methods[k] = v
+      end
+    end
+  end
+
+  def method_added name
+    return if methods.include?(name)
+    puts "#{name} added"
+    set_method(name, instance_method(name))
+    class_eval %{
+      def #{name}(*args)
+        self.class.methods[#{name.inspect}].bind(self).call(*args)
+      end
+    }, __FILE__, __LINE__ + 1
+  end
+end
+
+class NotWrapped
+def add a, b
+  a + b
+end
+end
+
+class Wrapped
+  extend ::Wrapper
+  def add a, b
+    a + b
+  end
+end
+
+
+w = Wrapped.new
+nw = NotWrapped.new
+#p w.add(1, 4)
+#exit
+# 30 is the width of the output column
+Benchmark.bm 30 do |x|
+  x.report 'wrapped' do
+    100000.times do |_|
+      w.add(rand(1000), rand(1000))
+    end
+  end
+  x.report 'not wrapped' do
+    100000.times do |_|
+      nw.add(rand(1000), rand(1000))      
+    end
+  end
+end
+

data/contracts.gemspec

@@ -0,0 +1,13 @@
+require File.expand_path(File.join(__FILE__, '../lib/contracts/version'))
+
+Gem::Specification.new do |s|
+  s.name        = "contracts"
+  s.version     = Contracts::VERSION
+  s.date        = "2014-05-08"
+  s.summary     = "Contracts for Ruby."
+  s.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 code."
+  s.author      = "Aditya Bhargava"
+  s.email       = "bluemangroupie@gmail.com"
+  s.files       = `git ls-files`.split("\n")
+  s.homepage    = "http://github.com/egonSchiele/contracts.ruby"
+end

data/lib/contracts.rb

@@ -1,7 +1,39 @@
-require 'decorators'
-require 'builtin_contracts'
+require 'contracts/support'
+require 'contracts/decorators'
+require 'contracts/builtin_contracts'
+require 'contracts/invariants'
 
-class ContractError < ArgumentError
+# @private
+# Base class for Contract errors
+#
+# If default failure callback is used it stores failure data
+class ContractBaseError < ArgumentError
+  attr_reader :data
+
+  def initialize(message, data)
+    super(message)
+    @data = data
+  end
+
+  # Used to convert to simple ContractError from other contract errors
+  def to_contract_error
+    self
+  end
+end
+
+# Default contract error
+#
+# If default failure callback is used, users normally see only these contract errors
+class ContractError < ContractBaseError
+end
+
+# @private
+# Special contract error used internally to detect pattern failure during pattern matching
+class PatternMatchingError < ContractBaseError
+  # Used to convert to ContractError from PatternMatchingError
+  def to_contract_error
+    ContractError.new(to_s, data)
+  end
 end
 
 module Contracts
@@ -14,6 +46,8 @@ module Contracts
   end
 
   def self.common base
+    return if base.respond_to?(:Contract)
+
     base.extend MethodDecorators
     base.instance_eval do
       def functype(funcname)
@@ -27,6 +61,7 @@ module Contracts
     end
     base.class_eval do
       def Contract(*args)
+        return if ENV["NO_CONTRACTS"]
         self.class.Contract(*args)
       end
 
@@ -39,7 +74,7 @@ module Contracts
         end
       end
     end
-  end    
+  end
 end
 
 # This is the main Contract class. When you write a new contract, you'll
@@ -48,7 +83,14 @@ end
 #   Contract [contract names] => return_value
 #
 # This class also provides useful callbacks and a validation method.
-class Contract < Decorator
+class Contract < Contracts::Decorator
+  # 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.
+  DEFAULT_FAILURE_CALLBACK = Proc.new do |data|
+    raise data[:contracts].failure_exception.new(failure_msg(data), data)
+  end
+
   attr_reader :args_contracts, :ret_contract, :klass, :method
   # decorator_name :contract
   def initialize(klass, method, *contracts)
@@ -89,17 +131,8 @@ class Contract < Decorator
                 data[:contract].to_s
               end
 
-    if RUBY_VERSION =~ /^1\.8/
-      if data[:method].respond_to?(:__file__)
-        position = data[:method].__file__ + ":" + data[:method].__line__.to_s
-      else
-        position = data[:method].inspect
-      end
-    else
-      file, line = data[:method].source_location
-      position = file + ":" + line.to_s
-    end
-   method_name = data[:method].is_a?(Proc) ? "Proc" : data[:method].name
+   position = Support.method_position(data[:method])
+   method_name = Support.method_name(data[:method])
 
    header = if data[:return_value]
      "Contract violation for return value:"
@@ -123,13 +156,41 @@ class Contract < Decorator
   #
   # Example of monkeypatching:
   #
-  #   Contract.failure_callback(data)
+  #   def Contract.failure_callback(data)
   #     puts "You had an error!"
   #     puts failure_msg(data)
   #     exit
   #   end
-  def self.failure_callback(data)
-    raise ContractError, failure_msg(data)
+  def self.failure_callback(data, use_pattern_matching=true)
+    if data[:contracts].pattern_match? && use_pattern_matching
+      return DEFAULT_FAILURE_CALLBACK.call(data)
+    end
+
+    fetch_failure_callback.call(data)
+  end
+
+  # Used to override failure_callback without monkeypatching.
+  #
+  # Takes: block parameter, that should accept one argument - data.
+  #
+  # Example usage:
+  #
+  #   Contract.override_failure_callback do |data|
+  #     puts "You had an error"
+  #     puts failure_msg(data)
+  #     exit
+  #   end
+  def self.override_failure_callback(&blk)
+    @failure_callback = blk
+  end
+
+  # Used to restore default failure callback
+  def self.restore_failure_callback
+    @failure_callback = DEFAULT_FAILURE_CALLBACK
+  end
+
+  def self.fetch_failure_callback
+    @failure_callback ||= DEFAULT_FAILURE_CALLBACK
   end
 
   # Used to verify if an argument satisfies a contract.
@@ -157,7 +218,7 @@ class Contract < Decorator
       # e.g. [Num, String]
       # TODO account for these errors too
       lambda { |arg|
-        return false unless arg.is_a?(Array)
+        return false unless arg.is_a?(Array) && arg.length == contract.length
         arg.zip(contract).all? do |_arg, _contract|
           Contract.valid?(_arg, _contract)
         end
@@ -186,10 +247,10 @@ class Contract < Decorator
       elsif klass == Class
         lambda { |arg| arg.is_a?(contract) }
       else
-        lambda { |arg| contract == arg }        
+        lambda { |arg| contract == arg }
       end
     end
-  end  
+  end
 
   def [](*args, &blk)
     call(*args, &blk)
@@ -200,6 +261,7 @@ class Contract < Decorator
   end
 
   def call_with(this, *args, &blk)
+
     _args = blk ? args + [blk] : args
 
     # check contracts on arguments
@@ -234,7 +296,30 @@ class Contract < Decorator
     end
     unless @ret_validator[result]
       Contract.failure_callback({:arg => result, :contract => @ret_contract, :class => @klass, :method => @method, :contracts => self, :return_value => true})
-    end    
+    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
+      PatternMatchingError
+    else
+      ContractError
+    end
+  end
+
+  # @private
+  # Used internally to mark contract as pattern matching contract
+  def pattern_match!
+    @pattern_match = true
+  end
+
+  # Used to determine if contract is a pattern matching contract
+  def pattern_match?
+    @pattern_match
+  end
 end

data/lib/{builtin_contracts.rb → contracts/builtin_contracts.rb}

@@ -1,4 +1,4 @@
-require 'testable'
+require 'contracts/testable'
 
 =begin rdoc
 This module contains all the builtin contracts.

data/lib/contracts/decorators.rb

@@ -0,0 +1,179 @@
+module Contracts
+  module MethodDecorators
+    def self.extended(klass)
+      return if klass.respond_to?(:decorated_methods=)
+
+      class << klass
+        attr_accessor :decorated_methods
+      end
+    end
+
+    # first, when you write a contract, the decorate method gets called which
+    # sets the @decorators variable. Then when the next method after the contract
+    # is defined, method_added is called and we look at the @decorators variable
+    # to find the decorator for that method. This is how we associate decorators
+    # with methods.
+    def method_added(name)
+      common_method_added name, false
+      super
+    end
+
+    def singleton_method_added name
+      common_method_added name, true
+      super
+    end
+
+    def common_method_added name, is_class_method
+      return unless @decorators
+
+      decorators = @decorators.dup
+      @decorators = nil
+      @decorated_methods ||= {:class_methods => {}, :instance_methods => {}}
+
+      if is_class_method
+        method_reference = method(name)
+        method_type = :class_methods
+        # private_methods is an array of strings on 1.8 and an array of symbols on 1.9
+        is_private = self.private_methods.include?(name) || self.private_methods.include?(name.to_s)
+      else
+        method_reference = instance_method(name)
+        method_type = :instance_methods
+        # private_instance_methods is an array of strings on 1.8 and an array of symbols on 1.9
+        is_private = self.private_instance_methods.include?(name) || self.private_instance_methods.include?(name.to_s)
+      end
+
+      @decorated_methods[method_type][name] ||= []
+
+      decorators.each do |klass, args|
+        # a reference to the method gets passed into the contract here. This is good because
+        # we are going to redefine this method with a new name below...so this reference is
+        # now the *only* reference to the old method that exists.
+        # We assume here that the decorator (klass) responds to .new
+        decorator = klass.new(self, method_reference, *args)
+        @decorated_methods[method_type][name] << decorator
+      end
+
+      if @decorated_methods[method_type][name].any? { |x| x.method != method_reference }
+        @decorated_methods[method_type][name].each do |decorator|
+          decorator.pattern_match!
+        end
+      end
+
+      # in place of this method, we are going to define our own method. This method
+      # just calls the decorator passing in all args that were to be passed into the method.
+      # The decorator in turn has a reference to the actual method, so it can call it
+      # on its own, after doing it's decorating of course.
+
+=begin
+Very important: THe line `current = #{self}` in the start is crucial.
+Not having it means that any method that used contracts could NOT use `super`
+(see this issue for example: https://github.com/egonSchiele/contracts.ruby/issues/27).
+Here's why: Suppose you have this code:
+
+    class Foo
+      Contract nil => String
+      def to_s
+        "Foo"
+      end
+    end
+
+    class Bar < Foo
+      Contract nil => String
+      def to_s
+        super + "Bar"
+      end
+    end
+
+    b = Bar.new
+    p b.to_s
+
+    `to_s` in Bar calls `super`. So you expect this to call `Foo`'s to_s. However,
+    we have overwritten the function (that's what this next defn is). So it gets a
+    reference to the function to call by looking at `decorated_methods`.
+
+    Now, this line used to read something like:
+
+      current = self#{is_class_method ? "" : ".class"}
+
+    In that case, `self` would always be `Bar`, regardless of whether you were calling
+    Foo's to_s or Bar's to_s. So you would keep getting Bar's decorated_methods, which
+    means you would always call Bar's to_s...infinite recursion! Instead, you want to
+    call Foo's version of decorated_methods. So the line needs to be `current = #{self}`.
+=end
+      method_def = %{
+        def #{is_class_method ? "self." : ""}#{name}(*args, &blk)
+          current = #{self}
+          ancestors = current.ancestors
+          ancestors.shift # first one is just the class itself
+          while current && !current.respond_to?(:decorated_methods) || current.decorated_methods.nil?
+            current = ancestors.shift
+          end
+          if !current.respond_to?(:decorated_methods) || current.decorated_methods.nil?
+            raise "Couldn't find decorator for method " + self.class.name + ":#{name}.\nDoes this method look correct to you? If you are using contracts from rspec, rspec wraps classes in it's own class.\nLook at the specs for contracts.ruby as an example of how to write contracts in this case."
+          end
+          methods = current.decorated_methods[#{is_class_method ? ":class_methods" : ":instance_methods"}][#{name.inspect}]
+
+          # this adds support for overloading methods. Here we go through each method and call it with the arguments.
+          # If we get a ContractError, we move to the next function. Otherwise we return the result.
+          # If we run out of functions, we raise the last ContractError.
+          success = false
+          i = 0
+          result = nil
+          expected_error = methods[0].failure_exception
+          while !success
+            method = methods[i]
+            i += 1
+            begin
+              success = true
+              result = method.call_with(self, *args, &blk)
+            rescue expected_error => error
+              success = false
+              unless methods[i]
+                begin
+                  ::Contract.failure_callback(error.data, false)
+                rescue expected_error => final_error
+                  raise final_error.to_contract_error
+                end
+              end
+            end
+          end
+          result
+        end
+        #{is_private ? "private #{name.inspect}" : ""}
+          }
+
+      class_eval method_def, __FILE__, __LINE__ + 1
+    end
+
+    def decorate(klass, *args)
+      @decorators ||= []
+      @decorators << [klass, args]
+    end
+  end
+
+  class Decorator
+    # an attr_accessor for a class variable:
+    class << self; attr_accessor :decorators; end
+
+    def self.inherited(klass)
+      name = klass.name.gsub(/^./) {|m| m.downcase}
+
+      return if name =~ /^[^A-Za-z_]/ || name =~ /[^0-9A-Za-z_]/
+
+      # the file and line parameters set the text for error messages
+      # make a new method that is the name of your decorator.
+      # that method accepts random args and a block.
+      # inside, `decorate` is called with those params.
+      MethodDecorators.module_eval <<-ruby_eval, __FILE__, __LINE__ + 1
+        def #{klass}(*args, &blk)
+          return if ENV["NO_CONTRACTS"]
+          decorate(#{klass}, *args, &blk)
+        end
+      ruby_eval
+    end
+
+    def initialize(klass, method)
+      @method = method
+    end
+  end
+end