contracts 0.12.0 → 0.16.1

data/lib/contracts.rb

@@ -1,3 +1,4 @@
+require "contracts/attrs"
 require "contracts/builtin_contracts"
 require "contracts/decorators"
 require "contracts/errors"
@@ -92,9 +93,9 @@ class Contract < Contracts::Decorator
     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?(Hash) || penultimate_contract.is_a?(Contracts::Builtin::KeywordArgs)
                             else
-                              last_contract.is_a?(Hash)
+                              last_contract.is_a?(Hash) || last_contract.is_a?(Contracts::Builtin::KeywordArgs)
                             end
     # ===
 
@@ -115,22 +116,57 @@ class Contract < Contracts::Decorator
   # 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)
-    expected = Contracts::Formatters::Expected.new(data[:contract]).contract
-    position = Contracts::Support.method_position(data[:method])
+    indent_amount = 8
     method_name = Contracts::Support.method_name(data[:method])
 
+    # Header
     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}
-        With Contract: #{data[:contracts]}
-        At: #{position} }
+    # Expected
+    expected_prefix = "Expected: "
+    expected_value = Contracts::Support.indent_string(
+      Contracts::Formatters::Expected.new(data[:contract]).contract.pretty_inspect,
+      expected_prefix.length
+    ).strip
+    expected_line = expected_prefix + expected_value + ","
+
+    # Actual
+    actual_prefix = "Actual: "
+    actual_value = Contracts::Support.indent_string(
+      data[:arg].pretty_inspect,
+      actual_prefix.length
+    ).strip
+    actual_line = actual_prefix + actual_value
+
+    # Value guarded in
+    value_prefix = "Value guarded in: "
+    value_value = "#{data[:class]}::#{method_name}"
+    value_line = value_prefix + value_value
+
+    # Contract
+    contract_prefix = "With Contract: "
+    contract_value = data[:contracts].to_s
+    contract_line = contract_prefix + contract_value
+
+    # Position
+    position_prefix = "At: "
+    position_value = Contracts::Support.method_position(data[:method])
+    position_line = position_prefix + position_value
+
+    header +
+      "\n" +
+      Contracts::Support.indent_string(
+        [expected_line,
+         actual_line,
+         value_line,
+         contract_line,
+         position_line].join("\n"),
+        indent_amount
+      )
   end
 
   # Callback for when a contract fails. By default it raises
@@ -215,9 +251,9 @@ class Contract < Contracts::Decorator
   # 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[-2].is_a?(Hash)
+    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[-1].is_a?(Hash)
+    elsif (args_contracts[-1].is_a?(Hash) || args_contracts[-1].is_a?(Contracts::Builtin::KeywordArgs)) && !args[-1].is_a?(Hash)
       args << {}
     end
     true

data/lib/contracts/attrs.rb

@@ -0,0 +1,24 @@
+module Contracts
+  module Attrs
+    def attr_reader_with_contract(*names, contract)
+      names.each do |name|
+        Contract Contracts::None => contract
+        attr_reader(name)
+      end
+    end
+
+    def attr_writer_with_contract(*names, contract)
+      names.each do |name|
+        Contract contract => contract
+        attr_writer(name)
+      end
+    end
+
+    def attr_accessor_with_contract(*names, contract)
+      attr_reader_with_contract(*names, contract)
+      attr_writer_with_contract(*names, contract)
+    end
+  end
+
+  include Attrs
+end

data/lib/contracts/builtin_contracts.rb

@@ -41,13 +41,27 @@ module Contracts
       end
     end
 
-    # Check that an argument is a natural number.
+    # Check that an argument is an +Integer+.
+    class Int
+      def self.valid? val
+        val && val.is_a?(Integer)
+      end
+    end
+
+    # Check that an argument is a natural number (includes zero).
     class Nat
       def self.valid? val
         val && val.is_a?(Integer) && val >= 0
       end
     end
 
+    # Check that an argument is a positive natural number (excludes zero).
+    class NatPos
+      def self.valid? val
+        val && val.is_a?(Integer) && val > 0
+      end
+    end
+
     # Passes for any argument.
     class Any
       def self.valid? val
@@ -379,6 +393,26 @@ module Contracts
       end
     end
 
