contracts-lite 0.14.0 → 0.15.0

data/lib/contracts/engine/target.rb

@@ -2,8 +2,6 @@ module Contracts
   module Engine
     # Represents class in question
     class Target
-      # Creates new instance of Target
-      #
       # @param [Class] target - class in question
       def initialize(target)
         @target = target
@@ -54,7 +52,7 @@ module Contracts
         self.class.new(eigenclass).apply(Eigenclass)
         eigenclass.extend(MethodDecorators)
         # FIXME; this should detect what user uses `include Contracts` or
-        # `include Contracts;;Core`
+        # `include Contracts::Core`
         eigenclass.send(:include, Contracts)
       end
 

data/lib/contracts/error_formatter.rb

@@ -1,5 +1,8 @@
 module Contracts
   class ErrorFormatters
+    # # 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)
       class_for(data).new(data).message
     end
@@ -55,7 +58,7 @@ module Contracts
   class KeywordArgsErrorFormatter < DefaultErrorFormatter
     def message
       s = []
-      s << "#{header}"
+      s << header.to_s
       s << "        Expected: #{expected}"
       s << "        Actual: #{data[:arg].inspect}"
       s << "        Missing Contract: #{missing_contract_info}" unless missing_contract_info.empty?
@@ -101,11 +104,8 @@ module Contracts
     end
 
     def check_contract(contract, value)
-      if contract.respond_to?(:valid?)
-        contract.valid?(value)
-      else
-        value.is_a?(contract)
-      end
+      return contract.valid?(value) if contract.respond_to?(:valid?)
+      value.is_a?(contract)
     rescue
       false
     end

data/lib/contracts/errors.rb

@@ -59,10 +59,10 @@ module Contracts
         # you can use `Contract` definition here now
       end
     end
-    ```}
+    ```}.freeze
 
     attr_reader :message
-    alias_method :to_s, :message
+    alias to_s message
 
     def initialize(message = DEFAULT_MESSAGE)
       @message = message

data/lib/contracts/formatters.rb

@@ -6,18 +6,15 @@ module Contracts
       # @param full [Boolean] if false only unique `to_s` values will be output,
       #   non unique values become empty string.
       def initialize(contract, full = true)
-        @contract, @full = contract, full
+        @contract = contract
+        @full     = full
       end
 
       # Formats any type of Contract.
       def contract(contract = @contract)
-        if contract.is_a?(Hash)
-          hash_contract(contract)
-        elsif contract.is_a?(Array)
-          array_contract(contract)
-        else
-          InspectWrapper.create(contract, @full)
-        end
+        return hash_contract(contract)  if contract.is_a?(Hash)
+        return array_contract(contract) if contract.is_a?(Array)
+        InspectWrapper.create(contract, @full)
       end
 
       # Formats Hash contracts.
@@ -41,17 +38,19 @@ module Contracts
       # InspectWrapper is a factory, will never be an instance
       # @return [ClassInspectWrapper, ObjectInspectWrapper]
       def self.create(value, full = true)
-        if value.class == Class
-          ClassInspectWrapper
-        else
-          ObjectInspectWrapper
-        end.new(value, full)
+        inspector_klass(value).new(value, full)
+      end
+
+      def self.inspector_klass(value)
+        return ClassInspectWrapper if value.class == Class
+        ObjectInspectWrapper
       end
 
       # @param full [Boolean] if false only unique `to_s` values will be output,
       #   non unique values become empty string.
       def initialize(value, full)
-        @value, @full = value, full
+        @value = value
+        @full  = full
       end
 
       # Inspect different types of contract values.
@@ -61,17 +60,17 @@ module Contracts
       # Primitive values e.g. 42, true, nil will be left alone.
       def inspect
         return "" unless full?
-        return @value.inspect if empty_val?
-        return @value.to_s if plain?
+        return @value.inspect     if empty_val?
+        return @value.to_s        if plain?
         return delim(@value.to_s) if useful_to_s?
         useful_inspect
       end
 
       def delim(value)
-        @full ? "(#{value})" : "#{value}"
+        @full ? "(#{value})" : value.to_s
       end
 
-      # Eliminates eronious quotes in output that plain inspect includes.
+      # Eliminates erroneous quotes in output that plain inspect includes.
       def to_s
         inspect
       end
@@ -84,17 +83,17 @@ module Contracts
 
       def full?
         @full ||
