contracts 0.3 → 0.4

data/lib/builtin_contracts.rb

@@ -218,22 +218,23 @@ module Contracts
     end  
   end
 
-  # Takes a class +A+. If argument.is_a? +A+, the contract passes.
-  # Example: <tt>IsA[Numeric]</tt>
-  class IsA < CallableClass
+  # Takes a class +A+. If argument is an object of type +A+, the contract passes.
+  # If it is a subclass of A (or not related to A in any way), it fails.
+  # Example: <tt>Exactly[Numeric]</tt>
+  class Exactly < CallableClass
     def initialize(cls)
       @cls = cls
     end
 
     def valid?(val)
-      val.is_a? @cls
+      val.class == @cls
     end
 
     def to_s
-      "a #{@cls.inspect}"
+      "exactly #{@cls.inspect}"
     end
   end
-
+  
   # Takes a variable number of contracts. The contract
   # passes if all of those contracts fail for the given argument.
   # Example: <tt>Not[nil]</tt>
@@ -313,6 +314,27 @@ module Contracts
     end
   end
 
+  # Use this to specify the Hash characteristics. Takes two contracts,
+  # one for hash keys and one for hash values.
+  # Example: <tt>HashOf[Symbol, String]</tt>
+  class HashOf < CallableClass
+    def initialize(key, value)
+      @key   = key
+      @value = value
+    end
+
+    def valid?(hash)
+      keys_match = hash.keys.map {|k| Contract.valid?(k, @key) }.all?
+      vals_match = hash.values.map {|v| Contract.valid?(v, @value) }.all?
+
+      [keys_match, vals_match].all?
+    end
+
+    def to_s
+      "Hash<#{@key.to_s}, #{@value.to_s}>"
+    end
+  end
+
   # Takes a Contract.
   # The contract passes if the contract passes or the given value is nil.
   # Maybe(foo) is equivalent to Or[foo, nil].

data/lib/contracts.rb

@@ -21,7 +21,7 @@ module Contracts
         if contracts.nil?
           "No contract for #{self}.#{funcname}"
         else
-          "#{funcname} :: #{contracts}"
+          "#{funcname} :: #{contracts[0]}"
         end
       end
     end
@@ -35,7 +35,7 @@ module Contracts
         if contracts.nil?
           "No contract for #{self.class}.#{funcname}"
         else
-          "#{funcname} :: #{contracts}"
+          "#{funcname} :: #{contracts[0]}"
         end
       end
     end
@@ -100,7 +100,14 @@ class Contract < Decorator
       position = file + ":" + line.to_s
     end
    method_name = data[:method].is_a?(Proc) ? "Proc" : data[:method].name
-%{Contract violation:
+
+   header = if data[:return_value]
+     "Contract violation for return value:"
+   else
+     "Contract violation for argument #{data[:arg_pos]} of #{data[:total_args]}:"
+   end
+
+%{#{header}
     Expected: #{expected},
     Actual: #{data[:arg].inspect}
     Value guarded in: #{data[:class]}::#{method_name}
@@ -177,7 +184,7 @@ class Contract < Decorator
       if contract.respond_to? :valid?
         lambda { |arg| contract.valid?(arg) }
       elsif klass == Class
-        lambda { |arg| contract == arg.class }
+        lambda { |arg| arg.is_a?(contract) }
       else
         lambda { |arg| contract == arg }        
       end
@@ -204,14 +211,14 @@ class Contract < Decorator
       j = i < last_index ? i : last_index
       #unless true #@args_contracts[i].valid?(args[i])
       unless @args_validators[j][_args[i]]
-        call_function = Contract.failure_callback({:arg => _args[i], :contract => @args_contracts[j], :class => @klass, :method => @method, :contracts => self})
+        call_function = Contract.failure_callback({:arg => _args[i], :contract => @args_contracts[j], :class => @klass, :method => @method, :contracts => self, :arg_pos => i+1, :total_args => _args.size})
         return unless call_function
       end
     end
 
     if @has_func_contracts
       # contracts on methods
-      contracts.each_with_index do |contract, i|
+      @args_contracts.each_with_index do |contract, i|
         if contract.is_a? Contracts::Func
         args[i] = Contract.new(@klass, args[i], *contract.contracts)
         end
@@ -226,7 +233,7 @@ class Contract < Decorator
       @method.call(*args, &blk)
     end
     unless @ret_validator[result]
-      Contract.failure_callback({:arg => result, :contract => @ret_contract, :class => @klass, :method => @method, :contracts => self})
+      Contract.failure_callback({:arg => result, :contract => @ret_contract, :class => @klass, :method => @method, :contracts => self, :return_value => true})
     end    
     result
   end

data/lib/decorators.rb

@@ -40,12 +40,14 @@ module MethodDecorators
         decorator = klass.new(self, method(name), *args)
         @decorated_methods[:class_methods][name] ||= []
         @decorated_methods[:class_methods][name] << decorator
-        is_private = self.private_methods.include?(name.to_s)
+        # private_instance_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
         decorator = klass.new(self, instance_method(name), *args)
         @decorated_methods[:instance_methods][name] ||= []
         @decorated_methods[:instance_methods][name] << decorator
-        is_private = self.private_instance_methods.include?(name.to_s)
+        # 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
     end
 
@@ -53,9 +55,46 @@ module MethodDecorators
     # 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
+
+=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#{is_class_method ? "" : ".class"}
+        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?
@@ -86,7 +125,9 @@ module MethodDecorators
         result
       end
       #{is_private ? "private #{name.inspect}" : ""}
-    ruby_eval
+        }
+
+    class_eval method_def, __FILE__, __LINE__ + 1
   end    
 
   def decorate(klass, *args)

metadata

@@ -1,12 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: contracts
 version: !ruby/object:Gem::Version 
-  hash: 13
+  hash: 3
   prerelease: 
   segments: 
   - 0
-  - 3
-  version: "0.3"
+  - 4
+  version: "0.4"
 platform: ruby
 authors: 
 - Aditya Bhargava
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-06-07 00:00:00 Z
+date: 2014-05-08 00:00:00 Z
 dependencies: []
 
 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.