+    # Use this to specify the Hash characteristics. This contracts fails
+    # if there are any extra keys that don't have contracts on them.
+    # Example: <tt>StrictHash[{ a: String, b: Bool }]</tt>
+    class StrictHash < CallableClass
+      attr_reader :contract_hash
+
+      def initialize(contract_hash)
+        @contract_hash = contract_hash
+      end
+
+      def valid?(arg)
+        return false unless arg.is_a?(Hash)
+        return false unless arg.keys.sort.eql?(contract_hash.keys.sort)
+
+        contract_hash.all? do |key, contract|
+          contract_hash.key?(key) && Contract.valid?(arg[key], contract)
+        end
+      end
+    end
+
     # Use this for specifying contracts for keyword arguments
     # Example: <tt>KeywordArgs[ e: Range, f: Optional[Num] ]</tt>
     class KeywordArgs < CallableClass
@@ -387,6 +421,7 @@ module Contracts
       end
 
       def valid?(hash)
+        return false unless hash.is_a?(Hash)
         return false unless hash.keys - options.keys == []
         options.all? do |key, contract|
           Optional._valid?(hash, key, contract)
@@ -406,6 +441,30 @@ module Contracts
       attr_reader :options
     end
 
+    # Use this for specifying contracts for class arguments
+    # Example: <tt>DescendantOf[ e: Range, f: Optional[Num] ]</tt>
+    class DescendantOf < CallableClass
+      def initialize(parent_class)
+        @parent_class = parent_class
+      end
+
+      def valid?(given_class)
+        given_class.is_a?(Class) && given_class.ancestors.include?(parent_class)
+      end
+
+      def to_s
+        "DescendantOf[#{parent_class}]"
+      end
+
+      def inspect
+        to_s
+      end
+
+      private
+
+      attr_reader :parent_class
+    end
+
     # Use this for specifying optional keyword argument
     # Example: <tt>Optional[Num]</tt>
     class Optional < CallableClass

data/lib/contracts/call_with.rb

@@ -1,6 +1,10 @@
 module Contracts
   module CallWith
     def call_with(this, *args, &blk)
+      call_with_inner(false, this, *args, &blk)
+    end
+
+    def call_with_inner(returns, this, *args, &blk)
       args << blk if blk
 
       # Explicitly append blk=nil if nil != Proc contract violation anticipated
@@ -16,17 +20,21 @@ module Contracts
         validator = @args_validators[i]
 
         unless validator && validator[arg]
-          return unless Contract.failure_callback(:arg => arg,
-                                                  :contract => contract,
-                                                  :class => klass,
-                                                  :method => method,
-                                                  :contracts => self,
-                                                  :arg_pos => i+1,
-                                                  :total_args => args.size,
-                                                  :return_value => false)
+          data = {:arg => arg,
+                  :contract => contract,
+                  :class => klass,
+                  :method => method,
+                  :contracts => self,
+                  :arg_pos => i+1,
+                  :total_args => args.size,
+                  :return_value => false}
+          return ParamContractError.new("as return value", data) if returns
+          return unless Contract.failure_callback(data)
         end
 
-        if contract.is_a?(Contracts::Func)
+        if contract.is_a?(Contracts::Func) && blk && !nil_block_appended
+          blk = Contract.new(klass, arg, *contract.contracts)
+        elsif contract.is_a?(Contracts::Func)
           args[i] = Contract.new(klass, arg, *contract.contracts)
         end
       end
@@ -72,8 +80,11 @@ module Contracts
                  # proc, block, lambda, etc
                  method.call(*args, &blk)
                else
-                 # original method name referrence
-                 method.send_to(this, *args, &blk)
+                 # original method name reference
+                 # Don't reassign blk, else Travis CI shows "stack level too deep".
+                 target_blk = blk
+                 target_blk = lambda { |*params| blk.call(*params) } if blk && blk.is_a?(Contract)
+                 method.send_to(this, *args, &target_blk)
                end
 
       unless @ret_validator[result]

data/lib/contracts/core.rb

@@ -9,8 +9,6 @@ module Contracts
     end
 
     def self.common(base)
-      return if base.respond_to?(:Contract)
-
       base.extend(MethodDecorators)
 
       base.instance_eval do

