contracts 0.17 → 0.17.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cbf4bff58a593998c5902920fff3c0a808ca5eb97ec9cad3646df370435421c7
-  data.tar.gz: 02e5cffce164a25ae463b22e9f8b85c810d50c9c2875d09a3e83751afebac012
+  metadata.gz: 8a151d83a8b03910e5dd1171c384e0ea8a01ff9437d81140f995358d888ac0fa
+  data.tar.gz: b92d01b9dd8702b866e004c41834781885d8178b1ceacb1e5166982243a13a49
 SHA512:
-  metadata.gz: c6911f4383b0140c40bc08c838a3044897c3c9ac3c577fae4b3806879cbfed12f044f8ee1336305b1599c10af1bfb5aabe9ae2e8f1f9ffd94774d4de789e8402
-  data.tar.gz: 25c8ecfe04e846ba55d87b33a43e0a38422440d0a963066ac67217edd8ebc396cbb2309b50704ea6f4dc4609bacbfb3fb3b501ef0a40210fe1877df5c6fbb7f8
+  metadata.gz: 94df8b86d22522b7c573f9cd7b3ee425568b024d7d3a88701759a2b47cdce691bd9ce7ec45710e7e8dafb993c7aa1cb93d6d9a0110d3c4effeece4b24fda29a9
+  data.tar.gz: dbbddaf090e48b52cde302f6a6b5b89fc84045e9c392ef1d34ddcfb2e149f65c3da825b8140ebd4b3d36672ed933b841e1c59b9e684098bb3144762bcd7b4b50

data/.github/workflows/code_style_checks.yaml

@@ -22,11 +22,11 @@ jobs:
         os:
           - ubuntu
         ruby:
-          - "3.0"
+          - "3.3"
     runs-on: ${{ matrix.os }}-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
       - name: Setup Ruby
         uses: ruby/setup-ruby@v1
         with:

data/.github/workflows/tests.yaml

@@ -22,16 +22,16 @@ jobs:
         os:
           - ubuntu
         ruby:
+          - "3.3"
+          - "3.2"
+          - "3.1"
           - "3.0"
-        test_command: ["bundle exec rspec && bundle exec cucumber"]
-        include:
-          - os: ubuntu
-            ruby: "3.0"
-            test_command: "bundle exec rspec"
+        test_command:
+          - "bundle exec rspec && bundle exec cucumber"
     runs-on: ${{ matrix.os }}-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
       - name: Setup Ruby
         uses: ruby/setup-ruby@v1
         with:

data/.rubocop.yml

@@ -64,7 +64,7 @@ Style/Documentation:
 Layout/LineLength:
   Enabled: false
 
-# triggered by Contract ({ :name => String, :age => Fixnum }) => nil
+# triggered by Contract ({ :name => String, :age => Integer }) => nil
 Lint/ParenthesesAsGroupedExpression:
   Enabled: false
 

data/README.md

@@ -1,11 +1,19 @@
 This project is looking for a new maintainer! [More details here](https://github.com/egonSchiele/contracts.ruby/issues/249)
 
-# contracts.ruby [![GitHub Build Status](https://img.shields.io/github/workflow/status/egonSchiele/contracts.ruby/Tests?style=flat-square)](https://github.com/egonSchiele/contracts.ruby/actions?query=workflow%3ATests) [![Join the chat at https://gitter.im/egonSchiele/contracts.ruby](https://img.shields.io/badge/gitter-join%20chat-brightgreen.svg)](https://gitter.im/egonSchiele/contracts.ruby)
+
+
+# contracts.ruby [![GitHub Build Status](https://img.shields.io/github/actions/workflow/status/egonSchiele/contracts.ruby/tests.yaml?branch=master&style=flat-square)](https://github.com/egonSchiele/contracts.ruby/actions/workflows/tests.yaml) [![Join the chat at https://gitter.im/egonSchiele/contracts.ruby](https://img.shields.io/badge/gitter-join%20chat-brightgreen.svg)](https://gitter.im/egonSchiele/contracts.ruby)
 
 Contracts let you clearly – even beautifully – express how your code behaves, and free you from writing tons of boilerplate, defensive code.
 
 You can think of contracts as `assert` on steroids.
 
+## 0.17.x = Ruby 3.x only
+
+0.17.x only supports Ruby 3.x  
+Looking for Ruby 2.x support?  
+Use 0.16.x  
+
 ## Installation
 
     gem install contracts
@@ -83,7 +91,7 @@ Using contracts.ruby results in very little slowdown. Check out [this blog post]
 
 **Q.** What Rubies can I use this with?
 
-**A.** It's been tested with `2.1`, `2.2`, `2.3`, `2.4`, `2.5`, `2.6` and `2.7`.
+**A.** It's been tested with `3.0` and `3.1`. (In case this list becomes outdated see [`.github/workflows/tests.yaml`](/.github/workflows/tests.yaml))
 
 If you're using the library, please [let me know](https://github.com/egonSchiele) what project you're using it on :)
 

