contracts 0.0.6 → 0.0.7

data/lib/builtin_contracts.rb

@@ -1,3 +1,5 @@
+require 'testable'
+
 =begin rdoc
 This module contains all the builtin contracts.
 If you want to use them, first:
@@ -21,6 +23,14 @@ module Contracts
     def self.valid? val
       val.is_a? Numeric
     end
+
+    def self.testable?
+      true
+    end
+
+    def self.test_data
+      [-1, 0, 1, 1.5, 50000]
+    end
   end
 
   # Check that an argument is a positive number.
@@ -28,6 +38,14 @@ module Contracts
     def self.valid? val
       val > 0
     end
+
+    def testable?
+      true
+    end
+
+    def self.test_data
+      (0..5).map { rand(999) + 1 }
+    end
   end
 
   # Check that an argument is a negative number.
@@ -35,6 +53,14 @@ module Contracts
     def self.valid? val
       val < 0
     end
+
+    def testable?
+      true
+    end
+
+    def self.test_data
+      (0..5).map { (rand(999) + 1) * -1 }
+    end
   end
 
   # Passes for any argument.
@@ -83,6 +109,19 @@ module Contracts
     def to_s
       @vals[0, @vals.size-1].join(", ") + " or " + @vals[-1].to_s
     end
+
+    # this can only be tested IF all the sub-contracts have a test_data method
+    def testable?
+      @vals.all? do |val|
+        Testable.testable?(val)
+      end    
+    end
+
+    def test_data
+      @vals.map { |val|
+        Testable.test_data(val)
+      }.flatten
+    end
   end
 
   # Takes a variable number of contracts.
@@ -104,6 +143,18 @@ module Contracts
     def to_s
       @vals[0, @vals.size-1].join(", ") + " xor " + @vals[-1].to_s
     end
+
+    def testable?
+      @vals.all? do |val|
+        Testable.testable? val
+      end    
+    end
+
+    def test_data
+      @vals.map { |val|
+        Testable.test_data val
+      }.flatten
+    end    
   end  
 
   # Takes a variable number of contracts.
@@ -129,8 +180,8 @@ module Contracts
   # Takes a variable number of method names as symbols.
   # The contract passes if the argument responds to all
   # of those methods.
-  # Example: <tt>RespondsTo[:password, :credit_card]</tt>
-  class RespondsTo < CallableClass
+  # Example: <tt>RespondTo[:password, :credit_card]</tt>
+  class RespondTo < CallableClass
     def initialize(*meths)
       @meths = meths
     end
@@ -222,6 +273,14 @@ module Contracts
     def to_s
       "an array of #{@contract}"
     end
+
+    def testable?
+      Testable.testable? @contract
+    end
+
+    def test_data
+      [[], [Testable.test_data(@contract)], [Testable.test_data(@contract), Testable.test_data(@contract)]]
+    end    
   end
 
   # Used for <tt>*args</tt> (variadic functions). Takes a contract
@@ -237,5 +296,60 @@ module Contracts
     def to_s
       "Args[#{@contract}]"
     end
-  end  
+
+    def testable?
+      Testable.testable? @contract
+    end
+
+    def test_data
+      [[], [Testable.test_data(@contract)], [Testable.test_data(@contract), Testable.test_data(@contract)]]
+    end    
+  end
+
+  class Bool
+    def self.valid? val
+      val.is_a?(TrueClass) || val.is_a?(FalseClass)
+    end
+  end
+
+  class ::Hash
+    def testable?
+      self.values.all? do |val|
+        Testable.testable?(val)
+      end
+    end
+
+    def test_data
+      keys = self.keys
+      _vals = keys.map do |key|
+        ret = Testable.test_data(self[key])
+        if ret.is_a? Array
+          ret
+        else
+          [ret]
+        end
+      end
+      all_vals = Testable.product(_vals)
+      hashes = []
+      all_vals.each do |vals|
+        hash = {}
+        keys.zip(vals).each do |key, val|
+          hash[key] = val
+        end
+        hashes << hash
+      end
+      hashes
+    end
+  end
+
+  class ::String
+    def self.testable?
+      true
+    end
+
+    def self.test_data
+      # send a random string
+      ('a'..'z').to_a.shuffle[0, 10].join
+    end
+  end
 end

data/lib/contracts.rb

@@ -1,15 +1,16 @@
 require 'decorators'
 require 'builtin_contracts'
 
-class Class
-  include MethodDecorators
-end
+module Contracts
+  def self.included(base)
+    base.extend MethodDecorators
+  end
 
-class Module
-  include MethodDecorators
+  def self.extended(base)
+    base.extend MethodDecorators
+  end
 end
 
-
 # This is the main Contract class. When you write a new contract, you'll
 # write it as:
 #
@@ -18,7 +19,7 @@ end
 # This class also provides useful callbacks and a validation method.
 class Contract < Decorator
   attr_accessor :contracts, :klass, :method
-  decorator_name :contract
+  # decorator_name :contract
   def initialize(klass, method, *contracts)
     @klass, @method, @contracts = klass, method, contracts
   end
@@ -185,3 +186,17 @@ Contracts: #{@contracts.map { |t| t.is_a?(Class) ? t.name : t.class.name }.join(
     end
   end
 end
+
+# convenience function for small scripts.
+# Use as:
+#   
+#   use_contracts self
+#
+# And then you can use contracts on functions
+# that aren't in any module or class.
+def use_contracts(this)
+  this.class.send(:include, Contracts)
+  def this.Contract(*args)
+    self.class.Contract(*args)
+  end
+end

data/lib/decorators.rb

