contracts-lite 0.14.0 → 0.15.0

data/lib/contracts.rb

@@ -1,3 +1,5 @@
+require "set"
+require "contracts/formatters"
 require "contracts/builtin_contracts"
 require "contracts/decorators"
 require "contracts/errors"
@@ -8,10 +10,14 @@ require "contracts/method_reference"
 require "contracts/support"
 require "contracts/engine"
 require "contracts/method_handler"
-require "contracts/validators"
-require "contracts/call_with"
 require "contracts/core"
 
+require "contracts/args_validator"
+require "contracts/contract/call_with"
+require "contracts/contract/validators"
+require "contracts/contract/failure_callback"
+require "contracts/contract"
+
 module Contracts
   def self.included(base)
     base.send(:include, Core)
@@ -21,211 +27,3 @@ module Contracts
     base.send(:extend, Core)
   end
 end
-
-# This is the main Contract class. When you write a new contract, you'll
-# write it as:
-#
-#   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.
-  DEFAULT_FAILURE_CALLBACK = proc do |data|
-    if data[:return_value]
-      # this failed on the return contract
-      fail ReturnContractError.new(failure_msg(data), data)
-    else
-      # this failed for a param contract
-      fail data[:contracts].failure_exception.new(failure_msg(data), data)
-    end
-  end
-
-  attr_reader :args_contracts, :ret_contract, :klass, :method
-  def initialize(klass, method, *contracts)
-    unless contracts.last.is_a?(Hash)
-      unless contracts.one?
-        fail %{
-          It looks like your contract for #{method.name} doesn't have a return
-          value. A contract should be written as `Contract arg1, arg2 =>
-          return_value`.
-        }.strip
-      end
-      contracts = [nil => contracts[-1]]
-    end
-
-    # internally we just convert that return value syntax back to an array
-    @args_contracts = contracts[0, contracts.size - 1] + contracts[-1].keys
-
-    @ret_contract = contracts[-1].values[0]
-
-    @args_validators = args_contracts.map do |contract|
-      Contract.make_validator(contract)
-    end
-
-    @args_contract_index = args_contracts.index do |contract|
-      contract.is_a? Contracts::Args
-    end
-
-    @ret_validator = Contract.make_validator(ret_contract)
-
-    @pattern_match = false
-
-    # == @has_proc_contract
-    last_contract = args_contracts.last
-    is_a_proc = last_contract.is_a?(Class) && (last_contract <= Proc || last_contract <= Method)
-    maybe_a_proc = last_contract.is_a?(Contracts::Maybe) && last_contract.include_proc?
-
-    @has_proc_contract = is_a_proc || maybe_a_proc || last_contract.is_a?(Contracts::Func)
-
-    # ====
-
-    # == @has_options_contract
-    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?(Contracts::Builtin::KeywordArgs)
-                            else
-                              last_contract.is_a?(Hash) || last_contract.is_a?(Contracts::Builtin::KeywordArgs)
-                            end
-    # ===
-
-    @klass, @method = klass, method
-  end
-
-  def pretty_contract c
-    c.is_a?(Class) ? c.name : c.class.name
-  end
-
-  def to_s
-    args = args_contracts.map { |c| pretty_contract(c) }.join(", ")
-    ret = pretty_contract(ret_contract)
-    ("#{args} => #{ret}").gsub("Contracts::Builtin::", "")
-  end
-
-  # Given a hash, prints out a failure message.
-  # 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)
-    Contracts::ErrorFormatters.failure_msg(data)
-  end
-
-  # Callback for when a contract fails. By default it raises
-  # an error and prints detailed info about the contract that
-  # failed. You can also monkeypatch this callback to do whatever
-  # you want...log the error, send you an email, print an error
-  # message, etc.
-  #
-  # Example of monkeypatching:
-  #
-  #   def Contract.failure_callback(data)
-  #     puts "You had an error!"
-  #     puts failure_msg(data)
-  #     exit
-  #   end
-  def self.failure_callback(data, use_pattern_matching = true)
-    if data[:contracts].pattern_match? && use_pattern_matching
-      return DEFAULT_FAILURE_CALLBACK.call(data)
-    end
-
-    fetch_failure_callback.call(data)
-  end
-
-  # Used to override failure_callback without monkeypatching.
-  #
-  # Takes: block parameter, that should accept one argument - data.
-  #
-  # Example usage:
-  #
-  #   Contract.override_failure_callback do |data|
-  #     puts "You had an error"
-  #     puts failure_msg(data)
-  #     exit
-  #   end
-  def self.override_failure_callback(&blk)
-    @failure_callback = blk
-  end
-
-  # Used to restore default failure callback
-  def self.restore_failure_callback
-    @failure_callback = DEFAULT_FAILURE_CALLBACK
-  end
-
-  def self.fetch_failure_callback
-    @failure_callback ||= DEFAULT_FAILURE_CALLBACK
-  end
-
-  # Used to verify if an argument satisfies a contract.
-  #
-  # Takes: an argument and a contract.
-  #
-  # Returns: a tuple: [Boolean, metadata]. The boolean indicates
-  # whether the contract was valid or not. If it wasn't, metadata
-  # contains some useful information about the failure.
-  def self.valid?(arg, contract)
-    make_validator(contract)[arg]
-  end
-
-  def [](*args, &blk)
-    call(*args, &blk)
-  end
-
-  def call(*args, &blk)
-    call_with(nil, *args, &blk)
-  end
-
-  # if we specified a proc in the contract but didn't pass one in,
-  # it's possible we are going to pass in a block instead. So lets
-  # append a nil to the list of args just so it doesn't fail.
-
-  # a better way to handle this might be to take this into account
-  # before throwing a "mismatched # of args" error.
-  # returns true if it appended nil
-  def maybe_append_block! args, blk
-    return false unless @has_proc_contract && !blk &&
-        (@args_contract_index || args.size < args_contracts.size)
-    args << nil
-    true
-  end
-
-  # Same thing for when we have named params but didn't pass any in.
-  # 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_contracts[-2].is_a?(Contracts::Builtin::KeywordArgs)) && !args[-2].is_a?(Hash)
-      args.insert(-2, {})
-    elsif (args_contracts[-1].is_a?(Hash) || args_contracts[-1].is_a?(Contracts::Builtin::KeywordArgs)) && !args[-1].is_a?(Hash)
-      args << {}
-    end
-    true
-  end
-
-  # Used to determine type of failure exception this contract should raise in case of failure
-  def failure_exception
-    if pattern_match?
-      PatternMatchingError
-    else
-      ParamContractError
-    end
-  end
-
-  # @private
-  # Used internally to mark contract as pattern matching contract
-  def pattern_match!
-    @pattern_match = true
-  end
-
-  # Used to determine if contract is a pattern matching contract
-  def pattern_match?
-    @pattern_match == true
-  end
-end

