contracts-lite 0.14.0

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
+  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(rand(1000), rand(1000))
+      end
+    end
+    x.report "testing contracts add" do
+      1_000_000.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)
+  10_000.times do |_|
+    contracts_add(rand(1000), rand(1000))
+  end
+  profilers.each { |p| puts p.report }
+end
+
+def ruby_prof
+  RubyProf.start
+  100_000.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/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/benchmarks/invariants.rb

@@ -0,0 +1,91 @@
+require "./lib/contracts"
+require "benchmark"
+require "rubygems"
+require "method_profiler"
+require "ruby-prof"
+
+class Obj
+  include Contracts
+
+  attr_accessor :value
+  def initialize value
+    @value = value
+  end
+
+  Contract Num, Num => Num
+  def contracts_add a, b
+    a + b
+  end
+end
+
+class ObjWithInvariants
+  include Contracts
+  include Contracts::Invariants
+
+  invariant(:value_not_nil) { value != nil }
+  invariant(:value_not_string) { !value.is_a?(String) }
+
+  attr_accessor :value
+  def initialize value
+    @value = value
+  end
+
+  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
+      1_000_000.times do |_|
+        obj.contracts_add(rand(1000), rand(1000))
+      end
+    end
+    x.report "testing contracts add with invariants" do
+      1_000_000.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)
+
+  10_000.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)
+
+  100_000.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/io.rb

@@ -0,0 +1,62 @@
+require "./lib/contracts"
+require "benchmark"
+require "rubygems"
+require "method_profiler"
+require "ruby-prof"
+require "open-uri"
+
+include Contracts
+
+def download url
+  open("http://www.#{url}/").read
+end
+
+Contract String => String
+def contracts_download url
+  open("http://www.#{url}").read
+end
+
+@urls = %w{google.com bing.com}
+
+def benchmark
+  Benchmark.bm 30 do |x|
+    x.report "testing download" do
+      100.times do |_|
+        download(@urls.sample)
+      end
+    end
+    x.report "testing contracts download" do
+      100.times do |_|
+        contracts_download(@urls.sample)
+      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.times do |_|
+    contracts_download(@urls.sample)
+  end
+  profilers.each { |p| puts p.report }
+end
+
+def ruby_prof
+  RubyProf.start
+  10.times do |_|
+    contracts_download(@urls.sample)
+  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,57 @@
+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
+    100_000.times do |_|
+      w.add(rand(1000), rand(1000))
+    end
+  end
+  x.report "not wrapped" do
+    100_000.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-lite"
+  s.version     = Contracts::VERSION
+  s.summary     = "Contracts for Ruby. (fork)"
+  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/ddd-ruby/contracts.ruby"
+  s.license     = "BSD-2-Clause"
+end

data/lib/contracts.rb

