Merge pull request #159 from waterlink/feature/override_validator

egonSchiele · egonSchiele · commit 8c1c5a6a3df8 · 2015-06-09T16:00:31.000-07:00
Refactor validator strategies + Add ability to override validators
diff --git a/TUTORIAL.md b/TUTORIAL.md
@@ -509,6 +509,36 @@ end
 
 If your failure callback returns `false`, the method that the contract is guarding will not be called (the default behaviour).
 
+## Providing your own custom validators
+
+This can be done with `Contract.override_validator`:
+
+```ruby
+# Make contracts accept all RSpec doubles
+Contract.override_validator(:class) do |contract|
+  lambda do |arg|
+    arg.is_a?(RSpec::Mocks::Double) ||
+      arg.is_a?(contract)
+  end
+end
+```
+
+The block you provide should always return lambda accepting one argument - validated argument. Block itself accepts contract as an argument.
+
+Possible validator overrides:
+
+- `override_validator(MyCustomContract)` - allows to add some special behaviour for custom contracts,
+- `override_validator(Proc)` - e.g. `lambda { true }`,
+- `override_validator(Array)` - e.g. `[Num, String]`,
+- `override_validator(Hash)` - e.g. `{ :a => Num, :b => String }`,
+- `override_validator(Contracts::Args)` - e.g. `Args[Num]`,
+- `override_validator(Contracts::Func)` - e.g. `Func[Num => Num]`,
+- `override_validator(:valid)` - allows to override how contracts that respond to `:valid?` are handled,
+- `override_validator(:class)` - allows to override how class/module contract constants are handled,
+- `override_validator(:default)` - otherwise, raw value contracts.
+
+Default validators can be found here: [lib/contracts/validators.rb](https://github.com/egonSchiele/contracts.ruby/blob/master/lib/contracts/validators.rb).
+
 ## Disabling contracts
 
 If you want to disable contracts, set the `NO_CONTRACTS` environment variable. This will disable contracts and you won't have a performance hit. Pattern matching will still work if you disable contracts in this way! With NO_CONTRACTS only pattern-matching contracts are defined.
diff --git a/lib/contracts.rb b/lib/contracts.rb
@@ -7,6 +7,8 @@
 require "contracts/support"
 require "contracts/engine"
 require "contracts/method_handler"
+require "contracts/validators"
+require "contracts/call_with"
 
 module Contracts
   def self.included(base)
@@ -58,7 +60,15 @@ def functype(funcname)
 #   Contract [contract names] => return_value
 #
 # This class also provides useful callbacks and a validation method.
+#
+# For #make_validator and related logic see file
+# lib/contracts/validators.rb
+# For #call_with and related logic see file
+# lib/contracts/call_with.rb
 class Contract < Contracts::Decorator
+  extend Contracts::Validators
+  include Contracts::CallWith
+
   # Default implementation of failure_callback. Provided as a block to be able
   # to monkey patch #failure_callback only temporary and then switch it back.
   # First important usage - for specs.
@@ -209,54 +219,6 @@ def self.valid?(arg, contract)
     make_validator(contract)[arg]
   end
 
-  # This is a little weird. For each contract
-  # we pre-make a proc to validate it so we
-  # don't have to go through this decision tree every time.
-  # Seems silly but it saves us a bunch of time (4.3sec vs 5.2sec)
-  def self.make_validator(contract)
-    # if is faster than case!
-    klass = contract.class
-    if klass == Proc
-      # e.g. lambda {true}
-      contract
-    elsif klass == Array
-      # e.g. [Num, String]
-      # TODO: account for these errors too
-      lambda do |arg|
-        return false unless arg.is_a?(Array) && arg.length == contract.length
-        arg.zip(contract).all? do |_arg, _contract|
-          Contract.valid?(_arg, _contract)
-        end
-      end
-    elsif klass == Hash
-      # e.g. { :a => Num, :b => String }
-      lambda do |arg|
-        return false unless arg.is_a?(Hash)
-        contract.keys.all? do |k|
-          Contract.valid?(arg[k], contract[k])
-        end
-      end
-    elsif klass == Contracts::Args
-      lambda do |arg|
-        Contract.valid?(arg, contract.contract)
-      end
-    elsif klass == Contracts::Func
-      lambda do |arg|
-        arg.is_a?(Method) || arg.is_a?(Proc)
-      end
-    else
-      # classes and everything else
-      # e.g. Fixnum, Num
-      if contract.respond_to? :valid?
-        lambda { |arg| contract.valid?(arg) }
-      elsif klass == Class || klass == Module
-        lambda { |arg| arg.is_a?(contract) }
-      else
-        lambda { |arg| contract == arg }
-      end
-    end
-  end
-
   def [](*args, &blk)
     call(*args, &blk)
   end
@@ -287,99 +249,6 @@ def maybe_append_options! args, blk
     end
   end
 
-  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
-
   # Used to determine type of failure exception this contract should raise in case of failure
   def failure_exception
     if @pattern_match
diff --git a/lib/contracts/call_with.rb b/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
diff --git a/lib/contracts/support.rb b/lib/contracts/support.rb
@@ -29,6 +29,10 @@ def unique_id
         (Time.now.to_f * 1000).to_i.to_s(36) + rand(1_000_000).to_s(36)
       end
 
+      def contract_id(contract)
+        contract.object_id
+      end
+
       def eigenclass_hierarchy_supported?
         return false if RUBY_PLATFORM == "java" && RUBY_VERSION.to_f < 2.0
         RUBY_VERSION.to_f > 1.8
diff --git a/lib/contracts/validators.rb b/lib/contracts/validators.rb
diff --git a/spec/override_validators_spec.rb b/spec/override_validators_spec.rb