data/lib/contracts/args_validator.rb

@@ -0,0 +1,96 @@
+module Contracts
+  class ArgsValidator
+    attr_accessor :splat_args_contract_index, :klass, :method, :contracts, :args_contracts, :args_validators
+    def initialize(opts)
+      @splat_args_contract_index = opts.fetch(:splat_args_contract_index)
+      @klass                     = opts.fetch(:klass)
+      @method                    = opts.fetch(:method)
+      @contracts                 = opts.fetch(:contracts)
+      @args_contracts            = opts.fetch(:args_contracts)
+      @args_validators           = opts.fetch(:args_validators)
+    end
+
+    # Loop forward validating the arguments up to the splat (if there is one)
+    # may change the `args` param
+    def validate_args_before_splat!(args)
+      (splat_args_contract_index || args.size).times do |i|
+        validate!(args, i)
+      end
+    end
+
+    ## possibilities
+    # - splat is last argument,     like: def hello(a, b, *args)
+    # - splat is not last argument, like: def hello(*args, n)
+    def validate_splat_args_and_after!(args)
+      return unless splat_args_contract_index
+      from, count = splat_range(args)
+      validate_splat(args, from, count)
+
+      splat_upper_bound = from + count
+      return if splat_upper_bound == args.size
+
+      validate_rest(args, from, splat_upper_bound)
+    end
+
+    private
+
+    def validate_splat(args, from, count)
+      args.slice(from, count).each_with_index do |_arg, index|
+        arg_index = from + index
+        contract  = args_contracts[from]
+        validator = args_validators[from]
+        validate!(args, arg_index, contract, validator)
+      end
+    end
+
+    def validate_rest(args, from, splat_upper_bound)
+      args[splat_upper_bound..-1].each_with_index do |_arg, index|
+        arg_index      = splat_upper_bound + index
+        contract_index = from + index + 1
+        contract       = args_contracts[contract_index]
+        validator      = args_validators[contract_index]
+        validate!(args, arg_index, contract, validator)
+      end
+    end
+
+    # string, splat[integer], float
+    # - "aom", 2, 3, 4, 5, 0.1        >>> 1, 4
+    # - "aom", 2, 0.1                 >>> 1, 1
+    # - "aom", 2, 3, 4, 5, 6, 7, 0.1  >>> 1, 6
+
+    # splat[integer]
+    # - 2, 3, 4, 5        >>> 0, 4
+    # - 2                 >>> 0, 1
+    # - 2, 3, 4, 5, 6, 7  >>> 0, 6
+    def splat_range(args)
+      args_after_splat  = args_contracts.size - (splat_args_contract_index + 1)
+      in_splat          = args.size - args_after_splat - splat_args_contract_index
+
+      [splat_args_contract_index, in_splat]
+    end
+
+    def validate!(args, index, contract = nil, validator = nil)
+      arg       = args[index]
+      contract  ||= args_contracts[index]
+      validator ||= args_validators[index]
+      fail_if_invalid(validator, arg, index + 1, args.size, contract)
+
+      return unless contract.is_a?(Contracts::Func)
+      args[index] = Contract.new(klass, arg, *contract.contracts)
+    end
+
+    def fail_if_invalid(validator, arg, arg_pos, args_size, contract)
+      return if validator && validator.call(arg)
+      throw :return, Contracts::CallWith::SILENT_FAILURE unless Contract.failure_callback(
+        :arg          => arg,
+        :contract     => contract,
+        :class        => klass,
+        :method       => method,
+        :contracts    => contracts,
+        :arg_pos      => arg_pos,
+        :total_args   => args_size,
+        :return_value => false
+      )
+    end
+  end
+end

