contracts 0.7 → 0.8

data/lib/contracts/decorators.rb

@@ -10,9 +10,7 @@ module Contracts
 
     module EigenclassWithOwner
       def self.lift(eigenclass)
-        unless with_owner?(eigenclass)
-          raise Contracts::ContractsNotIncluded
-        end
+        fail Contracts::ContractsNotIncluded unless with_owner?(eigenclass)
 
         eigenclass
       end
@@ -51,18 +49,14 @@ module Contracts
       decorators = fetch_decorators
       return if decorators.empty?
 
-      @decorated_methods ||= {:class_methods => {}, :instance_methods => {}}
+      @decorated_methods ||= { :class_methods => {}, :instance_methods => {} }
 
       if is_class_method
         method_reference = SingletonMethodReference.new(name, 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 = MethodReference.new(name, 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] ||= []
@@ -79,9 +73,7 @@ module Contracts
       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
+        @decorated_methods[method_type][name].each(&:pattern_match!)
 
         pattern_matching = true
       end
@@ -95,42 +87,40 @@ module Contracts
       # 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
+      # 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}`.
 
       current = self
       method_reference.make_definition(self) do |*args, &blk|
@@ -140,7 +130,7 @@ Here's why: Suppose you have this code:
           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."
+          fail "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[method_type][name]
 
@@ -151,7 +141,7 @@ Here's why: Suppose you have this code:
         i = 0
         result = nil
         expected_error = methods[0].failure_exception
-        while !success
+        until success
           method = methods[i]
           i += 1
           begin
@@ -170,12 +160,10 @@ Here's why: Suppose you have this code:
         end
         result
       end
-
-      method_reference.make_private(self) if is_private
     end
 
     def decorate(klass, *args)
-      if self.singleton_class?
+      if Support.eigenclass? self
         return EigenclassWithOwner.lift(self).owner_class.decorate(klass, *args)
       end
 
@@ -189,7 +177,7 @@ Here's why: Suppose you have this code:
     class << self; attr_accessor :decorators; end
 
     def self.inherited(klass)
-      name = klass.name.gsub(/^./) {|m| m.downcase}
+      name = klass.name.gsub(/^./) { |m| m.downcase }
 
       return if name =~ /^[^A-Za-z_]/ || name =~ /[^0-9A-Za-z_]/
 

data/lib/contracts/eigenclass.rb

@@ -1,6 +1,5 @@
 module Contracts
   module Eigenclass
-
     def self.extended(eigenclass)
       return if eigenclass.respond_to?(:owner_class=)
 
@@ -10,13 +9,11 @@ module Contracts
     end
 
     def self.lift(base)
-      return NullEigenclass if base.singleton_class?
+      return NullEigenclass if Support.eigenclass? base
 
-      eigenclass = base.singleton_class
+      eigenclass = Support.eigenclass_of base
 
-      unless eigenclass.respond_to?(:owner_class=)
-        eigenclass.extend(Eigenclass)
-      end
+      eigenclass.extend(Eigenclass) unless eigenclass.respond_to?(:owner_class=)
 
       unless eigenclass.respond_to?(:pop_decorators)
         eigenclass.extend(MethodDecorators)
@@ -37,6 +34,5 @@ module Contracts
         []
       end
     end
-
   end
 end

data/lib/contracts/errors.rb

@@ -58,7 +58,7 @@ module Contracts
     attr_reader :message
     alias_method :to_s, :message
 
-    def initialize(message=DEFAULT_MESSAGE)
+    def initialize(message = DEFAULT_MESSAGE)
       @message = message
     end
   end

data/lib/contracts/formatters.rb

@@ -0,0 +1,134 @@
+module Contracts
+  # A namespace for classes related to formatting.
+  module Formatters
+    # Used to format contracts for the `Expected:` field of error output.
+    class Expected
+      # @param full [Boolean] if false only unique `to_s` values will be output,
+      #   non unique values become empty string.
+      def initialize(contract, full = true)
+        @contract, @full = contract, full
+      end
+
+      # Formats any type of Contract.
+      def contract(contract = @contract)
+        if contract.is_a?(Hash)
+          hash_contract(contract)
+        elsif contract.is_a?(Array)
+          array_contract(contract)
+        else
+          InspectWrapper.create(contract, @full)
+        end
+      end
+
+      # Formats Hash contracts.
+      def hash_contract(hash)
+        @full = true # Complex values output completely, overriding @full
+        hash.inject({}) do |repr, (k, v)|
+          repr.merge(k => InspectWrapper.create(contract(v), @full))
+        end.inspect
+      end
+
+      # Formats Array contracts.
+      def array_contract(array)
+        @full = true
+        array.map { |v| InspectWrapper.create(contract(v), @full) }.inspect
+      end
+    end
+
+    # A wrapper class to produce correct inspect behaviour for different
+    # contract values - constants, Class contracts, instance contracts etc.
+    module InspectWrapper
+      # InspectWrapper is a factory, will never be an instance
+      # @return [ClassInspectWrapper, ObjectInspectWrapper]
+      def self.create(value, full = true)
+        if value.class == Class
+          ClassInspectWrapper
+        else
+          ObjectInspectWrapper
+        end.new(value, full)
+      end
+
+      # @param full [Boolean] if false only unique `to_s` values will be output,
+      #   non unique values become empty string.
+      def initialize(value, full)
+        @value, @full = value, full
+      end
+
+      # Inspect different types of contract values.
+      # Contracts module prefix will be removed from classes.
+      # Custom to_s messages will be wrapped in round brackets to differentiate
+      # from standard Strings.
+      # Primitive values e.g. 42, true, nil will be left alone.
+      def inspect
+        return "" unless full?
+        return @value.inspect if empty_val?
+        return @value.to_s if plain?
+        return delim(@value.to_s) if useful_to_s?
+        useful_inspect
+      end
+
+      def delim(value)
+        @full ? "(#{value})" : "#{value}"
+      end
+
+      # Eliminates eronious quotes in output that plain inspect includes.
+      def to_s
+        inspect
+      end
+
+      private
+
+      def empty_val?
+        @value.nil? || @value == ""
+      end
+
+      def full?
+        @full ||
+          @value.is_a?(Hash) || @value.is_a?(Array) ||
+          (!plain? && useful_to_s?)
+      end
+
+      def plain?
+        # Not a type of contract that can have a custom to_s defined
+        !@value.is_a?(CallableClass) && @value.class != Class
+      end
+
+      def useful_to_s?
+        # Useless to_s value or no custom to_s behavious defined
+        !empty_to_s? && custom_to_s?
+      end
+
+      def empty_to_s?
+        @value.to_s.empty?
+      end
+
+      def strip_prefix(val)
+        val.gsub(/^Contracts::/, "")
+      end
+    end
+
+    class ClassInspectWrapper
+      include InspectWrapper
+
+      def custom_to_s?
+        @value.to_s != @value.name
+      end
+
+      def useful_inspect
+        strip_prefix(empty_to_s? ? @value.name : @value.inspect)
+      end
+    end
+
+    class ObjectInspectWrapper
+      include InspectWrapper
+
+      def custom_to_s?
+        !@value.to_s.match(/#\<\w+:.+\>/)
+      end
+
+      def useful_inspect
+        strip_prefix(empty_to_s? ? @value.class.name : @value.inspect)
+      end
+    end
+  end
+end

data/lib/contracts/invariants.rb

@@ -23,7 +23,7 @@ module Contracts
     end
 
     module InvariantExtension
-      def Invariant(name, &condition)
+      def invariant(name, &condition)
         return if ENV["NO_CONTRACTS"]
 
         invariants << Invariant.new(self, name, &condition)
@@ -53,17 +53,16 @@ module Contracts
       end
 
       def self.failure_callback(data)
-        raise InvariantError, failure_msg(data)
+        fail InvariantError, failure_msg(data)
       end
 
       def self.failure_msg(data)
-%{Invariant violation:
-    Expected: #{data[:expected]}
-    Actual: #{data[:actual]}
-    Value guarded in: #{data[:target].class}::#{Support.method_name(data[:method])}
-    At: #{Support.method_position(data[:method])}}
+        %{Invariant violation:
+            Expected: #{data[:expected]}
+            Actual: #{data[:actual]}
+            Value guarded in: #{data[:target].class}::#{Support.method_name(data[:method])}
+            At: #{Support.method_position(data[:method])}}
       end
     end
-
   end
 end

data/lib/contracts/method_reference.rb

@@ -2,7 +2,6 @@ module Contracts
   # MethodReference represents original method reference that was
   # decorated by contracts.ruby. Used for instance methods.
   class MethodReference
-
     attr_reader :name
 
     # name - name of the method
@@ -19,13 +18,11 @@ module Contracts
 
     # Makes a method re-definition in proper way
     def make_definition(this, &blk)
+      is_private = private?(this)
+      is_protected = protected?(this)
       alias_target(this).send(:define_method, name, &blk)
-    end
-
-    # Makes a method private
-    def make_private(this)
-      original_name = name
-      alias_target(this).class_eval { private original_name }
+      make_private(this) if is_private
+      make_protected(this) if is_protected
     end
 
     # Aliases original method to a special unique name, which is known
@@ -48,6 +45,26 @@ module Contracts
 
     private
 
+    # Makes a method private
+    def make_private(this)
+      original_name = name
+      alias_target(this).class_eval { private original_name }
+    end
+
+    def private?(this)
+      this.private_instance_methods.map(&:to_sym).include?(name)
+    end
+
+    def protected?(this)
+      this.protected_instance_methods.map(&:to_sym).include?(name)
+    end
+
+    # Makes a method protected
+    def make_protected(this)
+      original_name = name
+      alias_target(this).class_eval { protected original_name }
+    end
+
     # Returns alias target for instance methods, subject to be
     # overriden in subclasses.
     def alias_target(this)
@@ -61,16 +78,23 @@ module Contracts
     def construct_unique_name
       :"__contracts_ruby_original_#{name}_#{Support.unique_id}"
     end
-
   end
 
   # The same as MethodReference, but used for singleton methods.
   class SingletonMethodReference < MethodReference
     private
 
+    def private?(this)
+      this.private_methods.map(&:to_sym).include?(name)
+    end
+
+    def protected?(this)
+      this.protected_methods.map(&:to_sym).include?(name)
+    end
+
     # Return alias target for singleton methods.
     def alias_target(this)
-      this.singleton_class
+      Support.eigenclass_of this
     end
   end
 end

data/lib/contracts/support.rb

@@ -1,8 +1,7 @@
 module Contracts
   module Support
-
     def self.method_position(method)
-      return method.method_position if MethodReference === method
+      return method.method_position if method.is_a?(MethodReference)
 
       if RUBY_VERSION =~ /^1\.8/
         if method.respond_to?(:__file__)
@@ -26,7 +25,7 @@ module Contracts
     #    Contracts::Support.unique_id   # => "i53u6tiw5hbo"
     def self.unique_id
       # Consider using SecureRandom.hex here, and benchmark which one is better
-      (Time.now.to_f * 1000).to_i.to_s(36) + rand(1000000).to_s(36)
+      (Time.now.to_f * 1000).to_i.to_s(36) + rand(1_000_000).to_s(36)
     end
 
     def self.eigenclass_hierarchy_supported?
@@ -34,5 +33,12 @@ module Contracts
       RUBY_VERSION.to_f > 1.8
     end
 
+    def self.eigenclass_of(target)
+      class << target; self; end
+    end
+
+    def self.eigenclass?(target)
+      target <= eigenclass_of(Object)
+    end
   end
 end