-          @value.is_a?(Hash) || @value.is_a?(Array) ||
+          @value.is_a?(Hash) ||
+          @value.is_a?(Array) ||
           (!plain? && useful_to_s?)
       end
 
+      # Not a type of contract that can have a custom to_s defined
       def plain?
-        # Not a type of contract that can have a custom to_s defined
         !@value.is_a?(Builtin::CallableClass) && @value.class != Class
       end
 
       def useful_to_s?
-        # Useless to_s value or no custom to_s behavious defined
         !empty_to_s? && custom_to_s?
       end
 

data/lib/contracts/invariants.rb

@@ -36,7 +36,9 @@ module Contracts
 
     class Invariant
       def initialize(klass, name, &condition)
-        @klass, @name, @condition = klass, name, condition
+        @klass     = klass
+        @name      = name
+        @condition = condition
       end
 
       def expected
@@ -46,14 +48,16 @@ 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)
-        fail InvariantError, failure_msg(data)
+        raise InvariantError, failure_msg(data)
       end
 
       def self.failure_msg(data)

data/lib/contracts/method_handler.rb

@@ -3,14 +3,14 @@ module Contracts
   # Represents single such method
   class MethodHandler
     METHOD_REFERENCE_FACTORY = {
-      :class_methods => SingletonMethodReference,
+      :class_methods    => SingletonMethodReference,
       :instance_methods => MethodReference
-    }
+    }.freeze
 
     RAW_METHOD_STRATEGY = {
-      :class_methods => lambda { |target, name| target.method(name) },
+      :class_methods    => lambda { |target, name| target.method(name) },
       :instance_methods => lambda { |target, name| target.instance_method(name) }
-    }
+    }.freeze
 
     # Creates new instance of MethodHandler
     #
@@ -18,9 +18,9 @@ module Contracts
     # @param [Bool] is_class_method
     # @param [Class] target - class that method got added to
     def initialize(method_name, is_class_method, target)
-      @method_name = method_name
+      @method_name     = method_name
       @is_class_method = is_class_method
-      @target = target
+      @target          = target
     end
 
     # Handles method addition
@@ -58,7 +58,7 @@ module Contracts
     end
     # _method_type is required for assigning it to local variable with
     # the same name. See: #redefine_method
-    alias_method :_method_type, :method_type
+    alias _method_type method_type
 
     def method_reference
       @_method_reference ||= METHOD_REFERENCE_FACTORY[method_type].new(method_name, raw_method)
@@ -102,8 +102,8 @@ module Contracts
       return if ignore_decorators?
 
       # Those are required for instance_eval to be able to refer them
-      name = method_name
-      method_type = _method_type
+      name           = method_name
+      method_type    = _method_type
       current_engine = engine
 
       # We are gonna redefine original method here
@@ -113,11 +113,15 @@ module Contracts
         # 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."
+          raise "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
         decorated_methods = engine.decorated_methods_for(method_type, name)
+        expected_error    = decorated_methods[0].failure_exception
+        error_to_return   = nil
+        result            = nil
+        success           = nil
 
         # This adds support for overloading methods. Here we go
         # through each method and call it with the arguments.
@@ -125,38 +129,29 @@ 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
-
-        until success
-          decorated_method = decorated_methods[i]
-          i += 1
+        decorated_methods.any? do |decorated_method|
           begin
-            success = true
             result = decorated_method.call_with(self, *args, &blk)
+            success = true
           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
+            error_to_return = error
+            nil
           end
         end
+        return result if success
 
-        # Return the result of successfully called method
-        result
+        begin
+          ::Contract.failure_callback(error_to_return.data, false)
+        rescue expected_error
+          raise error_to_return.to_contract_error
+        end
       end
     end
 
     def validate_decorators!
       return if decorators.size == 1
 
