contracts 0.17.1 → 0.17.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a151d83a8b03910e5dd1171c384e0ea8a01ff9437d81140f995358d888ac0fa
-  data.tar.gz: b92d01b9dd8702b866e004c41834781885d8178b1ceacb1e5166982243a13a49
+  metadata.gz: 9a3e8688e39f57c226e61188412d8afcadc4b3836818b6287e774eb0c1c50e5a
+  data.tar.gz: fc13d092a656848c127f4f49dbb2a5cf60996c766a6309ed207ca6b556402f6d
 SHA512:
-  metadata.gz: 94df8b86d22522b7c573f9cd7b3ee425568b024d7d3a88701759a2b47cdce691bd9ce7ec45710e7e8dafb993c7aa1cb93d6d9a0110d3c4effeece4b24fda29a9
-  data.tar.gz: dbbddaf090e48b52cde302f6a6b5b89fc84045e9c392ef1d34ddcfb2e149f65c3da825b8140ebd4b3d36672ed933b841e1c59b9e684098bb3144762bcd7b4b50
+  metadata.gz: 386ecf5ae50df02c70b7adb1051b933866aea337213ae2103899b6a004fac17b3e453ea2efad63811e525acfc7372bc01ff4d553b8dbcb456d17f83beab3880c
+  data.tar.gz: ef5360cc907a2699d0f6aa4710b0b5d3fd75d89e58d766e8ef8f6a53a48702d271cf1779ac2a440fd1266aecbb369f126cff6bd503ecdad74728e47e6ad1f5dd

data/.github/dependabot.yml

@@ -0,0 +1,22 @@
+version: 2
+updates:
+
+  - package-ecosystem: bundler
+    directory: "/"
+    schedule:
+      interval: monthly
+      time: "06:00"
+      timezone: Asia/Hong_Kong
+    open-pull-requests-limit: 10
+    labels:
+      - "dependencies"
+
+  - package-ecosystem: github-actions
+    directory: "/"
+    schedule:
+      interval: monthly
+      time: "06:00"
+      timezone: Asia/Hong_Kong
+    open-pull-requests-limit: 10
+    labels:
+      - "dependencies"

data/.github/workflows/code_style_checks.yaml

@@ -6,11 +6,13 @@ on:
       - master
     paths-ignore:
       - 'README.md'
+      - 'CHANGELOG.markdown'
   push:
     branches:
       - master
     paths-ignore:
       - 'README.md'
+      - 'CHANGELOG.markdown'
 
 jobs:
   rubocop:
@@ -22,11 +24,11 @@ jobs:
         os:
           - ubuntu
         ruby:
-          - "3.3"
+          - "3.4"
     runs-on: ${{ matrix.os }}-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
       - name: Setup Ruby
         uses: ruby/setup-ruby@v1
         with:

data/.github/workflows/tests.yaml

@@ -6,11 +6,13 @@ on:
       - master
     paths-ignore:
       - 'README.md'
+      - 'CHANGELOG.markdown'
   push:
     branches:
       - master
     paths-ignore:
       - 'README.md'
+      - 'CHANGELOG.markdown'
 
 jobs:
   unit_tests:
@@ -20,22 +22,30 @@ jobs:
       fail-fast: false
       matrix:
         os:
-          - ubuntu
+          - ubuntu-latest
         ruby:
-          - "3.3"
-          - "3.2"
-          - "3.1"
           - "3.0"
-        test_command:
-          - "bundle exec rspec && bundle exec cucumber"
-    runs-on: ${{ matrix.os }}-latest
+          - "3.1"
+          - "3.2"
+          - "3.3"
+          - "3.4"
+          - "4.0"
+        allow_failures:
+          - false
+        include:
+          - os: ubuntu-latest
+            ruby: ruby-head
+            allow_failures: true
+    env:
+      ALLOW_FAILURES: "${{ matrix.allow_failures }}"
+    runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
       - name: Setup Ruby
         uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.ruby }}
           bundler-cache: true
       - name: Test
-        run: ${{ matrix.test_command }}
+        run: "bundle exec rspec && bundle exec rake cucumber || $ALLOW_FAILURES"

data/.rubocop_todo.yml

@@ -6,7 +6,7 @@
 # Note that changes in the inspected code, or installation of new
 # versions of RuboCop, may require this file to be generated again.
 
-require:
+plugins:
   - rubocop-performance
 
 # Offense count: 2