data/lib/contracts/decorators.rb

@@ -4,6 +4,11 @@ module Contracts
       Engine.apply(klass)
     end
 
+    def inherited(subclass)
+      Engine.fetch_from(subclass).set_eigenclass_owner
+      super
+    end
+
     def method_added(name)
       MethodHandler.new(name, false, self).handle
       super

data/lib/contracts/engine/eigenclass.rb

@@ -18,6 +18,10 @@ module Contracts
         return Engine.fetch_from(eigenclass) if Engine.applied?(eigenclass)
 
         Target.new(eigenclass).apply(Eigenclass)
+        eigenclass.extend(MethodDecorators)
+        # FIXME; this should detect what user uses `include Contracts` or
+        # `include Contracts;;Core`
+        eigenclass.send(:include, Contracts)
         Engine.fetch_from(owner).set_eigenclass_owner
         Engine.fetch_from(eigenclass)
       end

data/lib/contracts/engine/target.rb

@@ -53,6 +53,8 @@ module Contracts
 
         self.class.new(eigenclass).apply(Eigenclass)
         eigenclass.extend(MethodDecorators)
+        # FIXME; this should detect what user uses `include Contracts` or
+        # `include Contracts;;Core`
         eigenclass.send(:include, Contracts)
       end
 

data/lib/contracts/formatters.rb

@@ -1,3 +1,5 @@
+require "pp"
+
 module Contracts
   # A namespace for classes related to formatting.
   module Formatters
@@ -25,13 +27,13 @@ module Contracts
         @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
       end
 
       # Formats Array contracts.
       def array_contract(array)
         @full = true
-        array.map { |v| InspectWrapper.create(contract(v), @full) }.inspect
+        array.map { |v| InspectWrapper.create(contract(v), @full) }
       end
     end
 

data/lib/contracts/method_handler.rb

@@ -125,31 +125,23 @@ module Contracts
         # function. Otherwise we return the result.
         # If we run out of functions, we raise the last error, but
         # convert it to_contract_error.
-        success = false
-        i = 0
-        result = nil
+
         expected_error = decorated_methods[0].failure_exception
+        last_error = nil
 
-        until success
-          decorated_method = decorated_methods[i]
-          i += 1
-          begin
-            success = true
-            result = decorated_method.call_with(self, *args, &blk)
-          rescue expected_error => error
-            success = false
-            unless decorated_methods[i]
-              begin
-                ::Contract.failure_callback(error.data, false)
-              rescue expected_error => final_error
-                raise final_error.to_contract_error
-              end
-            end
-          end
+        decorated_methods.each do |decorated_method|
+          result = decorated_method.call_with_inner(true, self, *args, &blk)
+          return result unless result.is_a?(ParamContractError)
+          last_error = result
         end
 
-        # Return the result of successfully called method
-        result
+        begin
+          if ::Contract.failure_callback(last_error.data, false)
+            decorated_methods.last.call_with_inner(false, self, *args, &blk)
+          end
+        rescue expected_error => final_error
+          raise final_error.to_contract_error
+        end
       end
     end
 
