contracts 0.9 → 0.10

data/lib/contracts/builtin_contracts.rb

@@ -29,21 +29,21 @@ module Contracts
   # Check that an argument is a positive number.
   class Pos
     def self.valid? val
-      val > 0
+      val && val.is_a?(Numeric) && val > 0
     end
   end
 
   # Check that an argument is a negative number.
   class Neg
     def self.valid? val
-      val < 0
+      val && val.is_a?(Numeric) && val < 0
     end
   end
 
   # Check that an argument is a natural number.
   class Nat
     def self.valid? val
-      val && val >= 0 && val.integer?
+      val && val.is_a?(Integer) && val >= 0
     end
   end
 
@@ -310,6 +310,24 @@ module Contracts
     end
   end
 
+  # Use this to specify a Range object of a particular datatype.
+  # Example: <tt>RangeOf[Nat]</tt>, <tt>RangeOf[Date]</tt>, ...
+  class RangeOf < CallableClass
+    def initialize(contract)
+      @contract = contract
+    end
+
+    def valid?(val)
+      val.is_a?(Range) &&
+        Contract.valid?(val.first, @contract) &&
+        Contract.valid?(val.last,  @contract)
+    end
+
+    def to_s
+      "a range of #{@contract}"
+    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>
@@ -345,6 +363,81 @@ module Contracts
     end
   end
 
+  # Use this for specifying contracts for keyword arguments
+  # Example: <tt>KeywordArgs[ e: Range, f: Optional[Num] ]</tt>
+  class KeywordArgs < CallableClass
+    def initialize(options)
+      @options = options
+    end
+
+    def valid?(hash)
+      options.all? do |key, contract|
+        Optional._valid?(hash, key, contract)
+      end
+    end
+
+    def to_s
+      "KeywordArgs[#{options}]"
+    end
+
+    def inspect
+      to_s
+    end
+
+    private
+
+    attr_reader :options
+  end
+
+  # Use this for specifying optional keyword argument
+  # Example: <tt>Optional[Num]</tt>
+  class Optional < CallableClass
+    UNABLE_TO_USE_OUTSIDE_OF_OPT_HASH =
+      "Unable to use Optional contract outside of KeywordArgs contract"
+
+    def self._valid?(hash, key, contract)
+      return Contract.valid?(hash[key], contract) unless contract.is_a?(Optional)
+      contract.within_opt_hash!
+      !hash.key?(key) || Contract.valid?(hash[key], contract)
+    end
+
+    def initialize(contract)
+      @contract = contract
+      @within_opt_hash = false
+    end
+
+    def within_opt_hash!
+      @within_opt_hash = true
+      self
+    end
+
+    def valid?(value)
+      ensure_within_opt_hash
+      Contract.valid?(value, contract)
+    end
+
+    def to_s
+      "Optional[#{formatted_contract}]"
+    end
+
+    def inspect
+      to_s
+    end
+
+    private
+
+    attr_reader :contract, :within_opt_hash
+
+    def ensure_within_opt_hash
+      return if within_opt_hash
+      fail ArgumentError, UNABLE_TO_USE_OUTSIDE_OF_OPT_HASH
+    end
+
+    def formatted_contract
+      Formatters::InspectWrapper.create(contract)
+    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].
@@ -352,6 +445,10 @@ module Contracts
     def initialize(*vals)
       super(*(vals + [nil]))
     end
+
+    def include_proc?
+      @vals.include? Proc
+    end
   end
 
   # Used to define contracts on functions passed in as arguments.

data/lib/contracts/call_with.rb

@@ -0,0 +1,96 @@
+module Contracts
+  module CallWith
+    def call_with(this, *args, &blk)
+      args << blk if blk
+
+      # Explicitly append blk=nil if nil != Proc contract violation anticipated
+      maybe_append_block!(args, blk)
+
+      # Explicitly append options={} if Hash contract is present
+      maybe_append_options!(args, blk)
+
+      # Loop forward validating the arguments up to the splat (if there is one)
+      (@args_contract_index || args.size).times do |i|
+        contract = args_contracts[i]
+        arg = args[i]
+        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)
+        end
+
+        if contract.is_a?(Contracts::Func)
+          args[i] = Contract.new(klass, arg, *contract.contracts)
+        end
+      end
+
+      # If there is a splat loop backwards to the lower index of the splat
+      # Once we hit the splat in this direction set its upper index
+      # Keep validating but use this upper index to get the splat validator.
+      if @args_contract_index
+        splat_upper_index = @args_contract_index
+        (args.size - @args_contract_index).times do |i|
+          arg = args[args.size - 1 - i]
+
+          if args_contracts[args_contracts.size - 1 - i].is_a?(Contracts::Args)
+            splat_upper_index = i
+          end
+
+          # Each arg after the spat is found must use the splat validator
+          j = i < splat_upper_index ? i : splat_upper_index
+          contract = args_contracts[args_contracts.size - 1 - j]
+          validator = @args_validators[args_contracts.size - 1 - j]
+
+          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)
+          end
+
+          if contract.is_a?(Contracts::Func)
+            args[args.size - 1 - i] = Contract.new(klass, arg, *contract.contracts)
+          end
+        end
+      end
+
+      # If we put the block into args for validating, restore the args
+      args.slice!(-1) if blk
+      result = if method.respond_to?(:call)
+                 # proc, block, lambda, etc
+                 method.call(*args, &blk)
+               else
+                 # original method name referrence
+                 method.send_to(this, *args, &blk)
+               end
+
+      unless @ret_validator[result]
+        Contract.failure_callback(:arg => result,
+                                  :contract => ret_contract,
+                                  :class => klass,
+                                  :method => method,
+                                  :contracts => self,
+                                  :return_value => true)
+      end
+
+      this.verify_invariants!(method) if this.respond_to?(:verify_invariants!)
+
+      if ret_contract.is_a?(Contracts::Func)
+        result = Contract.new(klass, result, *ret_contract.contracts)
+      end
+
+      result
+    end
+  end
+end

