contracts 0.16.1 → 0.17.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f008c5c8ab0f0e8d60c14f29413e2b6b262f53b53d9bdc34a618d438a3065a2
-  data.tar.gz: 812d80e1696cfe92350c4402d5a2368589d7ecca4b1849f6ca110a8afe239d18
+  metadata.gz: 8a151d83a8b03910e5dd1171c384e0ea8a01ff9437d81140f995358d888ac0fa
+  data.tar.gz: b92d01b9dd8702b866e004c41834781885d8178b1ceacb1e5166982243a13a49
 SHA512:
-  metadata.gz: 37e8c58c78748244de26e797301d7510a16263a1373a45b69b01749f34d8a0990c60b9ec02adf49b745abf1493911e61596b90d37af60663abd84e8f5c5273d5
-  data.tar.gz: 502421a171fc8284295c9253edb405321c05ef871d0aafb52b80e9b7cf5099f216b7f71ca3dce696e582854feedaad80faa00394a0fb903760fa732c34cd87a0
+  metadata.gz: 94df8b86d22522b7c573f9cd7b3ee425568b024d7d3a88701759a2b47cdce691bd9ce7ec45710e7e8dafb993c7aa1cb93d6d9a0110d3c4effeece4b24fda29a9
+  data.tar.gz: dbbddaf090e48b52cde302f6a6b5b89fc84045e9c392ef1d34ddcfb2e149f65c3da825b8140ebd4b3d36672ed933b841e1c59b9e684098bb3144762bcd7b4b50

data/.github/workflows/code_style_checks.yaml

@@ -22,11 +22,11 @@ jobs:
         os:
           - ubuntu
         ruby:
-          - "2.7"
+          - "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,22 +22,16 @@ jobs:
         os:
           - ubuntu
         ruby:
-          - "2.1"
-          - "2.2"
-          - "2.3"
-          - "2.4"
-          - "2.5"
-          - "2.6"
-          - "2.7"
-        test_command: ["bundle exec rspec && bundle exec cucumber"]
-        include:
-          - os: ubuntu
-            ruby: "2.4.2"
-            test_command: "bundle exec rspec"
+          - "3.3"
+          - "3.2"
+          - "3.1"
+          - "3.0"
+        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

@@ -1,12 +1,17 @@
 inherit_from: .rubocop_todo.yml
 
 AllCops:
-  TargetRubyVersion: 1.9
+  TargetRubyVersion: 3.0
   DisplayCopNames: true
+  NewCops: disable
   Exclude:
+    - "benchmarks/**/*"
     - "tmp/**/*"
     - "vendor/**/*"
+    - "script/**/*.rb"
+    - "spec/fixtures/*.rb"
     - "spec/ruby_version_specific/*.rb"
+    - "spec/*.rb"
 
 # forces method defs to have params in parens
 Style/MethodDefParentheses:
@@ -38,7 +43,7 @@ Lint/UnusedMethodArgument:
   Enabled: false
 
 # changes x ** 2 to x**2
-Style/SpaceAroundOperators:
+Layout/SpaceAroundOperators:
   Enabled: false
 
 # doesn't allow vars starting with _
@@ -56,10 +61,10 @@ Style/Documentation:
 
 # enforces line length of 80
 # TODO enable
-Metrics/LineLength:
+Layout/LineLength:
   Enabled: false
 
-# triggered by Contract ({ :name => String, :age => Fixnum }) => nil
+# triggered by Contract ({ :name => String, :age => Integer }) => nil
 Lint/ParenthesesAsGroupedExpression:
   Enabled: false
 
@@ -101,7 +106,7 @@ Lint/DuplicateMethods:
 Style/TrivialAccessors:
   Enabled: false
 
-Style/MultilineOperationIndentation:
+Layout/MultilineOperationIndentation:
   EnforcedStyle: indented
 
 # Asks you to use %w{array of words} if possible.
@@ -111,12 +116,12 @@ Style/WordArray:
 
 # conflicts with contracts
 # we define contracts like `Baz = 1`
-Style/ConstantName:
+Naming/ConstantName:
   Enabled: false
 
 # `Contract` violates this, otherwise a good cop (enforces snake_case method names)
 # TODO possible to get this enabled but ignore `Contract`?
-Style/MethodName:
+Naming/MethodName:
   Enabled: false
 
 # checks for !!
@@ -129,9 +134,30 @@ Metrics/ParameterLists:
   Enabled: false
 
 # Checks that braces used for hash literals have or don't have surrounding space depending on configuration.
