contracts 0.0.7 → 0.0.8

data/lib/builtin_contracts.rb

@@ -352,4 +352,11 @@ module Contracts
       ('a'..'z').to_a.shuffle[0, 10].join
     end
   end
+
+  class Func < CallableClass
+    attr_reader :contracts    
+    def initialize(*contracts)
+      @contracts = contracts
+    end
+  end
 end

data/lib/contracts.rb

@@ -1,6 +1,5 @@
 require 'decorators'
 require 'builtin_contracts'
-
 module Contracts
   def self.included(base)
     base.extend MethodDecorators
@@ -40,11 +39,11 @@ class Contract < Decorator
       file, line = data[:method].source_location
       position = file + ":" + line.to_s
     end
-   
+   method_name = data[:method].is_a?(Proc) ? "Proc" : data[:method].name
 %{Contract violation:
     Expected: #{expected},
     Actual: #{data[:arg].inspect}
-    Value guarded in: #{data[:class]}::#{data[:method].name}
+    Value guarded in: #{data[:class]}::#{method_name}
     With Contract: #{data[:contracts].map { |t| t.is_a?(Class) ? t.name : t.class.name }.join(", ") }
     At: #{position} }
   end
@@ -99,6 +98,8 @@ class Contract < Decorator
       validate_hash(arg, contract)
     when Contracts::Args
       valid? arg, contract.contract
+    when Func
+      arg.is_a?(Method) || arg.is_a?(Proc)
     else
       if contract.respond_to? :valid?
         mkerror(contract.valid?(arg), arg, contract)
@@ -108,22 +109,41 @@ class Contract < Decorator
     end
   end
 
-  def call(this, *args, &blk)
+  def call(*args, &blk)
+    call_with(nil, *args, &blk)
+  end
+
+  def call_with(this, *args, &blk)
     _args = blk ? args + [blk] : args
     if _args.size != @contracts.size - 1
       # so it's not *args
-      if !@contracts[-2].is_a? Contracts::Args
+      unless @contracts.any? { |contract| contract.is_a? Contracts::Args }
         raise %{The number of arguments doesn't match the number of contracts.
 Did you forget to write a contract for the return value of the function?
 Or if you want a variable number of arguments using *args, use the Args contract.
 Args: #{args.inspect}
 Contracts: #{@contracts.map { |t| t.is_a?(Class) ? t.name : t.class.name }.join(", ")}}
       end
-    end    
+    end
+
     res = Contract.validate_all(_args, @contracts[0, @contracts.size - 1], @klass, @method)
     return if res == false
 
-    result = @method.bind(this).call(*args, &blk)
+    # contracts on methods
+
+    contracts.each_with_index do |contract, i|
+      if contract.is_a? Func
+      args[i] = Contract.new(@klass, args[i], *contract.contracts)
+      end
+    end      
+    
+    if @method.respond_to? :bind
+      # instance method
+      result = @method.bind(this).call(*args, &blk)
+    else
+      # class method
+      result = @method.call(*args, &blk)
+    end
     
     if args.size == @contracts.size - 1
       Contract.validate(result, @contracts[-1], @klass, @method, @contracts)
@@ -161,18 +181,25 @@ Contracts: #{@contracts.map { |t| t.is_a?(Class) ? t.name : t.class.name }.join(
     mkerror(valid, arg, contract)
   end
 
-  def self.validate_all(args, contracts, klass, method)
-    # we assume that any mismatch in # of args/contracts
+  def self.validate_all(params, contracts, klass, method)
+    # we assume that any mismatch in # of params/contracts
     # has been checked befoer this point.
-    if args.size != contracts.size
-      # assumed: contracts[-1].is_a? Args
-      while contracts.size < args.size
-        contracts << contracts[-1].dup
+    args_index = contracts.index do |contract|
+      contract.is_a? Contracts::Args
+    end
+    if args_index
+      # there is a *args at this index.
+      # Now we need to see how many arguments this contract
+      # accounts for and just duplicate the contract for all
+      # of those args.
+      args_contract = contracts[args_index]
+      while contracts.size < params.size
+        contracts.insert(args_index, args_contract.dup)
       end
     end
 
-    args.zip(contracts).each do |arg, contract|
-      result = validate(arg, contract, klass, method, contracts)
+    params.zip(contracts).each do |param, contract|
+      result = validate(param, contract, klass, method, contracts)
       return result if result == false
     end
   end

data/lib/decorators.rb

@@ -11,6 +11,16 @@ module MethodDecorators
   # 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
@@ -24,7 +34,15 @@ module MethodDecorators
       # 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
+      if klass.respond_to? :new
+        if is_class_method
+          decorator = klass.new(self, method(name), *args)
+        else
+          decorator = klass.new(self, instance_method(name), *args)
+        end
+      else
+        decorator = klass
+      end
       @decorated_methods[name] << decorator
     end
 
@@ -33,16 +51,15 @@ module MethodDecorators
     # 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)
+      def #{is_class_method ? "self." : ""}#{name}(*args, &blk)
         ret = nil
-        self.class.decorated_methods[#{name.inspect}].each do |decorator|
-          ret = decorator.call(self, *args, &blk)
+        self.#{is_class_method ? "" : "class."}decorated_methods[#{name.inspect}].each do |decorator|
+          ret = decorator.call_with(self, *args, &blk)
         end
         ret
       end
     ruby_eval
-    super
-  end
+  end    
 
   def decorate(klass, *args)
     @decorators ||= []

data/lib/foo.rb

@@ -1,10 +1,15 @@
 require 'contracts'
 use_contracts(self)
 
-Contract [Num, String]
-def mult
-  return 1, 2
+add = Proc.new do |x|
+  1
 end
 
-f = mult
-p f
+Contract ArrayOf[Num], Func[String, Num], ArrayOf[Num]
+def map nums, func
+  nums.map do |num|
+    func.call(num)
+  end
+end
+
+p map([1, 2, 3], add)

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: contracts
 version: !ruby/object:Gem::Version 
-  hash: 17
+  hash: 15
   prerelease: false
   segments: 
   - 0
   - 0
-  - 7
-  version: 0.0.7
+  - 8
+  version: 0.0.8
 platform: ruby
 authors: 
 - Aditya Bhargava