contracts 0.13.0 → 0.17

data/lib/contracts/call_with.rb

@@ -1,13 +1,19 @@
+# frozen_string_literal: true
+
 module Contracts
   module CallWith
-    def call_with(this, *args, &blk)
+    def call_with(this, *args, **kargs, &blk)
+      call_with_inner(false, this, *args, **kargs, &blk)
+    end
+
+    def call_with_inner(returns, this, *args, **kargs, &blk)
       args << blk if blk
 
       # Explicitly append blk=nil if nil != Proc contract violation anticipated
       nil_block_appended = maybe_append_block!(args, blk)
 
       # Explicitly append options={} if Hash contract is present
-      maybe_append_options!(args, blk)
+      kargs_appended = maybe_append_options!(args, kargs, blk)
 
       # Loop forward validating the arguments up to the splat (if there is one)
       (@args_contract_index || args.size).times do |i|
@@ -16,17 +22,23 @@ 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
@@ -49,14 +61,18 @@ module Contracts
           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)
+            # rubocop:disable Style/SoleNestedConditional
+            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,
+            })
+            # rubocop:enable Style/SoleNestedConditional
           end
 
           if contract.is_a?(Contracts::Func)
@@ -68,21 +84,27 @@ module Contracts
       # If we put the block into args for validating, restore the args
       # OR if we added a fake nil at the end because a block wasn't passed in.
       args.slice!(-1) if blk || nil_block_appended
+      args.slice!(-1) if kargs_appended
       result = if method.respond_to?(:call)
                  # proc, block, lambda, etc
-                 method.call(*args, &blk)
+                 method.call(*args, **kargs, &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.is_a?(Contract)
+                 method.send_to(this, *args, **kargs, &target_blk)
                end
 
       unless @ret_validator[result]
-        Contract.failure_callback(:arg => result,
-                                  :contract => ret_contract,
-                                  :class => klass,
-                                  :method => method,
-                                  :contracts => self,
-                                  :return_value => true)
+        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!)

data/lib/contracts/core.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Contracts
   module Core
     def self.included(base)
@@ -9,8 +11,6 @@ module Contracts
     end
 
     def self.common(base)
-      return if base.respond_to?(:Contract)
-
       base.extend(MethodDecorators)
 
       base.instance_eval do
@@ -27,7 +27,7 @@ module Contracts
       # NOTE: Workaround for `defined?(super)` bug in ruby 1.9.2
       # source: http://stackoverflow.com/a/11181685
       # bug: https://bugs.ruby-lang.org/issues/6644
-      base.class_eval <<-RUBY
+      base.class_eval <<-RUBY, __FILE__, __LINE__ + 1
         # TODO: deprecate
         # Required when contracts are included in global scope
         def Contract(*args)

data/lib/contracts/decorators.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Contracts
   module MethodDecorators
     def self.extended(klass)
@@ -6,6 +8,7 @@ module Contracts
 
     def inherited(subclass)
       Engine.fetch_from(subclass).set_eigenclass_owner
+      super
     end
 
     def method_added(name)
@@ -24,6 +27,7 @@ module Contracts
     class << self; attr_accessor :decorators; end
 
     def self.inherited(klass)
+      super
       name = klass.name.gsub(/^./) { |m| m.downcase }
 
       return if name =~ /^[^A-Za-z_]/ || name =~ /[^0-9A-Za-z_]/
@@ -32,11 +36,11 @@ module Contracts
       # make a new method that is the name of your decorator.
       # that method accepts random args and a block.
       # inside, `decorate` is called with those params.
-      MethodDecorators.module_eval <<-ruby_eval, __FILE__, __LINE__ + 1
+      MethodDecorators.module_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
         def #{klass}(*args, &blk)
           ::Contracts::Engine.fetch_from(self).decorate(#{klass}, *args, &blk)
         end
-      ruby_eval
+      RUBY_EVAL
     end
 
     def initialize(klass, method)

data/lib/contracts/engine.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "contracts/engine/base"
 require "contracts/engine/target"
 require "contracts/engine/eigenclass"

data/lib/contracts/engine/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Contracts
   module Engine
     # Contracts engine
@@ -90,7 +92,7 @@ module Contracts
       def nearest_decorated_ancestor
         current = klass
         current_engine = self
-        ancestors = current.ancestors[1..-1]
+        ancestors = current.ancestors[1..]
 
         while current && current_engine && !current_engine.decorated_methods?
           current = ancestors.shift
@@ -109,8 +111,7 @@ module Contracts
       end
 
       # No-op because it is safe to add decorators to normal classes
-      def validate!
-      end
+      def validate!; end
 
       def pop_decorators
         decorators.tap { clear_decorators }

data/lib/contracts/engine/eigenclass.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Contracts
   module Engine
     # Special case of contracts engine for eigenclasses
@@ -27,8 +29,7 @@ module Contracts
       end
 
       # No-op for eigenclasses
-      def set_eigenclass_owner
-      end
+      def set_eigenclass_owner; end
 
       # Fetches just eigenclasses decorators
       def all_decorators

data/lib/contracts/engine/target.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Contracts
   module Engine
     # Represents class in question

data/lib/contracts/errors.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # @private
 # Base class for Contract errors
 #
@@ -65,6 +67,7 @@ module Contracts
     alias_method :to_s, :message
 
     def initialize(message = DEFAULT_MESSAGE)
+      super
       @message = message
     end
   end

data/lib/contracts/formatters.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require "pp"
+
 module Contracts
   # A namespace for classes related to formatting.
   module Formatters
@@ -5,18 +9,19 @@ module Contracts
     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)