@@ -157,7 +149,7 @@ module Contracts
       return if decorators.size == 1
 
       fail %{
-Oops, it looks like method '#{name}' has multiple contracts:
+Oops, it looks like method '#{method_name}' has multiple contracts:
 #{decorators.map { |x| x[1][0].inspect }.join("\n")}
 
 Did you accidentally put more than one contract on a single function, like so?

data/lib/contracts/support.rb

@@ -4,14 +4,10 @@ module Contracts
       def method_position(method)
         return method.method_position if method.is_a?(MethodReference)
 
-        if RUBY_VERSION =~ /^1\.8/
-          if method.respond_to?(:__file__)
-            method.__file__ + ":" + method.__line__.to_s
-          else
-            method.inspect
-          end
+        file, line = method.source_location
+        if file.nil? || line.nil?
+          ""
         else
-          file, line = method.source_location
           file + ":" + line.to_s
         end
       end
@@ -34,8 +30,7 @@ module Contracts
       end
 
       def eigenclass_hierarchy_supported?
-        return false if RUBY_PLATFORM == "java" && RUBY_VERSION.to_f < 2.0
-        RUBY_VERSION.to_f > 1.8
+        RUBY_PLATFORM != "java" || RUBY_VERSION.to_f >= 2.0
       end
 
       def eigenclass_of(target)
@@ -47,6 +42,13 @@ module Contracts
           target <= eigenclass_of(Object)
       end
 
+      def indent_string(string, amount)
+        string.gsub(
+          /^(?!$)/,
+          (string[/^[ \t]/] || " ") * amount
+        )
+      end
+
       private
 
       # Module eigenclass can be detected by its ancestor chain

data/lib/contracts/version.rb

@@ -1,3 +1,3 @@
 module Contracts
-  VERSION = "0.12.0"
+  VERSION = "0.16.1"
 end

data/spec/attrs_spec.rb

@@ -0,0 +1,119 @@
+RSpec.describe "Contracts:" do
+  describe "Attrs:" do
+    class Person
+      include Contracts::Core
+      include Contracts::Attrs
+      include Contracts::Builtin
+
+      def initialize(name)
+        @name_r = name
+        @name_w = name
+        @name_rw = name
+
+        @name_r_2 = name
+        @name_w_2 = name
+        @name_rw_2 = name
+      end
+
+      attr_reader_with_contract :name_r, :name_r_2, String
+      attr_writer_with_contract :name_w, :name_w_2, String
+      attr_accessor_with_contract :name_rw, :name_rw_2, String
+    end
+
+    context "attr_reader_with_contract" do
+      it "getting valid type" do
+        expect(Person.new("bob").name_r)
+          .to(eq("bob"))
+      end
+
+      it "getting invalid type" do
+        expect { Person.new(1.3).name_r }
+          .to(raise_error(ReturnContractError))
+      end
+
+      it "getting valid type for second val" do
+        expect(Person.new("bob").name_r_2)
+          .to(eq("bob"))
+      end
+
+      it "getting invalid type for second val" do
+        expect { Person.new(1.3).name_r_2 }
+          .to(raise_error(ReturnContractError))
+      end
+
+      it "setting" do
+        expect { Person.new("bob").name_r = "alice" }
+          .to(raise_error(NoMethodError))
+      end
+    end
+
+    context "attr_writer_with_contract" do
+      it "getting" do
+        expect { Person.new("bob").name_w }
+          .to(raise_error(NoMethodError))
+      end
+
+      it "setting valid type" do
+        expect(Person.new("bob").name_w = "alice")
+          .to(eq("alice"))
+      end
+
+      it "setting invalid type" do
+        expect { Person.new("bob").name_w = 1.2 }
+          .to(raise_error(ParamContractError))
+      end
+
+      it "setting valid type for second val" do
+        expect(Person.new("bob").name_w_2 = "alice")
+          .to(eq("alice"))
+      end
+
+      it "setting invalid type for second val" do
+        expect { Person.new("bob").name_w_2 = 1.2 }
+          .to(raise_error(ParamContractError))
+      end
+    end
+
+    context "attr_accessor_with_contract" do
+      it "getting valid type" do
+        expect(Person.new("bob").name_rw)
+          .to(eq("bob"))
+      end
+
+      it "getting invalid type" do
+        expect { Person.new(1.2).name_rw }
+          .to(raise_error(ReturnContractError))
+      end
+
+      it "setting valid type" do
+        expect(Person.new("bob").name_rw = "alice")
+          .to(eq("alice"))
+      end
+
+      it "setting invalid type" do
+        expect { Person.new("bob").name_rw = 1.2 }
+          .to(raise_error(ParamContractError))
+      end
+
+      it "getting valid type for second val" do
+        expect(Person.new("bob").name_rw_2)
+          .to(eq("bob"))
+      end
+
+      it "getting invalid type for second val" do
+        expect { Person.new(1.2).name_rw_2 }
+          .to(raise_error(ReturnContractError))
+      end
+
+      it "setting valid type for second val" do
+        expect(Person.new("bob").name_rw_2 = "alice")
+          .to(eq("alice"))
+      end
+
+      it "setting invalid type for second val" do
+        expect { Person.new("bob").name_rw_2 = 1.2 }
+          .to(raise_error(ParamContractError))
+      end
+    end
+  end
+end