-Style/SpaceInsideHashLiteralBraces:
+Layout/SpaceInsideHashLiteralBraces:
   Enabled: false
 
 # TODO enable
 Style/SpecialGlobalVars:
   Enabled: false
+
+Style/IfUnlessModifier:
+  Enabled: false
+
+Naming/MemoizedInstanceVariableName:
+  Enabled: false
+
+Layout/FirstHashElementIndentation:
+  EnforcedStyle: consistent
+
+Layout/HashAlignment:
+  EnforcedColonStyle: table
+
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: consistent_comma
+
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: consistent_comma
+
+Style/TrailingCommaInArguments:
+  EnforcedStyleForMultiline: consistent_comma

data/.rubocop_todo.yml

@@ -6,6 +6,9 @@
 # Note that changes in the inspected code, or installation of new
 # versions of RuboCop, may require this file to be generated again.
 
+require:
+  - rubocop-performance
+
 # Offense count: 2
 Lint/NonLocalExitFromIterator:
   Exclude:
@@ -32,14 +35,14 @@ Style/Alias:
 # Offense count: 1
 # Cop supports --auto-correct.
 # Configuration parameters: AllowAdjacentOneLineDefs.
-Style/EmptyLineBetweenDefs:
+Layout/EmptyLineBetweenDefs:
   Exclude:
     - 'benchmarks/wrap_test.rb'
 
 # Offense count: 1
 # Cop supports --auto-correct.
 # Configuration parameters: AllowForAlignment, ForceEqualSignAlignment.
-Style/ExtraSpacing:
+Layout/ExtraSpacing:
   Exclude:
     - 'spec/builtin_contracts_spec.rb'
 
@@ -58,7 +61,7 @@ Style/IfInsideElse:
 # Cop supports --auto-correct.
 # Configuration parameters: EnforcedStyle, SupportedStyles.
 # SupportedStyles: symmetrical, new_line, same_line
-Style/MultilineHashBraceLayout:
+Layout/MultilineHashBraceLayout:
   Exclude:
     - 'spec/contracts_spec.rb'
     - 'spec/fixtures/fixtures.rb'
@@ -130,6 +133,6 @@ Style/TrailingUnderscoreVariable:
 
 # Offense count: 1
 # Cop supports --auto-correct.
-Style/UnneededInterpolation:
+Style/RedundantInterpolation:
   Exclude:
     - 'lib/contracts/formatters.rb'

data/CHANGELOG.markdown

@@ -1,6 +1,8 @@
 
 ## [v0.16.1] - 2021-04-17
 
+[v0.16.1]: https://github.com/egonSchiele/contracts.ruby/compare/v0.16.0...v0.16.1
+
 - Enhancement: Pretty-print contracts in error messages - [Corey Farwell](https://github.com/frewsxcv) [#289](https://github.com/egonSchiele/contracts.ruby/pull/289)
 - Bugfix: Fix `attr_accessor_with_contract` with multiple attribute names input - [Kevin Yeh](https://github.com/kyeah) [#259](https://github.com/egonSchiele/contracts.ruby/pull/259)
 - Bugfix: Fix "stack level too deep" in CI builds - [md-work](https://github.com/md-work) [#283](https://github.com/egonSchiele/contracts.ruby/pull/283)

data/Gemfile

@@ -1,17 +1,21 @@
+# frozen_string_literal: true
+
 source "https://rubygems.org"
 
 gemspec
 
 group :test do
-  gem "rspec"
   gem "aruba"
   gem "cucumber", "~> 1.3.20"
-  gem "rubocop", "~> 0.41.2" if RUBY_VERSION >= "2"
+  gem "rspec"
+
+  gem "rubocop", ">= 1.0.0"
+  gem "rubocop-performance", ">= 1.0.0"
 end
 
 group :development do
-  gem "relish"
   gem "method_profiler"
-  gem "ruby-prof"
   gem "rake"
+  gem "relish"
+  gem "ruby-prof"
 end

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/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 task :default => [:spec]
 
 task :add_tag do

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require File.expand_path(File.join(__FILE__, "../lib/contracts/version"))
 
 Gem::Specification.new do |s|
@@ -10,8 +12,5 @@ Gem::Specification.new do |s|
   s.files       = `git ls-files`.split("\n")
   s.homepage    = "https://github.com/egonSchiele/contracts.ruby"
   s.license     = "BSD-2-Clause"
-  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)
-  "
+  s.required_ruby_version = [">= 3.0", "< 4"]
 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/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/attrs.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Contracts
   module Attrs
     def attr_reader_with_contract(*names, contract)