+      def initialize(contract, full: true)
         @contract, @full = contract, full
       end
 
       # Formats any type of Contract.
       def contract(contract = @contract)
-        if contract.is_a?(Hash)
+        case contract
+        when Hash
           hash_contract(contract)
-        elsif contract.is_a?(Array)
+        when Array
           array_contract(contract)
         else
-          InspectWrapper.create(contract, @full)
+          InspectWrapper.create(contract, full: @full)
         end
       end
 
@@ -24,14 +29,14 @@ module 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
+          repr.merge(k => InspectWrapper.create(contract(v), full: @full))
+        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: @full) }
       end
     end
 
@@ -40,8 +45,8 @@ module Contracts
     module InspectWrapper
       # InspectWrapper is a factory, will never be an instance
       # @return [ClassInspectWrapper, ObjectInspectWrapper]
-      def self.create(value, full = true)
-        if value.class == Class
+      def self.create(value, full: true)
+        if value.instance_of?(Class)
           ClassInspectWrapper
         else
           ObjectInspectWrapper
@@ -64,6 +69,7 @@ module Contracts
         return @value.inspect if empty_val?
         return @value.to_s if plain?
         return delim(@value.to_s) if useful_to_s?
+
         useful_inspect
       end
 
@@ -94,7 +100,7 @@ module Contracts
       end
 
       def useful_to_s?
-        # Useless to_s value or no custom to_s behavious defined
+        # Useless to_s value or no custom to_s behaviour defined
         !empty_to_s? && custom_to_s?
       end
 
@@ -123,7 +129,7 @@ module Contracts
       include InspectWrapper
 
       def custom_to_s?
-        !@value.to_s.match(/#\<\w+:.+\>/)
+        !@value.to_s.match(/#<\w+:.+>/)
       end
 
       def useful_inspect

data/lib/contracts/invariants.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Contracts
   module Invariants
     def self.included(base)
@@ -46,10 +48,12 @@ module Contracts
       def check_on(target, method)
         return if target.instance_eval(&@condition)
 
-        self.class.failure_callback(:expected => expected,
-                                    :actual => false,
-                                    :target => target,
-                                    :method => method)
+        self.class.failure_callback({
+          expected: expected,
+          actual:   false,
+          target:   target,
+          method:   method,
+        })
       end
 
       def self.failure_callback(data)

data/lib/contracts/method_handler.rb

@@ -1,15 +1,17 @@
+# frozen_string_literal: true
+
 module Contracts
   # Handles class and instance methods addition
   # Represents single such method
   class MethodHandler
     METHOD_REFERENCE_FACTORY = {
       :class_methods => SingletonMethodReference,
-      :instance_methods => MethodReference
+      :instance_methods => MethodReference,
     }
 
     RAW_METHOD_STRATEGY = {
       :class_methods => lambda { |target, name| target.method(name) },
-      :instance_methods => lambda { |target, name| target.instance_method(name) }
+      :instance_methods => lambda { |target, name| target.instance_method(name) },
     }
 
     # Creates new instance of MethodHandler
@@ -78,11 +80,13 @@ module Contracts
 
     def pattern_matching?
       return @_pattern_matching if defined?(@_pattern_matching)
+
       @_pattern_matching = decorated_methods.any? { |x| x.method != method_reference }
     end
 
     def mark_pattern_matching_decorators
       return unless pattern_matching?
+
       decorated_methods.each(&:pattern_match!)
     end
 
@@ -107,13 +111,13 @@ module Contracts
       current_engine = engine
 
       # We are gonna redefine original method here
-      method_reference.make_definition(target) do |*args, &blk|
+      method_reference.make_definition(target) do |*args, **kargs, &blk|
         engine = current_engine.nearest_decorated_ancestor
 
         # If we weren't able to find any ancestor that has decorated methods
         # FIXME : this looks like untested code (commenting it out doesn't make specs red)
         unless engine
-          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."
+          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
 
         # Fetch decorated methods out of the contracts engine
@@ -125,31 +129,26 @@ 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, **kargs, &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, use_pattern_matching: false)
+            decorated_methods.last.call_with_inner(false, self, *args, **kargs, &blk)
+          end
+          # rubocop:disable Naming/RescuedExceptionsVariableName
+        rescue expected_error => final_error
+          raise final_error.to_contract_error
+          # rubocop:enable Naming/RescuedExceptionsVariableName
+        end
       end
     end
 
@@ -157,7 +156,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?
@@ -181,7 +180,8 @@ https://github.com/egonSchiele/contracts.ruby/issues
 
       return if matched.empty?
 
-      fail ContractError.new(%{
+      fail ContractError.new(
+        %{
 It looks like you are trying to use pattern-matching, but
 multiple definitions for function '#{method_name}' have the same
 contract for input parameters:
@@ -189,7 +189,9 @@ contract for input parameters:
 #{(matched + [decorator]).map(&:to_s).join("\n")}
 
 Each definition needs to have a different contract for the parameters.
-      }, {})
+        },
+        {},
+      )
     end
   end
 end