data/CHANGELOG.markdown

@@ -1,3 +1,26 @@
+## [v0.17.3]
+- Relax `required_ruby_version` to support Ruby 4.0
+- Bump cucumber, rubocop, actions/checkout
+
+## [v0.17.2] - 2024-10-06
+
+[v0.17.2]: https://github.com/egonSchiele/contracts.ruby/compare/v0.17.1...v0.17.2
+
+- Bugfix: Fix pattern matching  - [PikachuEXE](https://github.com/PikachuEXE) [#308](https://github.com/egonSchiele/contracts.ruby/pull/308)
+
+## [v0.17.1] - 2024-10-06
+
+[v0.17.1]: https://github.com/egonSchiele/contracts.ruby/compare/v0.17...v0.17.1
+
+- Bugfix: Fix keyword arguments contract when used with optional positional arguments - [PikachuEXE](https://github.com/PikachuEXE) [#305](https://github.com/egonSchiele/contracts.ruby/pull/305)
+- Enhancement: Always load version.rb, suppress legacy deprecation warning - [Vlad Pisanov](https://github.com/vlad-pisanov) [#301](https://github.com/egonSchiele/contracts.ruby/pull/306)
+- Enhancement: Update doc & spec about deprecated `Fixnum` to `Integer` - [PikachuEXE](https://github.com/PikachuEXE) [#301](https://github.com/egonSchiele/contracts.ruby/pull/301)
+
+## [v0.17] - 2021-09-28
+
+[v0.17]: https://github.com/egonSchiele/contracts.ruby/compare/v0.16.1...v0.17
+
+- Update implementation & spec to be 3.0 compatible **Support for Ruby 2 has been discontinued** - [PikachuEXE](https://github.com/PikachuEXE) [#295](https://github.com/egonSchiele/contracts.ruby/pull/295)
 
 ## [v0.16.1] - 2021-04-17
 
@@ -20,7 +43,7 @@
 [v0.15.0]: https://github.com/egonSchiele/contracts.ruby/compare/v0.14.0...v0.15.0
 
 - Bugfix: Func contract's return value isn't enforced with blocks - [Piotr Szmielew](https://github.com/esse) [#251](https://github.com/egonSchiele/contracts.ruby/pull/251)
-- Bugfx: Fix contracts used in AR-models - [Gert Goet](https://github.com/eval) [#237](https://github.com/egonSchiele/contracts.ruby/pull/237)
+- Bugfix: Fix contracts used in AR-models - [Gert Goet](https://github.com/eval) [#237](https://github.com/egonSchiele/contracts.ruby/pull/237)
 
 ## [v0.14.0] - 2016-04-26
 

data/Gemfile

@@ -6,7 +6,7 @@ gemspec
 
 group :test do
   gem "aruba"
-  gem "cucumber", "~> 1.3.20"
+  gem "cucumber", ">= 9.2.1"
   gem "rspec"
 
   gem "rubocop", ">= 1.0.0"

data/Rakefile

@@ -2,6 +2,14 @@
 
 task :default => [:spec]
 
+task :cucumber do
+  if RUBY_VERSION >= "3.4"
+    sh "cucumber --tags 'not @before_ruby_3_3'"
+  else
+    sh "cucumber --tags 'not @after_ruby_3_4'"
+  end
+end
+
 task :add_tag do
   `git tag -a v#{Contracts::VERSION} -m 'v#{Contracts::VERSION}'`
 end

data/contracts.gemspec

@@ -12,5 +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.required_ruby_version = [">= 3.0", "< 4"]
+  s.required_ruby_version = [">= 3.0", "< 5"]
 end

data/features/advanced/pattern_matching.feature

@@ -0,0 +1,133 @@
+Feature: Method Overloading
+
+  You can use contracts for method overloading! This is commonly called "pattern matching" in functional programming languages.
+
+  ```ruby
+  Contract 1 => 1
+  def fact x
+    x
+  end
+
+  Contract C::Num => C::Num
+  def fact x
+    x * fact(x - 1)
+  end
+  ```
+
+  Background:
+    Given a file named "method_overloading_with_positional_args_usage.rb" with:
+    """ruby
+    require "contracts"
+    C = Contracts
+
+    class Example
+      include Contracts::Core
+
+      Contract 1 => 1
+      def fact(x)
+        x
+      end
+
+      Contract C::Num => C::Num
+      def fact(x)
+        x * fact(x - 1)
+      end
+    end
+    """
+
+    Given a file named "method_overloading_with_keyword_args_usage.rb" with:
+    """ruby
+    require "contracts"
+    C = Contracts
+
+    class Example
+      include Contracts::Core
+
+      Contract C::KeywordArgs[age: Integer, size: Symbol] => String
+      def speak(age:, size:)
+        "age: #{age} size: #{size}"
+      end
+
+      Contract C::KeywordArgs[sound: String] => String
+      def speak(sound:)
+        "sound: #{sound}"
+      end
+    end
+    """
+
+  Scenario: Positional Args Method 1
+    Given a file named "positional_args_method_1.rb" with:
+    """ruby
+    require "./method_overloading_with_positional_args_usage"
+    puts Example.new.fact(1)
+    """
+    When I run `ruby positional_args_method_1.rb`
+    Then the output should contain:
+    """
+    1
+    """
+
+  Scenario: Positional Args Method 2
+    Given a file named "positional_args_method_2.rb" with:
+    """ruby
+    require "./method_overloading_with_positional_args_usage"
+    puts Example.new.fact(4)
+    """
+    When I run `ruby positional_args_method_2.rb`
+    Then the output should contain:
+    """
+    24
+    """
+
+  Scenario: Keyword Args Method 1
+    Given a file named "keyword_args_method_1.rb" with:
+    """ruby
+    require "./method_overloading_with_keyword_args_usage"
+    puts Example.new.speak(age: 5, size: :large)
+    """
+    When I run `ruby keyword_args_method_1.rb`
+    Then the output should contain:
+    """
+    age: 5 size: large
+    """
+
+  Scenario: Keyword Args Method 2
+    Given a file named "keyword_args_method_2.rb" with:
+    """ruby
+    require "./method_overloading_with_keyword_args_usage"
+    puts Example.new.speak(sound: "woof")
+    """
+    When I run `ruby keyword_args_method_2.rb`
+    Then the output should contain:
+    """
+    sound: woof
+    """
+
+  Scenario: Incorrect Positional Args Method
+    Given a file named "incorrect_positional_args_method.rb" with:
+    """ruby
+    require "contracts"
+    C = Contracts
+
+    class Example
+      include Contracts::Core
+
+      # Notice that this method's contract is wider than the one below
+      # This would cause this method to be called every time but never the one below
+      Contract C::Num => C::Num
+      def fact(x)
+        x * fact(x - 1)
+      end
+
+      Contract 1 => 1
+      def fact(x)
+        x
+      end
+    end
+    puts Example.new.fact(4)
+    """
+    When I run `ruby incorrect_positional_args_method.rb`
+    Then the output should contain:
+    """
+    stack level too deep (SystemStackError)
+    """

data/features/basics/{pretty-print.feature → pretty-print_@before_ruby_3_3.feature}

@@ -1,4 +1,5 @@
-Feature: Pretty printing Contract violations
+@before_ruby_3_3
+Feature: Pretty printing Contract violations (Ruby 3.3-)
 
   Scenario: Big array argument being passed to big array method parameter
     Given a file named "example.rb" with:

data/features/basics/pretty-print_after_ruby_3_4.feature

@@ -0,0 +1,242 @@
+@after_ruby_3_4
+Feature: Pretty printing Contract violations (Ruby 3.4+)
+
+  Scenario: Big array argument being passed to big array method parameter
+    Given a file named "example.rb" with:
+    """ruby
+    require "contracts"
+    C = Contracts
+
+    class Example
+      include Contracts::Core
+
+      class << self
+        Contract [
+            C::Or[String, Symbol],
+            C::Or[String, Symbol],
+            C::Or[String, Symbol],
+            C::Or[String, Symbol],
+            C::Or[String, Symbol],
+            C::Or[String, Symbol],
+            C::Or[String, Symbol]
+        ] => nil
+        def run(data)
+          nil
+        end
+      end
+    end
+
+    puts Example.run([
+      ["foo", "foo"],
+      ["foo", "foo"],
+      ["foo", "foo"],
+      ["foo", "foo"],
+      ["foo", "foo"],
+      ["foo", "foo"],
+      ["foo", "foo"],
+      ["foo", "foo"],
+      ["foo", "foo"]
+    ])
+    """
+    When I run `ruby example.rb`
+    Then the output should contain:
+    """
+    : Contract violation for argument 1 of 1: (ParamContractError)
+            Expected: [(String or Symbol),
+                       (String or Symbol),
+                       (String or Symbol),
+                       (String or Symbol),
+                       (String or Symbol),
+                       (String or Symbol),
+                       (String or Symbol)],
+            Actual: [["foo", "foo"],
+                     ["foo", "foo"],
+                     ["foo", "foo"],
+                     ["foo", "foo"],
+                     ["foo", "foo"],
+                     ["foo", "foo"],
+                     ["foo", "foo"],
+                     ["foo", "foo"],
+                     ["foo", "foo"]]
+            Value guarded in: Example::run
+            With Contract: Array => NilClass
+            At: example.rb:17
+    """
+
+  Scenario: Big array value being returned from method expecting different big array type
+    Given a file named "example.rb" with:
+    """ruby
+    require "contracts"
+    C = Contracts
+
+    class Example
+      include Contracts::Core
+
+      class << self
+        Contract C::None => [
+            C::Or[String, Symbol],
+            C::Or[String, Symbol],
+            C::Or[String, Symbol],
+            C::Or[String, Symbol],
+            C::Or[String, Symbol],
+            C::Or[String, Symbol],
+            C::Or[String, Symbol]
+        ]
+        def run
+          [
+            ["foo", "foo"],
+            ["foo", "foo"],
+            ["foo", "foo"],
+            ["foo", "foo"],
+            ["foo", "foo"],
+            ["foo", "foo"],
+            ["foo", "foo"],
+            ["foo", "foo"],
+            ["foo", "foo"]
+          ]
+        end
+      end
+    end
+
+    puts Example.run
+    """
+    When I run `ruby example.rb`
+    Then the output should contain:
+    """
+    : Contract violation for return value: (ReturnContractError)
+            Expected: [(String or Symbol),
+                       (String or Symbol),
+                       (String or Symbol),
+                       (String or Symbol),
+                       (String or Symbol),
+                       (String or Symbol),
+                       (String or Symbol)],
+            Actual: [["foo", "foo"],
+                     ["foo", "foo"],
+                     ["foo", "foo"],
+                     ["foo", "foo"],
+                     ["foo", "foo"],
+                     ["foo", "foo"],
+                     ["foo", "foo"],
+                     ["foo", "foo"],
+                     ["foo", "foo"]]
+            Value guarded in: Example::run
+            With Contract: None => Array
+            At: example.rb:17
+    """
+
+  Scenario: Big hash argument being passed to big hash method parameter
+    Given a file named "example.rb" with:
+    """ruby
+    require "contracts"
+    C = Contracts
+
+    class Example
+      include Contracts::Core
+
+      class << self
+        Contract ({
+            a: C::Or[String, Symbol],
+            b: C::Or[String, Symbol],
+            c: C::Or[String, Symbol],
+            d: C::Or[String, Symbol],
+            e: C::Or[String, Symbol],
+            f: C::Or[String, Symbol],
+            g: C::Or[String, Symbol]
+        }) => nil
+        def run(data)
+          nil
+        end
+      end
+    end
+
+    puts Example.run({
+      a: ["foo", "foo"],
+      b: ["foo", "foo"],
+      c: ["foo", "foo"],
+      d: ["foo", "foo"],
+      e: ["foo", "foo"],
+      f: ["foo", "foo"],
+      g: ["foo", "foo"]
+    })
+    """
+    When I run `ruby example.rb`
+    Then the output should contain:
+    """
+    : Contract violation for argument 1 of 1: (ParamContractError)
+            Expected: {a: (String or Symbol),
+                       b: (String or Symbol),
+                       c: (String or Symbol),
+                       d: (String or Symbol),
+                       e: (String or Symbol),
+                       f: (String or Symbol),
+                       g: (String or Symbol)},
+            Actual: {a: ["foo", "foo"],
+                     b: ["foo", "foo"],
+                     c: ["foo", "foo"],
+                     d: ["foo", "foo"],
+                     e: ["foo", "foo"],
+                     f: ["foo", "foo"],
+                     g: ["foo", "foo"]}
+            Value guarded in: Example::run
+            With Contract: Hash => NilClass
+            At: example.rb:17
+    """
+
+  Scenario: Big hash value being returned from method expecting different big hash type
+    Given a file named "example.rb" with:
+    """ruby
+    require "contracts"
+    C = Contracts
+
+    class Example
+      include Contracts::Core
+
+      class << self
+        Contract C::None => ({
+            a: C::Or[String, Symbol],
+            b: C::Or[String, Symbol],
+            c: C::Or[String, Symbol],
+            d: C::Or[String, Symbol],
+            e: C::Or[String, Symbol],
+            f: C::Or[String, Symbol],
+            g: C::Or[String, Symbol]
+        })
+        def run
+          {
+            a: ["foo", "foo"],
+            b: ["foo", "foo"],
+            c: ["foo", "foo"],
+            d: ["foo", "foo"],
+            e: ["foo", "foo"],
+            f: ["foo", "foo"],
+            g: ["foo", "foo"]
+          }
+        end
+      end
+    end
+
+    puts Example.run
+    """
+    When I run `ruby example.rb`
+    Then the output should contain:
+    """
+    : Contract violation for return value: (ReturnContractError)
+            Expected: {a: (String or Symbol),
+                       b: (String or Symbol),
+                       c: (String or Symbol),
+                       d: (String or Symbol),
+                       e: (String or Symbol),
+                       f: (String or Symbol),
+                       g: (String or Symbol)},
+            Actual: {a: ["foo", "foo"],
+                     b: ["foo", "foo"],
+                     c: ["foo", "foo"],
+                     d: ["foo", "foo"],
+                     e: ["foo", "foo"],
+                     f: ["foo", "foo"],
+                     g: ["foo", "foo"]}
+            Value guarded in: Example::run
+            With Contract: None => Hash
+            At: example.rb:17
+    """

data/lib/contracts/formatters.rb

@@ -1,9 +1,7 @@
 # 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/method_handler.rb

@@ -174,8 +174,10 @@ https://github.com/egonSchiele/contracts.ruby/issues
 
     def validate_pattern_matching!
       new_args_contract = decorator.args_contracts
+      new_kargs_contract = decorator.kargs_contract
       matched = decorated_methods.select do |contract|
-        contract.args_contracts == new_args_contract
+        contract.args_contracts == new_args_contract &&
+          contract.kargs_contract == new_kargs_contract
       end
 
       return if matched.empty?

data/lib/contracts/version.rb

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

data/spec/ruby_version_specific/contracts_spec_2.1.rb

@@ -56,7 +56,11 @@ RSpec.describe "Contracts:" do
           @o.complicated("a", true, :b, :c, 2.0, e: (1..5), f: nil, g: :d) do |x|
             x
           end
-        end.to raise_error(ContractError, /Expected: \(KeywordArgs\[{:e=>Range, :f=>Optional\[Num\], :g=>Symbol}\]\)/)
+        end.to raise_error(
+          ContractError,
+          # 3.3- vs 3.4+ error message format
+          /(Expected: \(KeywordArgs\[{:e=>Range, :f=>Optional\[Num\], :g=>Symbol}\]\)|Expected: \(KeywordArgs\[{e: Range, f: Optional\[Num\], g: Symbol}\]\))/,
+        )
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: contracts
 version: !ruby/object:Gem::Version
-  version: 0.17.1
+  version: 0.17.3
 platform: ruby
 authors:
 - Aditya Bhargava
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-10-05 00:00:00.000000000 Z
+date: 2025-12-19 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
@@ -18,6 +18,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/dependabot.yml"
 - ".github/workflows/code_style_checks.yaml"
 - ".github/workflows/tests.yaml"
 - ".gitignore"
@@ -40,8 +41,10 @@ files:
 - cucumber.yml
 - dependabot.yml
 - features/README.md
+- features/advanced/pattern_matching.feature
 - features/basics/functype.feature
-- features/basics/pretty-print.feature
+- features/basics/pretty-print_@before_ruby_3_3.feature
+- features/basics/pretty-print_after_ruby_3_4.feature
 - features/basics/simple_example.feature
 - features/builtin_contracts/README.md
 - features/builtin_contracts/and.feature
@@ -112,7 +115,7 @@ homepage: https://github.com/egonSchiele/contracts.ruby
 licenses:
 - BSD-2-Clause
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -123,15 +126,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '3.0'
   - - "<"
     - !ruby/object:Gem::Version
-      version: '4'
+      version: '5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key:
+rubygems_version: 3.0.3.1
+signing_key: 
 specification_version: 4
 summary: Contracts for Ruby.
 test_files: []