data/lib/contracts/builtin_contracts.rb

@@ -1,7 +1,3 @@
-require "contracts/formatters"
-require "set"
-
-# rdoc
 # This module contains all the builtin contracts.
 # If you want to use them, first:
 #
@@ -22,56 +18,56 @@ module Contracts
   module Builtin
     # Check that an argument is +Numeric+.
     class Num
-      def self.valid? val
+      def self.valid?(val)
         val.is_a? Numeric
       end
     end
 
     # Check that an argument is a positive number.
     class Pos
-      def self.valid? val
+      def self.valid?(val)
         val && val.is_a?(Numeric) && val > 0
       end
     end
 
     # Check that an argument is a negative number.
     class Neg
-      def self.valid? val
+      def self.valid?(val)
         val && val.is_a?(Numeric) && val < 0
       end
     end
 
     # Check that an argument is an +Integer+.
     class Int
-      def self.valid? val
+      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
+      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
+      def self.valid?(val)
         val && val.is_a?(Integer) && val > 0
       end
     end
 
     # Passes for any argument.
     class Any
-      def self.valid? val
+      def self.valid?(val)
         true
       end
     end
 
     # Fails for any argument.
     class None
-      def self.valid? val
+      def self.valid?(val)
         false
       end
     end
@@ -91,6 +87,15 @@ module Contracts
       end
     end
 
+    class EnumInspector
+      include ::Contracts::Formatters
+      def self.inspect(vals, last_join_word)
+        vals[0, vals.size-1].map do |x|
+          InspectWrapper.create(x)
+        end.join(", ") + " #{last_join_word} " + InspectWrapper.create(vals[-1]).to_s
+      end
+    end
+
     # Takes a variable number of contracts.
     # The contract passes if any of the contracts pass.
     # Example: <tt>Or[Fixnum, Float]</tt>
@@ -101,15 +106,13 @@ module Contracts
 
       def valid?(val)
         @vals.any? do |contract|
-          res, _ = Contract.valid?(val, contract)
+          res, = Contract.valid?(val, contract)
           res
         end
       end
 
       def to_s
-        @vals[0, @vals.size-1].map do |x|
-          InspectWrapper.create(x)
-        end.join(", ") + " or " + InspectWrapper.create(@vals[-1]).to_s
+        EnumInspector.inspect(@vals, "or")
       end
     end
 
@@ -123,16 +126,14 @@ module Contracts
 
       def valid?(val)
         results = @vals.map do |contract|