data/lib/contracts/decorators.rb

@@ -1,208 +1,18 @@
 module Contracts
   module MethodDecorators
     def self.extended(klass)
-      return if klass.respond_to?(:decorated_methods=)
-
-      class << klass
-        attr_accessor :decorated_methods
-      end
-    end
-
-    module EigenclassWithOwner
-      def self.lift(eigenclass)
-        fail Contracts::ContractsNotIncluded unless with_owner?(eigenclass)
-
-        eigenclass
-      end
-
-      private
-
-      def self.with_owner?(eigenclass)
-        eigenclass.respond_to?(:owner_class) && eigenclass.owner_class
-      end
+      Engine.apply(klass)
     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)
-      common_method_added name, false
+      MethodHandler.new(name, false, self).handle
       super
     end
 
     def singleton_method_added(name)
-      common_method_added name, true
+      MethodHandler.new(name, true, self).handle
       super
     end
-
-    def pop_decorators
-      Array(@decorators).tap { @decorators = nil }
-    end
-
-    def fetch_decorators
-      pop_decorators + Eigenclass.lift(self).pop_decorators
-    end
-
-    def common_method_added(name, is_class_method)
-      decorators = fetch_decorators
-      return if decorators.empty?
-
-      @decorated_methods ||= { :class_methods => {}, :instance_methods => {} }
-
-      if is_class_method
-        method_reference = SingletonMethodReference.new(name, method(name))
-        method_type = :class_methods
-      else
-        method_reference = MethodReference.new(name, instance_method(name))
-        method_type = :instance_methods
-      end
-
-      @decorated_methods[method_type][name] ||= []
-
-      unless decorators.size == 1
-        fail %{
-Oops, it looks like 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?
-
-Contract String => String
-Contract Num => String
-def foo x
-end
-
-If you did NOT, then you have probably discovered a bug in this library.
-Please file it along with the relevant code at:
-https://github.com/egonSchiele/contracts.ruby/issues
-        }
-      end
-
-      pattern_matching = false
-      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.
-        # We assume here that the decorator (klass) responds to .new
-        decorator = klass.new(self, method_reference, *args)
-        new_args_contract = decorator.args_contracts
-        matched = @decorated_methods[method_type][name].select do |contract|
-          contract.args_contracts == new_args_contract
-        end
-        unless matched.empty?
-          fail ContractError.new(%{
-It looks like you are trying to use pattern-matching, but
-multiple definitions for function '#{name}' have the same
-contract for input parameters:
-
-#{(matched + [decorator]).map(&:to_s).join("\n")}
-
-Each definition needs to have a different contract for the parameters.
-          }, {})
-        end
-        @decorated_methods[method_type][name] << decorator
-        pattern_matching ||= decorator.pattern_match?
-      end
-
-      if @decorated_methods[method_type][name].any? { |x| x.method != method_reference }
-        @decorated_methods[method_type][name].each(&:pattern_match!)
-
-        pattern_matching = true
-      end
-
-      method_reference.make_alias(self)
-
-      return if ENV["NO_CONTRACTS"] && !pattern_matching
-
-      # 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.
-
-      # 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 String
-      #       def to_s
-      #         "Foo"
-      #       end
-      #     end
-      #
-      #     class Bar < Foo
-      #       Contract 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|
-        ancestors = current.ancestors
-        ancestors.shift # first one is just the class itself
-        while current && !current.respond_to?(:decorated_methods) || current.decorated_methods.nil?
-          current = ancestors.shift
-        end
-        if !current.respond_to?(:decorated_methods) || current.decorated_methods.nil?
-          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]
-
-        # this adds support for overloading methods. Here we go through each method and call it with the arguments.
-        # If we get a ContractError, we move to the next function. Otherwise we return the result.
-        # If we run out of functions, we raise the last ContractError.
-        success = false
-        i = 0
-        result = nil
-        expected_error = methods[0].failure_exception
-        until success
-          method = methods[i]
-          i += 1
-          begin
-            success = true
-            result = method.call_with(self, *args, &blk)
-          rescue expected_error => error
-            success = false
-            unless methods[i]
-              begin
-                ::Contract.failure_callback(error.data, false)
-              rescue expected_error => final_error
-                raise final_error.to_contract_error
-              end
-            end
-          end
-        end
-        result
-      end
-    end
-
-    def decorate(klass, *args)
-      if Support.eigenclass? self
-        return EigenclassWithOwner.lift(self).owner_class.decorate(klass, *args)
-      end
-
-      @decorators ||= []
-      @decorators << [klass, args]
-    end
   end
 
   class Decorator
@@ -220,7 +30,7 @@ Each definition needs to have a different contract for the parameters.
       # inside, `decorate` is called with those params.
       MethodDecorators.module_eval <<-ruby_eval, __FILE__, __LINE__ + 1
         def #{klass}(*args, &blk)
-          decorate(#{klass}, *args, &blk)
+          ::Contracts::Engine.fetch_from(self).decorate(#{klass}, *args, &blk)
         end
       ruby_eval
     end