-      fail %{
+      raise %{
 Oops, it looks like method '#{name}' has multiple contracts:
 #{decorators.map { |x| x[1][0].inspect }.join("\n")}
 
@@ -181,7 +176,7 @@ https://github.com/egonSchiele/contracts.ruby/issues
 
       return if matched.empty?
 
-      fail ContractError.new(%{
+      raise 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:

data/lib/contracts/method_reference.rb

@@ -7,21 +7,20 @@ module Contracts
     # name - name of the method
     # method - method object
     def initialize(name, method)
-      @name = name
+      @name   = name
       @method = method
     end
 
-    # Returns method_position, delegates to Support.method_position
     def method_position
       Support.method_position(@method)
     end
 
     # Makes a method re-definition in proper way
     def make_definition(this, &blk)
-      is_private = private?(this)
+      is_private   = private?(this)
       is_protected = protected?(this)
       alias_target(this).send(:define_method, name, &blk)
-      make_private(this) if is_private
+      make_private(this)   if is_private
       make_protected(this) if is_protected
     end
 
@@ -45,18 +44,18 @@ module Contracts
 
     private
 
-    # Makes a method private
-    def make_private(this)
-      original_name = name
-      alias_target(this).class_eval { private original_name }
-    end
-
     def private?(this)
-      this.private_instance_methods.map(&:to_sym).include?(name)
+      this.private_instance_methods.include?(name)
     end
 
     def protected?(this)
-      this.protected_instance_methods.map(&:to_sym).include?(name)
+      this.protected_instance_methods.include?(name)
+    end
+
+    # Makes a method private
+    def make_private(this)
+      original_name = name
+      alias_target(this).class_eval { private original_name }
     end
 
     # Makes a method protected
@@ -85,11 +84,11 @@ module Contracts
     private
 
     def private?(this)
-      this.private_methods.map(&:to_sym).include?(name)
+      this.private_methods.include?(name)
     end
 
     def protected?(this)
-      this.protected_methods.map(&:to_sym).include?(name)
+      this.protected_methods.include?(name)
     end
 
     # Return alias target for singleton methods.

data/lib/contracts/support.rb

@@ -3,17 +3,8 @@ module Contracts
     class << self
       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
-        else
-          file, line = method.source_location
-          file + ":" + line.to_s
-        end
+        file, line = method.source_location
+        "#{file}:#{line}"
       end
 
       def method_name(method)
@@ -33,11 +24,6 @@ module Contracts
         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
-      end
-
       def eigenclass_of(target)
         class << target; self; end
       end

data/lib/contracts/version.rb

@@ -1,3 +1,3 @@
 module Contracts
-  VERSION = "0.14.0"
+  VERSION = "0.15.0".freeze
 end

data/spec/contracts_spec.rb

@@ -7,12 +7,23 @@ RSpec.describe "Contracts:" do
     it "should fail for insufficient arguments" do
       expect do
         @o.hello
-      end.to raise_error
+      end.to raise_error(ArgumentError)
     end
 
     it "should fail for insufficient contracts" do
       expect { @o.bad_double(2) }.to raise_error(ContractError)
     end
+
+    it "requires last argument to be a hash for more than one contracts" do
+      expect{
+        Class.new(GenericExample) do
+          Contract C::Num, C::Num
+          def no_args_bad_contract(num)
+            1
+          end
+        end
+      }.to raise_error(RuntimeError, Regexp.new("A contract should be written as"))
+    end
   end
 
   describe "contracts for functions with no arguments" do
@@ -32,7 +43,7 @@ RSpec.describe "Contracts:" do
             1
           end
         end
-      end.to raise_error
+      end.to raise_error(NameError)
     end
   end
 
@@ -462,9 +473,17 @@ RSpec.describe "Contracts:" do
         @o.with_partial_sums(1, 2, 3)
       end.to raise_error(ContractError, /Actual: nil/)
 
-      expect do
-        @o.with_partial_sums(1, 2, 3, lambda { |x| x })
-      end.to raise_error(ContractError, /Actual: nil/)
+      to_call = lambda {
+        expect do
+          # because lambda is not a valid &block, it is considered to belong to the splat argument, and raises for num contract!
+          @o.with_partial_sums(1, 2, 3, lambda { |x| x })
+        end
+      }
+      to_call.call.to raise_error(ContractError, /Contract violation for argument 4 of 5/)
+      to_call.call.to raise_error(ContractError, /Actual: #<Proc/)
+      to_call.call.to raise_error(ContractError, Regexp.new("Expected: \\(SplatArgs\\[Contracts::Builtin::Num\\]\\)"))
+
+
     end
 
     context "when block has Func contract" do
@@ -696,7 +715,7 @@ RSpec.describe "Contracts:" do
     it "should apply the contract to an inherited method" do
       c = Child.new
       expect { c.double(2) }.to_not raise_error
-      expect { c.double("asd") }.to raise_error
+      expect { c.double("asd") }.to raise_error(ParamContractError)
     end
   end