@@ -0,0 +1,231 @@
+require "contracts/builtin_contracts"
+require "contracts/decorators"
+require "contracts/errors"
+require "contracts/error_formatter"
+require "contracts/formatters"
+require "contracts/invariants"
+require "contracts/method_reference"
+require "contracts/support"
+require "contracts/engine"
+require "contracts/method_handler"
+require "contracts/validators"
+require "contracts/call_with"
+require "contracts/core"
+
+module Contracts
+  def self.included(base)
+    base.send(:include, Core)
+  end
+
+  def self.extended(base)
+    base.send(:extend, Core)
+  end
+end
+
+# This is the main Contract class. When you write a new contract, you'll
+# write it as:
+#
+#   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.
+  DEFAULT_FAILURE_CALLBACK = proc do |data|
+    if data[:return_value]
+      # this failed on the return contract
+      fail ReturnContractError.new(failure_msg(data), data)
+    else
+      # this failed for a param contract
+      fail data[:contracts].failure_exception.new(failure_msg(data), data)
+    end
+  end
+
+  attr_reader :args_contracts, :ret_contract, :klass, :method
+  def initialize(klass, method, *contracts)
+    unless contracts.last.is_a?(Hash)
+      unless contracts.one?
+        fail %{
+          It looks like your contract for #{method.name} doesn't have a return
+          value. A contract should be written as `Contract arg1, arg2 =>
+          return_value`.
+        }.strip
+      end
+      contracts = [nil => contracts[-1]]
+    end
+
+    # internally we just convert that return value syntax back to an array
+    @args_contracts = contracts[0, contracts.size - 1] + contracts[-1].keys
+
+    @ret_contract = contracts[-1].values[0]
+
+    @args_validators = args_contracts.map do |contract|
+      Contract.make_validator(contract)
+    end
+
+    @args_contract_index = args_contracts.index do |contract|
+      contract.is_a? Contracts::Args
+    end
+
+    @ret_validator = Contract.make_validator(ret_contract)
+
+    @pattern_match = false
+
+    # == @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 || maybe_a_proc || last_contract.is_a?(Contracts::Func)
+
+    # ====
+
+    # == @has_options_contract
+    last_contract = args_contracts.last
+    penultimate_contract = args_contracts[-2]
+    @has_options_contract = if @has_proc_contract
+                              penultimate_contract.is_a?(Hash) || penultimate_contract.is_a?(Contracts::Builtin::KeywordArgs)
+                            else
+                              last_contract.is_a?(Hash) || last_contract.is_a?(Contracts::Builtin::KeywordArgs)
+                            end
+    # ===
+
+    @klass, @method = klass, method
+  end
+
+  def pretty_contract c
+    c.is_a?(Class) ? c.name : c.class.name
+  end
+
+  def to_s
+    args = args_contracts.map { |c| pretty_contract(c) }.join(", ")
+    ret = pretty_contract(ret_contract)
+    ("#{args} => #{ret}").gsub("Contracts::Builtin::", "")
+  end
+
+  # Given a hash, prints out a failure message.
+  # This function is used by the default #failure_callback method
+  # and uses the hash passed into the failure_callback method.
+  def self.failure_msg(data)
+    Contracts::ErrorFormatters.failure_msg(data)
+  end
+
+  # Callback for when a contract fails. By default it raises
+  # an error and prints detailed info about the contract that
+  # failed. You can also monkeypatch this callback to do whatever
+  # you want...log the error, send you an email, print an error
+  # message, etc.
+  #
+  # Example of monkeypatching:
+  #
+  #   def Contract.failure_callback(data)
+  #     puts "You had an error!"
+  #     puts failure_msg(data)
+  #     exit
+  #   end
+  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.
+  #
+  # Takes: an argument and a contract.
+  #
+  # Returns: a tuple: [Boolean, metadata]. The boolean indicates
+  # whether the contract was valid or not. If it wasn't, metadata
+  # contains some useful information about the failure.
+  def self.valid?(arg, contract)
+    make_validator(contract)[arg]
+  end
+
+  def [](*args, &blk)
+    call(*args, &blk)
+  end
+
+  def call(*args, &blk)
+    call_with(nil, *args, &blk)
+  end
+
+  # if we specified a proc in the contract but didn't pass one in,
+  # it's possible we are going to pass in a block instead. So lets
+  # append a nil to the list of args just so it doesn't fail.
+
+  # a better way to handle this might be to take this into account
+  # before throwing a "mismatched # of args" error.
+  # returns true if it appended nil
+  def maybe_append_block! args, blk
+    return false unless @has_proc_contract && !blk &&
+        (@args_contract_index || args.size < args_contracts.size)
+    args << nil
+    true
+  end
+
+  # Same thing for when we have named params but didn't pass any in.
+  # returns true if it appended nil
+  def maybe_append_options! args, blk
+    return false unless @has_options_contract
+    if @has_proc_contract && (args_contracts[-2].is_a?(Hash) || args_contracts[-2].is_a?(Contracts::Builtin::KeywordArgs)) && !args[-2].is_a?(Hash)
+      args.insert(-2, {})
+    elsif (args_contracts[-1].is_a?(Hash) || args_contracts[-1].is_a?(Contracts::Builtin::KeywordArgs)) && !args[-1].is_a?(Hash)
+      args << {}
+    end
+    true
+  end
+
+  # Used to determine type of failure exception this contract should raise in case of failure
+  def failure_exception
+    if pattern_match?
+      PatternMatchingError
+    else
+      ParamContractError
+    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 == true
+  end
+end