data/TUTORIAL.md

@@ -80,8 +80,8 @@ contracts.ruby comes with a lot of built-in contracts, including the following:
 
 * Logical combinations
   * [`Maybe`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/Maybe) – specifies that a value _may be_ nil, e.g. `Maybe[String]` (equivalent to `Or[String,nil]`)
-  * [`Or`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/Or) – passes if any of the given contracts pass, e.g. `Or[Fixnum, Float]`
-  * [`Xor`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/Xor) – passes if exactly one of the given contracts pass, e.g. `Xor[Fixnum, Float]`
+  * [`Or`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/Or) – passes if any of the given contracts pass, e.g. `Or[Integer, Float]`
+  * [`Xor`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/Xor) – passes if exactly one of the given contracts pass, e.g. `Xor[Integer, Float]`
   * [`And`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/And) – passes if all contracts pass, e.g. `And[Nat, -> (n) { n.even? }]`
   * [`Not`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/Not) – passes if all contracts fail for the given argument, e.g. `Not[nil]`
 
@@ -89,7 +89,7 @@ contracts.ruby comes with a lot of built-in contracts, including the following:
   * [`ArrayOf`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/ArrayOf) – checks that the argument is an array, and all elements pass the given contract, e.g. `ArrayOf[Num]`
   * [`SetOf`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/SetOf) – checks that the argument is a set, and all elements pass the given contract, e.g. `SetOf[Num]`
   * [`HashOf`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/HashOf) – checks that the argument is a hash, and all keys and values pass the given contract, e.g. `HashOf[Symbol => String]` or `HashOf[Symbol,String]`
