contracts 0.13.0 → 0.17

data/features/support/env.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "aruba/cucumber"
 require "aruba/jruby" if RUBY_PLATFORM == "java"
 

data/lib/contracts.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+require "contracts/attrs"
 require "contracts/builtin_contracts"
 require "contracts/decorators"
 require "contracts/errors"
@@ -50,7 +53,9 @@ class Contract < Contracts::Decorator
   end
 
   attr_reader :args_contracts, :ret_contract, :klass, :method
+
   def initialize(klass, method, *contracts)
+    super(klass, method)
     unless contracts.last.is_a?(Hash)
       unless contracts.one?
         fail %{
@@ -92,17 +97,17 @@ class Contract < Contracts::Decorator
     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
+  def pretty_contract contract
+    contract.is_a?(Class) ? contract.name : contract.class.name
   end
 
   def to_s
@@ -115,22 +120,60 @@ class Contract < Contracts::Decorator
   # 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)
-    expected = Contracts::Formatters::Expected.new(data[:contract]).contract
-    position = Contracts::Support.method_position(data[:method])
+    indent_amount = 8
     method_name = Contracts::Support.method_name(data[:method])
 
+    # Header
     header = if data[:return_value]
                "Contract violation for return value:"
              else
                "Contract violation for argument #{data[:arg_pos]} of #{data[:total_args]}:"
              end
 
-    %{#{header}
-        Expected: #{expected},
-        Actual: #{data[:arg].inspect}
-        Value guarded in: #{data[:class]}::#{method_name}
-        With Contract: #{data[:contracts]}
-        At: #{position} }
+    # Expected
+    expected_prefix = "Expected: "
+    expected_value = Contracts::Support.indent_string(
+      Contracts::Formatters::Expected.new(data[:contract]).contract.pretty_inspect,
+      expected_prefix.length,
+    ).strip
+    expected_line = "#{expected_prefix}#{expected_value},"
+
+    # Actual
+    actual_prefix = "Actual: "
+    actual_value = Contracts::Support.indent_string(
+      data[:arg].pretty_inspect,
+      actual_prefix.length,
+    ).strip
+    actual_line = actual_prefix + actual_value
+
+    # Value guarded in
+    value_prefix = "Value guarded in: "
+    value_value = "#{data[:class]}::#{method_name}"
+    value_line = value_prefix + value_value
+
+    # Contract
+    contract_prefix = "With Contract: "
+    contract_value = data[:contracts].to_s
+    contract_line = contract_prefix + contract_value
+
+    # Position
+    position_prefix = "At: "
+    position_value = Contracts::Support.method_position(data[:method])
+    position_line = position_prefix + position_value
+
+    [
+      header,
+      Contracts::Support.indent_string(
+        [
+          expected_line,
+          actual_line,
+          value_line,
+          contract_line,
+          position_line,
+        ].join("\n"),
+        indent_amount,
+      ),
+    ].join("\n")
   end
 
   # Callback for when a contract fails. By default it raises
@@ -146,7 +189,7 @@ class Contract < Contracts::Decorator
   #     puts failure_msg(data)
   #     exit
   #   end
-  def self.failure_callback(data, use_pattern_matching = true)
+  def self.failure_callback(data, use_pattern_matching: true)
     if data[:contracts].pattern_match? && use_pattern_matching
       return DEFAULT_FAILURE_CALLBACK.call(data)
     end
@@ -206,19 +249,21 @@ class Contract < Contracts::Decorator
   # 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_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
+  def maybe_append_options! args, kargs, blk
     return false unless @has_options_contract
-    if @has_proc_contract && args_contracts[-2].is_a?(Hash) && !args[-2].is_a?(Hash)
-      args.insert(-2, {})
-    elsif args_contracts[-1].is_a?(Hash) && !args[-1].is_a?(Hash)
-      args << {}
+
+    if @has_proc_contract && args_contracts[-2].is_a?(Contracts::Builtin::KeywordArgs)
+      args.insert(-2, kargs)
+    elsif args_contracts[-1].is_a?(Contracts::Builtin::KeywordArgs)
+      args << kargs
     end
     true
   end

data/lib/contracts/attrs.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Contracts
+  module Attrs
+    def attr_reader_with_contract(*names, contract)
+      names.each do |name|
+        Contract Contracts::None => contract
+        attr_reader(name)
+      end
+    end
+
+    def attr_writer_with_contract(*names, contract)
+      names.each do |name|
+        Contract contract => contract
+        attr_writer(name)
+      end
+    end
+
+    def attr_accessor_with_contract(*names, contract)
+      attr_reader_with_contract(*names, contract)
+      attr_writer_with_contract(*names, contract)
+    end
+  end
+
+  include Attrs
+end

data/lib/contracts/builtin_contracts.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "contracts/formatters"
 require "set"
 
@@ -30,35 +32,35 @@ module Contracts
     # Check that an argument is a positive number.
     class Pos
       def self.valid? val
-        val && val.is_a?(Numeric) && val > 0
+        val.is_a?(Numeric) && val.positive?
       end
     end
 
     # Check that an argument is a negative number.
     class Neg
       def self.valid? val
-        val && val.is_a?(Numeric) && val < 0
+        val.is_a?(Numeric) && val.negative?
       end
     end
 
     # Check that an argument is an +Integer+.
     class Int
       def self.valid? val
-        val && val.is_a?(Integer)
+        val.is_a?(Integer)
       end
     end
 
     # Check that an argument is a natural number (includes zero).
     class Nat
       def self.valid? val
-        val && val.is_a?(Integer) && val >= 0
+        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
-        val && val.is_a?(Integer) && val > 0
+        val.is_a?(Integer) && val.positive?
       end
     end
 
@@ -96,6 +98,7 @@ module Contracts
     # Example: <tt>Or[Fixnum, Float]</tt>
     class Or < CallableClass
       def initialize(*vals)
+        super()
         @vals = vals
       end
 
@@ -107,9 +110,11 @@ module Contracts
       end
 
       def to_s
+        # rubocop:disable Style/StringConcatenation
         @vals[0, @vals.size-1].map do |x|
           InspectWrapper.create(x)
         end.join(", ") + " or " + InspectWrapper.create(@vals[-1]).to_s
+        # rubocop:enable Style/StringConcatenation
       end
     end
 
@@ -118,6 +123,7 @@ module Contracts
     # Example: <tt>Xor[Fixnum, Float]</tt>
     class Xor < CallableClass
       def initialize(*vals)
+        super()
         @vals = vals
       end
 
@@ -130,9 +136,11 @@ module Contracts
       end
 
       def to_s
+        # rubocop:disable Style/StringConcatenation
         @vals[0, @vals.size-1].map do |x|
           InspectWrapper.create(x)
         end.join(", ") + " xor " + InspectWrapper.create(@vals[-1]).to_s
+        # rubocop:enable Style/StringConcatenation
       end
     end
 
@@ -141,6 +149,7 @@ module Contracts
     # Example: <tt>And[Fixnum, Float]</tt>
     class And < CallableClass
       def initialize(*vals)
+        super()
         @vals = vals
       end
 
@@ -152,9 +161,11 @@ module Contracts
       end
 
       def to_s
+        # rubocop:disable Style/StringConcatenation
         @vals[0, @vals.size-1].map do |x|
           InspectWrapper.create(x)
         end.join(", ") + " and " + InspectWrapper.create(@vals[-1]).to_s
+        # rubocop:enable Style/StringConcatenation
       end
     end
 
@@ -164,6 +175,7 @@ module Contracts
     # Example: <tt>RespondTo[:password, :credit_card]</tt>
     class RespondTo < CallableClass
       def initialize(*meths)
+        super()
         @meths = meths
       end
 
@@ -185,6 +197,7 @@ module Contracts
     # Example: <tt>Send[:valid?]</tt>
     class Send < CallableClass
       def initialize(*meths)
+        super()
         @meths = meths
       end
 
@@ -204,11 +217,12 @@ module Contracts
     # Example: <tt>Exactly[Numeric]</tt>
     class Exactly < CallableClass
       def initialize(cls)
+        super()
         @cls = cls
       end
 
       def valid?(val)
-        val.class == @cls
+        val.instance_of?(@cls)
       end
 
       def to_s
@@ -222,6 +236,7 @@ module Contracts
     # Example: <tt>Enum[:a, :b, :c]</tt>?
     class Enum < CallableClass
       def initialize(*vals)
+        super()
         @vals = vals
       end
 
@@ -235,6 +250,7 @@ module Contracts
     # Example: <tt>Eq[Class]</tt>
     class Eq < CallableClass
       def initialize(value)
+        super()
         @value = value
       end
 
@@ -252,6 +268,7 @@ module Contracts
     # Example: <tt>Not[nil]</tt>
     class Not < CallableClass
       def initialize(*vals)
+        super()
         @vals = vals
       end
 
@@ -275,12 +292,14 @@ module Contracts
     # Example: <tt>CollectionOf[Array, Num]</tt>
     class CollectionOf < CallableClass
       def initialize(collection_class, contract)
+        super()
         @collection_class = collection_class
         @contract = contract
       end
 
       def valid?(vals)
         return false unless vals.is_a?(@collection_class)
+
         vals.all? do |val|
           res, _ = Contract.valid?(val, @contract)
           res
@@ -298,7 +317,7 @@ module Contracts
         end
 
         def new(contract)
-          @before_new && @before_new.call
+          @before_new&.call
           CollectionOf.new(@collection_class, contract)
         end
 
@@ -324,7 +343,9 @@ module Contracts
     # Example: <tt>Args[Or[String, Num]]</tt>
     class Args < CallableClass
       attr_reader :contract
+
       def initialize(contract)
+        super()
         @contract = contract
       end
 
@@ -343,6 +364,7 @@ module Contracts
     # Example: <tt>RangeOf[Nat]</tt>, <tt>RangeOf[Date]</tt>, ...
     class RangeOf < CallableClass
       def initialize(contract)
+        super()
         @contract = contract
       end
 
@@ -364,6 +386,7 @@ module Contracts
       INVALID_KEY_VALUE_PAIR = "You should provide only one key-value pair to HashOf contract"
 
       def initialize(key, value = nil)
+        super()
         if value
           @key   = key
           @value = value
@@ -376,6 +399,7 @@ module Contracts
 
       def valid?(hash)
         return false unless hash.is_a?(Hash)
+
         keys_match = hash.keys.map { |k| Contract.valid?(k, @key) }.all?
         vals_match = hash.values.map { |v| Contract.valid?(v, @value) }.all?
 
@@ -393,15 +417,39 @@ module Contracts
       end
     end
 
+    # Use this to specify the Hash characteristics. This contracts fails
+    # if there are any extra keys that don't have contracts on them.
+    # Example: <tt>StrictHash[{ a: String, b: Bool }]</tt>
+    class StrictHash < CallableClass
+      attr_reader :contract_hash
+
+      def initialize(contract_hash)
+        super()
+        @contract_hash = contract_hash
+      end
+
+      def valid?(arg)
+        return false unless arg.is_a?(Hash)
+        return false unless arg.keys.sort.eql?(contract_hash.keys.sort)
+
+        contract_hash.all? do |key, contract|
+          contract_hash.key?(key) && Contract.valid?(arg[key], contract)
+        end
+      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)
+        super()
         @options = options
       end
 
       def valid?(hash)
+        return false unless hash.is_a?(Hash)
         return false unless hash.keys - options.keys == []
+
         options.all? do |key, contract|
           Optional._valid?(hash, key, contract)
         end
@@ -420,6 +468,31 @@ module Contracts
       attr_reader :options
     end
 
+    # Use this for specifying contracts for class arguments
+    # Example: <tt>DescendantOf[ e: Range, f: Optional[Num] ]</tt>
+    class DescendantOf < CallableClass
+      def initialize(parent_class)
+        super()
+        @parent_class = parent_class
+      end
+
+      def valid?(given_class)
+        given_class.is_a?(Class) && given_class.ancestors.include?(parent_class)
+      end
+
+      def to_s
+        "DescendantOf[#{parent_class}]"
+      end
+
+      def inspect
+        to_s
+      end
+
+      private
+
+      attr_reader :parent_class
+    end
+
     # Use this for specifying optional keyword argument
     # Example: <tt>Optional[Num]</tt>
     class Optional < CallableClass
@@ -428,11 +501,13 @@ module Contracts
 
       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)
+        super()
         @contract = contract
         @within_opt_hash = false
       end
@@ -461,6 +536,7 @@ module Contracts
 
       def ensure_within_opt_hash
         return if within_opt_hash
+
         fail ArgumentError, UNABLE_TO_USE_OUTSIDE_OF_OPT_HASH
       end
 
@@ -486,7 +562,9 @@ module Contracts
     # Example: <tt>Func[Num => Num] # the function should take a number and return a number</tt>
     class Func < CallableClass
       attr_reader :contracts
+
       def initialize(*contracts)
+        super()
         @contracts = contracts
       end
     end