-          res, _ = Contract.valid?(val, contract)
+          res,  = Contract.valid?(val, contract)
           res
         end
         results.count(true) == 1
       end
 
       def to_s
-        @vals[0, @vals.size-1].map do |x|
-          InspectWrapper.create(x)
-        end.join(", ") + " xor " + InspectWrapper.create(@vals[-1]).to_s
+        EnumInspector.inspect(@vals, "xor")
       end
     end
 
@@ -146,15 +147,13 @@ module Contracts
 
       def valid?(val)
         @vals.all? do |contract|
-          res, _ = Contract.valid?(val, contract)
+          res, = Contract.valid?(val, contract)
           res
         end
       end
 
       def to_s
-        @vals[0, @vals.size-1].map do |x|
-          InspectWrapper.create(x)
-        end.join(", ") + " and " + InspectWrapper.create(@vals[-1]).to_s
+        EnumInspector.inspect(@vals, "and")
       end
     end
 
@@ -257,7 +256,7 @@ module Contracts
 
       def valid?(val)
         @vals.all? do |contract|
-          res, _ = Contract.valid?(val, contract)
+          res, = Contract.valid?(val, contract)
           !res
         end
       end
@@ -282,7 +281,7 @@ module Contracts
       def valid?(vals)
         return false unless vals.is_a?(@collection_class)
         vals.all? do |val|
-          res, _ = Contract.valid?(val, @contract)
+          res, = Contract.valid?(val, @contract)
           res
         end
       end
@@ -302,7 +301,7 @@ module Contracts
           CollectionOf.new(@collection_class, contract)
         end
 
-        alias_method :[], :new
+        alias [] new
       end
     end
 
@@ -321,20 +320,28 @@ module Contracts
     # Used for <tt>*args</tt> (variadic functions). Takes a contract
     # and uses it to validate every element passed in
     # through <tt>*args</tt>.
-    # Example: <tt>Args[Or[String, Num]]</tt>
-    class Args < CallableClass
+    # Example: <tt>SplatArgs[Or[String, Num]]</tt>
+    class SplatArgs < CallableClass
       attr_reader :contract
       def initialize(contract)
         @contract = contract
       end
 
       def to_s
-        "Args[#{@contract}]"
+        "SplatArgs[#{@contract}]"
+      end
+    end
+
+    # for compatibility
+    class Args < SplatArgs
+      def initialize(contract)
+        puts "DEPRECATION WARNING: \nContract::Args was renamed to Contract::SplatArgs, please update your before the next major version"
+        @contract = contract
       end
     end
 
     class Bool
-      def self.valid? val
+      def self.valid?(val)
         val.is_a?(TrueClass) || val.is_a?(FalseClass)
       end
     end
@@ -361,7 +368,7 @@ module Contracts
     # one for hash keys and one for hash values.
     # Example: <tt>HashOf[Symbol, String]</tt>
     class HashOf < CallableClass
-      INVALID_KEY_VALUE_PAIR = "You should provide only one key-value pair to HashOf contract"
+      INVALID_KEY_VALUE_PAIR = "You should provide only one key-value pair to HashOf contract".freeze
 
       def initialize(key, value = nil)
         if value
@@ -389,7 +396,7 @@ module Contracts
       private
 
       def validate_hash(hash)
-        fail ArgumentError, INVALID_KEY_VALUE_PAIR unless hash.count == 1
+        raise ArgumentError, INVALID_KEY_VALUE_PAIR unless hash.count == 1
       end
     end
 
@@ -468,7 +475,7 @@ module Contracts
     # Example: <tt>Optional[Num]</tt>
     class Optional < CallableClass
       UNABLE_TO_USE_OUTSIDE_OF_OPT_HASH =
-        "Unable to use Optional contract outside of KeywordArgs contract"
+        "Unable to use Optional contract outside of KeywordArgs contract".freeze
 
       def self._valid?(hash, key, contract)
         return Contract.valid?(hash[key], contract) unless contract.is_a?(Optional)
@@ -505,7 +512,7 @@ module Contracts
 
       def ensure_within_opt_hash
         return if within_opt_hash
-        fail ArgumentError, UNABLE_TO_USE_OUTSIDE_OF_OPT_HASH
+        raise ArgumentError, UNABLE_TO_USE_OUTSIDE_OF_OPT_HASH
       end
 
       def formatted_contract