-  * [`StrictHash`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/StrictHash) – checks that the argument is a hash, and every key passed is present in the given contract, e.g. `StrictHash[{ :description => String, :number => Fixnum }]`
+  * [`StrictHash`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/StrictHash) – checks that the argument is a hash, and every key passed is present in the given contract, e.g. `StrictHash[{ :description => String, :number => Integer }]`
   * [`RangeOf`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/RangeOf) – checks that the argument is a range whose elements (#first and #last) pass the given contract, e.g. `RangeOf[Date]`
   * [`Enum`](http://www.rubydoc.info/gems/contracts/Contracts/Builtin/Enum) – checks that the argument is part of a given collection of objects, e.g. `Enum[:a, :b, :c]`
 
@@ -152,7 +152,7 @@ end
 
 You always need to specify a contract for the return value. In this example, `hello` doesn't return anything, so the contract is `nil`. Now you know that you can use a constant like `nil` as the end of a contract. Valid values for a contract are:
 
-- the name of a class (like `String` or `Fixnum`)
+- the name of a class (like `String` or `Integer`)
 - a constant (like `nil` or `1`)
 - a `Proc` that takes a value and returns true or false to indicate whether the contract passed or not
 - a class that responds to the `valid?` class method (more on this later)
@@ -161,32 +161,32 @@ You always need to specify a contract for the return value. In this example, `he
 ### A Double Function
 
 ```ruby
-Contract C::Or[Fixnum, Float] => C::Or[Fixnum, Float]
+Contract C::Or[Integer, Float] => C::Or[Integer, Float]
 def double(x)
   2 * x
 end
 ```
 
 Sometimes you want to be able to choose between a few contracts. `Or` takes a variable number of contracts and checks the argument against all of them. If it passes for any of the contracts, then the `Or` contract passes.
-This introduces some new syntax. One of the valid values for a contract is an instance of a class that responds to the `valid?` method. This is what `Or[Fixnum, Float]` is. The longer way to write it would have been:
+This introduces some new syntax. One of the valid values for a contract is an instance of a class that responds to the `valid?` method. This is what `Or[Integer, Float]` is. The longer way to write it would have been:
 
 ```ruby
-Contract C::Or.new(Fixnum, Float) => C::Or.new(Fixnum, Float)
+Contract C::Or.new(Integer, Float) => C::Or.new(Integer, Float)
 ```
 
 All the built-in contracts have overridden the square brackets (`[]`) to give the same functionality. So you could write
 
 ```ruby
-Contract C::Or[Fixnum, Float] => C::Or[Fixnum, Float]
+Contract C::Or[Integer, Float] => C::Or[Integer, Float]
 ```
 
 or
 
 ```ruby
-Contract C::Or.new(Fixnum, Float) => C::Or.new(Fixnum, Float)
+Contract C::Or.new(Integer, Float) => C::Or.new(Integer, Float)
 ```
 
-whichever you prefer. They both mean the same thing here: make a new instance of `Or` with `Fixnum` and `Float`. Use that instance to validate the argument.
+whichever you prefer. They both mean the same thing here: make a new instance of `Or` with `Integer` and `Float`. Use that instance to validate the argument.
 
 ### A Product Function
 
@@ -455,7 +455,7 @@ Now you can use `Person` wherever you would have used `Or[Hash, nil]`. Your code
 
 Contracts are very easy to define. To re-iterate, there are 5 kinds of contracts:
 
-- the name of a class (like `String` or `Fixnum`)
+- the name of a class (like `String` or `Integer`)
 - a constant (like `nil` or `1`)
 - a `Proc` that takes a value and returns true or false to indicate whether the contract passed or not
 - a class that responds to the `valid?` class method (more on this later)
@@ -511,7 +511,7 @@ The `Or` contract takes a sequence of contracts, and passes if any of them pass.
 This class inherits from `CallableClass`, which allows us to use `[]` when using the class:
 
 ```ruby
-Contract C::Or[Fixnum, Float] => C::Num
+Contract C::Or[Integer, Float] => C::Num
 def double(x)
   2 * x
 end
@@ -520,7 +520,7 @@ end
 Without `CallableClass`, we would have to use `.new` instead:
 
 ```ruby
-Contract C::Or.new(Fixnum, Float) => C::Num
+Contract C::Or.new(Integer, Float) => C::Num
 def double(x)
 # etc
 ```
@@ -723,7 +723,7 @@ class MyBirthday < Struct.new(:day, :month)
   invariant(:day) { 1 <= day && day <= 31 }
   invariant(:month) { 1 <= month && month <= 12 }
 
-  Contract C::None => Fixnum
+  Contract C::None => Integer
   def silly_next_day!
     self.day += 1
   end

data/contracts.gemspec

@@ -13,8 +13,4 @@ Gem::Specification.new do |s|
   s.homepage    = "https://github.com/egonSchiele/contracts.ruby"
   s.license     = "BSD-2-Clause"
   s.required_ruby_version = [">= 3.0", "< 4"]
-  s.post_install_message = "
-    0.16.x will be the supporting Ruby 2.x and be feature frozen (only fixes will be released)
-    For Ruby 3.x use 0.17.x or later (might not be released yet)
-  "
 end

data/features/builtin_contracts/keyword_args_with_optional_positional_args.feature

@@ -0,0 +1,76 @@
+Feature: KeywordArgs when used with optional positional arguments
+
+  Checks that the argument is an options hash, and all required keyword arguments are present, and all values pass their respective contracts
+
+  ```ruby
+  Contract Any, KeywordArgs[:number => Num, :description => Optional[String]] => Any
+  ```
+
+  Background:
+    Given a file named "keyword_args_with_optional_positional_args_usage.rb" with:
+    """ruby
+    require "contracts"
+    C = Contracts
+
+    class Example
+      include Contracts::Core
+
+      Contract C::Any, String, C::KeywordArgs[b: C::Optional[String]] => Symbol
+      def foo(output, a = 'a', b: 'b')
+        p [a, b]
+        output
+      end
+    end
+    """
+
+  Scenario: Accepts arguments when only require arguments filled and valid
+    Given a file named "accepts_all_filled_valid_args.rb" with:
+    """ruby
+    require "./keyword_args_with_optional_positional_args_usage"
+    puts Example.new.foo(:output)
+    """
+    When I run `ruby accepts_all_filled_valid_args.rb`
+    Then output should contain:
+    """
+    ["a", "b"]
+    output
+    """
+
+  Scenario: Accepts arguments when all filled and valid
+    Given a file named "accepts_all_filled_valid_args.rb" with:
+    """ruby
+    require "./keyword_args_with_optional_positional_args_usage"
+    puts Example.new.foo(:output, 'c', b: 'd')
+    """
+    When I run `ruby accepts_all_filled_valid_args.rb`
+    Then output should contain:
+    """
+    ["c", "d"]
+    output
+    """
+
+  Scenario: Accepts arguments when only require arguments & optional keyword arguments filled and valid
+    Given a file named "accepts_all_filled_valid_args.rb" with:
+    """ruby
+    require "./keyword_args_with_optional_positional_args_usage"
+    puts Example.new.foo(:output, b: 'd')
+    """
+    When I run `ruby accepts_all_filled_valid_args.rb`
+    Then output should contain:
+    """
+    ["a", "d"]
+    output
+    """
+
+  Scenario: Accepts arguments when only require arguments & optional positional arguments filled and valid
+    Given a file named "accepts_all_filled_valid_args.rb" with:
+    """ruby
+    require "./keyword_args_with_optional_positional_args_usage"
+    puts Example.new.foo(:output, 'c')
+    """
+    When I run `ruby accepts_all_filled_valid_args.rb`
+    Then output should contain:
+    """
+    ["c", "b"]
+    output
+    """

data/features/builtin_contracts/none.feature

@@ -26,7 +26,8 @@ Feature: None
     def autorescue
       yield
     rescue => e
-      puts e.inspect
+      # Since ruby 3.2 the `#inspect` output becomes a bit different
+      puts e.inspect.gsub(/^#</, "").gsub(/Error:\"/, "Error: ")
     end
     """
     Given a file named "none_usage.rb" with:
@@ -42,6 +43,11 @@ Feature: None
       def self.a_symbol(*args)
         :a_symbol
       end
+
+      Contract C::None => Symbol
+      def a_symbol(*args)
+        :a_symbol
+      end
     end
     """
 
@@ -61,14 +67,14 @@ Feature: None
     Given a file named "anything.rb" with:
     """ruby
     require "./none_usage"
-    autorescue { Example.a_symbol(nil) }
-    autorescue { Example.a_symbol(12) }
-    autorescue { Example.a_symbol(37.5) }
-    autorescue { Example.a_symbol("foo") }
-    autorescue { Example.a_symbol(:foo) }
-    autorescue { Example.a_symbol({}) }
-    autorescue { Example.a_symbol([]) }
-    autorescue { Example.a_symbol(Object) }
+    autorescue { Example.new.a_symbol(nil) }
+    autorescue { Example.new.a_symbol(12) }
+    autorescue { Example.new.a_symbol(37.5) }
+    autorescue { Example.new.a_symbol("foo") }
+    autorescue { Example.new.a_symbol(:foo) }
+    autorescue { Example.new.a_symbol({}) }
+    autorescue { Example.new.a_symbol([]) }
+    autorescue { Example.new.a_symbol(Object) }
     """
     When I run `ruby anything.rb`
 

data/lib/contracts/builtin_contracts.rb

@@ -95,7 +95,7 @@ module Contracts
 
     # Takes a variable number of contracts.
     # The contract passes if any of the contracts pass.
-    # Example: <tt>Or[Fixnum, Float]</tt>
+    # Example: <tt>Or[Integer, Float]</tt>
     class Or < CallableClass
       def initialize(*vals)
         super()
@@ -120,7 +120,7 @@ module Contracts
 
     # Takes a variable number of contracts.
     # The contract passes if exactly one of those contracts pass.
-    # Example: <tt>Xor[Fixnum, Float]</tt>
+    # Example: <tt>Xor[Integer, Float]</tt>
     class Xor < CallableClass
       def initialize(*vals)
         super()
@@ -146,7 +146,7 @@ module Contracts
 
     # Takes a variable number of contracts.
     # The contract passes if all contracts pass.
-    # Example: <tt>And[Fixnum, Float]</tt>
+    # Example: <tt>And[Integer, Float]</tt>
     class And < CallableClass
       def initialize(*vals)
         super()

data/lib/contracts/call_with.rb

@@ -12,8 +12,20 @@ module Contracts
       # 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
-      kargs_appended = maybe_append_options!(args, kargs, blk)
+      if @kargs_validator && !@kargs_validator[kargs]
+        data = {
+          arg:          kargs,
+          contract:     kargs_contract,
+          class:        klass,
+          method:       method,
+          contracts:    self,
+          arg_pos:      :keyword,
+          total_args:   args.size,
+          return_value: false,
+        }
+        return ParamContractError.new("as return value", data) if returns
+        return unless Contract.failure_callback(data)
+      end
 
       # Loop forward validating the arguments up to the splat (if there is one)
       (@args_contract_index || args.size).times do |i|
@@ -84,7 +96,6 @@ 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, **kargs, &blk)

data/lib/contracts/formatters.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
+# rubocop:disable Lint/RedundantRequireStatement
+# If removed, spec/module_spec fails
 require "pp"
+# rubocop:enable Lint/RedundantRequireStatement
 
 module Contracts
   # A namespace for classes related to formatting.

data/lib/contracts/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Contracts
-  VERSION = "0.17"
+  VERSION = "0.17.1"
 end

data/lib/contracts.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "contracts/version"
 require "contracts/attrs"
 require "contracts/builtin_contracts"
 require "contracts/decorators"
@@ -52,7 +53,7 @@ class Contract < Contracts::Decorator
     end
   end
 
-  attr_reader :args_contracts, :ret_contract, :klass, :method
+  attr_reader :args_contracts, :kargs_contract, :ret_contract, :klass, :method
 
   def initialize(klass, method, *contracts)
     super(klass, method)
@@ -69,6 +70,9 @@ class Contract < Contracts::Decorator
 
     # internally we just convert that return value syntax back to an array
     @args_contracts = contracts[0, contracts.size - 1] + contracts[-1].keys
+    # Extract contract for keyword arguments
+    @kargs_contract = args_contracts.find { |c| c.is_a?(Contracts::Builtin::KeywordArgs) }
+    args_contracts.delete(kargs_contract) if kargs_contract
 
     @ret_contract = contracts[-1].values[0]
 
@@ -76,6 +80,8 @@ class Contract < Contracts::Decorator
       Contract.make_validator(contract)
     end
 
+    @kargs_validator = kargs_contract ? Contract.make_validator(kargs_contract) : nil
+
     @args_contract_index = args_contracts.index do |contract|
       contract.is_a? Contracts::Args
     end
@@ -93,16 +99,6 @@ class Contract < Contracts::Decorator
 
     # ====
 
-    # == @has_options_contract
-    last_contract = args_contracts.last
-    penultimate_contract = args_contracts[-2]
-    @has_options_contract = if @has_proc_contract
-                              penultimate_contract.is_a?(Contracts::Builtin::KeywordArgs)
-                            else
-                              last_contract.is_a?(Contracts::Builtin::KeywordArgs)
-                            end
-    # ===
-
     @klass, @method = klass, method
   end
 
@@ -255,19 +251,6 @@ class Contract < Contracts::Decorator
     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, kargs, blk
-    return false unless @has_options_contract
-
-    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
-
   # Used to determine type of failure exception this contract should raise in case of failure
   def failure_exception
     if pattern_match?

data/spec/builtin_contracts_spec.rb

@@ -30,7 +30,7 @@ RSpec.describe "Contracts:" do
   end
 
   describe "Num:" do
-    it "should pass for Fixnums" do
+    it "should pass for Integers" do
       passes { @o.double(2) }
     end
 

data/spec/fixtures/fixtures.rb

@@ -100,11 +100,11 @@ class GenericExample
     end
   end
 
-  Contract ({ :name => String, :age => Fixnum }) => nil
+  Contract ({ :name => String, :age => Integer }) => nil
   def person(data)
   end
 
-  Contract C::StrictHash[{ :name => String, :age => Fixnum }] => nil
+  Contract C::StrictHash[{ :name => String, :age => Integer }] => nil
   def strict_person(data)
   end
 
@@ -119,7 +119,7 @@ class GenericExample
   def nested_hash_complex_contracts(data)
   end
 
-  Contract C::KeywordArgs[:name => String, :age => Fixnum] => nil
+  Contract C::KeywordArgs[:name => String, :age => Integer] => nil
   def person_keywordargs(name: "name", age: 10)
   end
 
@@ -529,30 +529,30 @@ class MyBirthday
     @month = month
   end
 
-  Contract C::None => Fixnum
+  Contract C::None => Integer
   def silly_next_day!
     self.day += 1
   end
 
-  Contract C::None => Fixnum
+  Contract C::None => Integer
   def silly_next_month!
     self.month += 1
   end
 
-  Contract C::None => Fixnum
+  Contract C::None => Integer
   def clever_next_day!
     return clever_next_month! if day == 31
     self.day += 1
   end
 
-  Contract C::None => Fixnum
+  Contract C::None => Integer
   def clever_next_month!
     return next_year! if month == 12
     self.month += 1
     self.day = 1
   end
 
-  Contract C::None => Fixnum
+  Contract C::None => Integer
   def next_year!
     self.month = 1
     self.day = 1
@@ -610,7 +610,7 @@ with_enabled_no_contracts do
       body + "!"
     end
 
-    Contract Fixnum, String => String
+    Contract Integer, String => String
     def on_response(status, body)
       "error #{status}: #{body}"
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: contracts
 version: !ruby/object:Gem::Version
-  version: '0.17'
+  version: 0.17.1
 platform: ruby
 authors:
 - Aditya Bhargava
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-07 00:00:00.000000000 Z
+date: 2024-10-05 00:00:00.000000000 Z
 dependencies: []
 description: This library provides contracts for Ruby. Contracts let you clearly express
   how your code behaves, and free you from writing tons of boilerplate, defensive
@@ -56,6 +56,7 @@ files:
 - features/builtin_contracts/hash_of.feature
 - features/builtin_contracts/int.feature
 - features/builtin_contracts/keyword_args.feature
+- features/builtin_contracts/keyword_args_with_optional_positional_args.feature
 - features/builtin_contracts/maybe.feature
 - features/builtin_contracts/nat.feature
 - features/builtin_contracts/nat_pos.feature
@@ -111,9 +112,7 @@ homepage: https://github.com/egonSchiele/contracts.ruby
 licenses:
 - BSD-2-Clause
 metadata: {}
-post_install_message: "\n    0.16.x will be the supporting Ruby 2.x and be feature
-  frozen (only fixes will be released)\n    For Ruby 3.x use 0.17.x or later (might
-  not be released yet)\n  "
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -131,8 +130,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.4.10
+signing_key:
 specification_version: 4
 summary: Contracts for Ruby.
 test_files: []