@@ -5,27 +5,11 @@ module MethodDecorators
     end
   end
 
-  def method_missing(name, *args, &blk)
-    # if the const isn't capitalized, then const_defined will throw an
-    # error. So first check to make sure it is capitalized.
-    letter = name.to_s[0]
-    if letter >= 65 && letter <= 90 && Object.const_defined?(name)
-      const = Object.const_get(name)
-    elsif Decorator.decorators.key?(name)
-      const = Decorator.decorators[name]
-    else
-      return super
-    end
-
-    instance_eval <<-ruby_eval, __FILE__, __LINE__ + 1
-      def #{name}(*args, &blk)
-        decorate(#{const.name}, *args, &blk)
-      end
-    ruby_eval
-
-    send(name, *args, &blk)
-  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)
     return unless @decorators
 
@@ -33,13 +17,21 @@ module MethodDecorators
     @decorators = nil
     @decorated_methods ||= Hash.new {|h,k| h[k] = []}
 
+    # attr_accessor on the class variable decorated_methods
     class << self; attr_accessor :decorated_methods; end
 
     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.
       decorator = klass.respond_to?(:new) ? klass.new(self, instance_method(name), *args) : klass
       @decorated_methods[name] << decorator
     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.
     class_eval <<-ruby_eval, __FILE__, __LINE__ + 1
       def #{name}(*args, &blk)
         ret = nil
@@ -49,6 +41,7 @@ module MethodDecorators
         ret
       end
     ruby_eval
+    super
   end
 
   def decorate(klass, *args)
@@ -58,19 +51,18 @@ module MethodDecorators
 end
 
 class Decorator
-  class << self
-    attr_accessor :decorators
-    def decorator_name(name)
-      Decorator.decorators ||= {}
-      Decorator.decorators[name] = self
-    end
-  end
+  # 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)
         decorate(#{klass}, *args, &blk)

data/lib/foo.rb

@@ -1,11 +1,10 @@
 require 'contracts'
-include Contracts
+use_contracts(self)
 
-class Object
-  Contract Num, Num, Num
-  def add(a, b)
-     a + b
-   end
+Contract [Num, String]
+def mult
+  return 1, 2
 end
 
-puts add(1, "foo")
+f = mult
+p f

data/lib/test.rb

@@ -1,7 +1,9 @@
 require 'contracts'
+require 'testable'
 include Contracts
 
 class Object
+
   Contract Num, Num
   def double(x)
     x * 2
@@ -35,6 +37,24 @@ class Object
   def person(data)
     p data
   end
+
+  Contract Num, Num
+  def test(x)
+    x + 2
+  end
 end
 
-person({:name => "Adit", :age => 25, :bar => 45})
+# this doesn't work
+# p Object.send(:sum, 1, 2)
+
+# but this does:
+# p send(:sum, 1, 2)
+#
+# why???
+
+Testable.check_all
+# Testable.check(method(:double))
+
+# p Object.test(5)
+#
+Object.Hello

data/lib/testable.rb

@@ -0,0 +1,69 @@
+module Contracts
+  class Testable
+    # Given an array-of-arrays of arguments,
+    # gives you the product of those arguments so that
+    # each possible combination is tried.
+    # Example: <tt>[[1, 2], [3, 4]]</tt> would give you:
+    #
+    #   [[1, 3], [1, 4], [2, 3], [2, 4]]
+    def self.product(arrays)
+      arrays.inject { |acc, x|
+        acc.product(x)
+      }.flatten(arrays.size - 2)
+    end
+    
+    # Given a contract, tells if you it's testable
+    def self.testable?(contract)
+      if contract.respond_to?(:testable?)
+        contract.testable?
+      else
+        contract.respond_to?(:new) && contract.method(:new).arity == 0
+      end
+    end
+
+    # Given a contract, returns the test data associated with that contract
+    def self.test_data(contract)
+      if contract.respond_to?(:testable?)
+        contract.test_data
+      else
+        contract.new
+      end
+    end
+
+    # TODO Should work on whatever class it was invoked on, no?
+    def self.check_all
+      o = Object.new
+      Object.decorated_methods.each do |name, contracts|
+        check(o.method(name))
+      end
+    end
+
+    def self.check(meth)
+      contracts = meth.owner.decorated_methods[meth.name.to_sym][0].contracts
+      arg_contracts = contracts[0, contracts.size - 1]
+      return_val = contracts[-1]
+      checkable = arg_contracts.all? do |arg_contract|
+        Testable.testable?(arg_contract)
+      end
+
+      if checkable
+        print "Checking #{meth.name}..."
+        _test_data = arg_contracts.map do |arg_contract|
+          data = Testable.test_data(arg_contract)
+          data.is_a?(Array) ? data : [data]
+        end
+        test_data = Testable.product _test_data
+        test_data.each do |args|
+          if args.is_a? Hash
+            # because *hash destroys the hash
+            res = meth.call(args)
+          else
+            res = meth.call(*args)
+          end
+          Contract.valid?(res, return_val)
+        end
+        puts "#{test_data.size} tests run."
+      end
+    end    
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: contracts
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 17
   prerelease: false
   segments: 
   - 0
   - 0
-  - 6
-  version: 0.0.6
+  - 7
+  version: 0.0.7
 platform: ruby
 authors: 
 - Aditya Bhargava
@@ -33,6 +33,7 @@ files:
 - lib/decorators.rb
 - lib/foo.rb
 - lib/test.rb
+- lib/testable.rb
 has_rdoc: true
 homepage: http://github.com/egonSchiele/contracts.ruby
 licenses: []