smartest 0.2.1 → 0.3.0.alpha1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd6c10e40f12fe57529897e25cc9142f2d1c0929db4115158ca7d4fc74125631
-  data.tar.gz: 5cc00bd0f73d1556505030b2f332dd867dcc3676d481f1d1de460f9bcd94247d
+  metadata.gz: 47237b7d39a7ec1c0daad3d8f6d63d14ab075bf976c748f21422af3bd64f235e
+  data.tar.gz: e665af0f114097daca5ffff0536074c8724c88a7fc6bb2355ced9395e8394355
 SHA512:
-  metadata.gz: ce164c8a76013859321c380250cf5d2c4f0e5fbe7a5c08452e119211db627be0be20379ec8ec3ae3528bef0bb62a518b85a1444bf11bf107c9c9caa9b36585a5
-  data.tar.gz: be8ef2223c3441c6029f85c752cb4e7146c2ba3025b89ee6ae018e264fcaa964542733bfd7402153120f3495515f878fb392e601419b0c9bfd3f4dbd4c582151
+  metadata.gz: 8a519183ebb6e32add6cca824a9bfead561a00b4be7f953fe54a1f7255e55cf2490ed5aeb0303d08a9059a6c236a0ad20b46b309bef1d57ddc8abe325b03ae1b
+  data.tar.gz: 45dec0f33a22a66382c8ded8647f5cefa33344cb1ac2e38327d62e61e772dac6cc79233732287af214e6de8257b80a98c84cf4b4fd2f9ab34f96e07bc09e49d1

data/README.md

@@ -98,6 +98,14 @@ bundle exec smartest smartest/user_test.rb:12
 bundle exec smartest smartest/user_test.rb:3-12
 ```
 
+Smartest prints the 5 slowest tests after each CLI run by default. Use
+`--profile N` to choose a different count:
+
+```bash
+bundle exec smartest --profile 10
+bundle exec smartest --profile 3 smartest/user_test.rb
+```
+
 CLI help and version output are available with:
 
 ```bash
@@ -105,13 +113,17 @@ bundle exec smartest --help
 bundle exec smartest --version
 ```
 
-Expected output:
+Output resembles:
 
 ```text
 Running 1 test
 
 ✓ example
 
+Top 1 slowest test (0.00001 seconds, 100.0% of total time):
+  example
+    0.00001 seconds .../smartest/example_test.rb:3
+
 1 test, 1 passed, 0 failed
 ```
 
@@ -182,6 +194,8 @@ expect { action }.to raise_error(ErrorClass)
 expect { action }.to raise_error(/message/)
 expect { action }.to raise_error(ErrorClass, /message/)
 expect { action }.to change { value }
+expect(actual).to matcher.or(other_matcher)
+expect(actual).to matcher.and(other_matcher)
 ```
 
 Examples:
@@ -249,6 +263,28 @@ specific order, preserve duplicate counts, and can use matcher objects such as
 `change` is only supported with `expect { ... }` block expectations and must be
 written with a value block.
 
+Matchers can be composed with `.or` and `.and`:
+
+```ruby
+expect(result).to include("NetworkError").or include("Failed to fetch")
+expect(response.status).to eq(200).or(eq(304))
+expect("report.txt").to start_with("report").and end_with(".txt")
+```
+
+`.or` passes when any matcher matches and short-circuits the right-hand matcher
+when the left-hand matcher passes. `.and` passes only when every matcher matches.
+`not_to` does not support composed matchers and raises `ArgumentError` when used
+with `.and` or `.or`.
+
+Composed `change` matchers observe one action block execution:
+
+```ruby
+expect {
+  count += 1
+  total += 1
+}.to change { count }.by(1).and change { total }.by(1)
+```
+
 Custom matcher modules can be registered from `around_suite` or `around_test`
 with `use_matcher`. The generated scaffold includes a `PredicateMatcher` custom
 matcher for `be_<predicate>` calls. See [Matchers](documentation/docs/matchers.md).

data/SMARTEST_DESIGN.md

@@ -718,9 +718,11 @@ MVP expectation API:
 expect(actual).to eq(expected)
 expect(actual).not_to eq(expected)
 expect { action }.to change { value }
+expect(actual).to matcher.or(other_matcher)
+expect(actual).to matcher.and(other_matcher)
 ```
 
-Current built-in matchers include:
+Current built-in matchers and composition helpers include:
 
 ```ruby
 eq(expected)
@@ -737,6 +739,8 @@ raise_error(ErrorClass)
 raise_error(/message/)
 raise_error(ErrorClass, /message/)
 change { value }
+matcher.or(other_matcher)
+matcher.and(other_matcher)
 ```
 
 Internal model:
@@ -748,8 +752,17 @@ expect(actual)
 eq(expected)
   => EqMatcher
 
+EqMatcher
+  < Smartest::Matcher
+
+Smartest::Matcher#or(other_matcher)
+  => OrMatcher
+
+Smartest::Matcher#and(other_matcher)
+  => AndMatcher
+
 ExpectationTarget#to(matcher)
-  => matcher.match!(actual)
+  => matcher.matches?(actual)
 ```
 
 Example:
@@ -761,17 +774,36 @@ class Smartest::ExpectationTarget
   end
 
   def to(matcher)
-    matcher.match!(@actual)
+    return self if matcher.matches?(@actual)
+
+    raise AssertionFailed, matcher.failure_message
   end
 
   def not_to(matcher)
-    matcher.not_match!(@actual)
+    if matcher.respond_to?(:supports_negated_expectation?) && !matcher.supports_negated_expectation?
+      raise ArgumentError, matcher.negated_expectation_error
+    end
+
+    if matcher.respond_to?(:does_not_match?)
+      return self if matcher.does_not_match?(@actual)
+
+      raise AssertionFailed, matcher.negated_failure_message
+    end
+
+    return self unless matcher.matches?(@actual)
+
+    raise AssertionFailed, matcher.negated_failure_message
   end
 end
 ```
 
 Assertion failures should raise `Smartest::AssertionFailed`.
 
+Matcher composition is logical composition over the same actual value. `or`
+passes when any matcher matches and should short-circuit later matchers after a
+match. `and` passes only when every matcher matches. `not_to` with composed
+matchers is intentionally unsupported and raises `ArgumentError`.
+
 ## Reporter
 
 The initial reporter should be simple.

data/exe/smartest

@@ -7,15 +7,15 @@ require "smartest"
 
 usage = <<~USAGE
   Usage:
-    smartest [paths...]
-    smartest path/to/test_file.rb:line[-line]
-    smartest --profile [N]
+    smartest [--profile N] [paths...]
+    smartest [--profile N] path/to/test_file.rb:line[-line]
     smartest --init
     smartest --version
     smartest --help
 
   When no paths are given, Smartest loads smartest/**/*_test.rb.
-  --profile prints the slowest tests after the run (default 5).
+  Smartest prints the 5 slowest tests after the run by default.
+  Use --profile N to choose how many slowest tests are printed.
 USAGE
 
 command = :run

data/lib/smartest/cli_arguments.rb

@@ -12,7 +12,7 @@ module Smartest
       @files = []
       @whole_files = Set.new
       @line_filters = Hash.new { |hash, key| hash[key] = Set.new }
-      @profile_count = nil
+      @profile_count = DEFAULT_PROFILE_COUNT
 
       paths = extract_options(argv)
       parse_paths(paths.empty? ? ["smartest/**/*_test.rb"] : paths)
@@ -45,17 +45,13 @@ module Smartest
 
         case argument
         when "--profile"
-          next_argument = argv[index + 1]
-          if next_argument && next_argument.match?(/\A\d+\z/)
-            @profile_count = next_argument.to_i
+          if argv[index + 1]&.match?(/\A\d+\z/)
+            @profile_count = argv[index + 1].to_i
             index += 2
           else
-            @profile_count = DEFAULT_PROFILE_COUNT
+            paths << argument
             index += 1
           end
-        when /\A--profile=(\d+)\z/
-          @profile_count = Regexp.last_match(1).to_i
-          index += 1
         else
           paths << argument
           index += 1

data/lib/smartest/expectation_target.rb

@@ -13,6 +13,10 @@ module Smartest
     end
 
     def not_to(matcher)
+      if matcher.respond_to?(:supports_negated_expectation?) && !matcher.supports_negated_expectation?
+        raise ArgumentError, matcher.negated_expectation_error
+      end
+
       if matcher.respond_to?(:does_not_match?)
         return self if matcher.does_not_match?(@actual)
 

data/lib/smartest/init_generator.rb

@@ -38,7 +38,7 @@ module Smartest
             name.to_s.match?(/\\Abe_.+\\z/) || super
           end
 
-          class Matcher
+          class Matcher < Smartest::Matcher
             def initialize(predicate_name, arguments, block)
               @predicate_name = predicate_name
               @predicate = "\#{predicate_name}?"
@@ -63,14 +63,14 @@ module Smartest
               "expected \#{@actual.inspect} not to be \#{description}"
             end
 
-            private
-
             def description
               return @predicate_name if @arguments.empty?
 
               "\#{@predicate_name} \#{argument_description}"
             end
 
+            private
+
             def argument_description
               @arguments.map(&:inspect).join(", ")
             end

data/lib/smartest/matchers.rb

@@ -54,7 +54,162 @@ module Smartest
     end
   end
 
-  class EqMatcher
+  class Matcher
+    def and(other_matcher)
+      AndMatcher.new(self, other_matcher)
+    end
+
+    def or(other_matcher)
+      OrMatcher.new(self, other_matcher)
+    end
+
+    def description
+      self.class.name || "matcher"
+    end
+  end
+
+  class CompoundMatcher < Matcher
+    attr_reader :matchers
+
+    NEGATED_EXPECTATION_ERROR = "not_to does not support matcher composition with .and or .or"
+
+    def initialize(*matchers)
+      @matchers = matchers.flat_map do |matcher|
+        matcher.is_a?(self.class) ? matcher.matchers : matcher
+      end
+      reset_result
+    end
+
+    def supports_negated_expectation?
+      false
+    end
+
+    def negated_expectation_error
+      NEGATED_EXPECTATION_ERROR
+    end
+
+    private
+
+    def reset_result
+      @actual = nil
+      @failed_matchers = []
+      @matched_matchers = []
+    end
+
+    def actual_description
+      @actual.respond_to?(:call) ? "block" : @actual.inspect
+    end
+
+    def matcher_description(matcher)
+      description = if matcher.respond_to?(:description)
+                      matcher.description
+                    else
+                      matcher.inspect
+                    end
+
+      matcher.is_a?(CompoundMatcher) ? "(#{description})" : description
+    end
+
+    def joined_description(separator)
+      @matchers.map { |matcher| matcher_description(matcher) }.join(separator)
+    end
+
+    def failure_messages
+      @failed_matchers.filter_map do |matcher|
+        matcher.failure_message if matcher.respond_to?(:failure_message)
+      end
+    end
+
+    def composed_block_expectation?(actual)
+      actual.respond_to?(:call) &&
+        @matchers.all? { |matcher| matcher.respond_to?(:composable_block_expectation?) } &&
+        @matchers.all?(&:composable_block_expectation?)
+    end
+
+    def run_composed_block_expectation(actual)
+      @matchers.each(&:prepare_composed_block_expectation)
+      actual.call
+      @matchers.each(&:finish_composed_block_expectation)
+      @matchers.each do |matcher|
+        if matcher.composed_block_matches?
+          @matched_matchers << matcher
+        else
+          @failed_matchers << matcher
+        end
+      end
+    end
+  end
+
+  class AndMatcher < CompoundMatcher
+    def matches?(actual)
+      reset_result
+      @actual = actual
+
+      if composed_block_expectation?(actual)
+        run_composed_block_expectation(actual)
+        return @failed_matchers.empty?
+      end
+
+      @matchers.each do |matcher|
+        if matcher.matches?(actual)
+          @matched_matchers << matcher
+        else
+          @failed_matchers << matcher
+          return false
+        end
+      end
+
+      true
+    end
+
+    def failure_message
+      message = "expected #{actual_description} to match all of #{description}"
+      details = failure_messages
+      details.empty? ? message : "#{message}; #{details.join('; ')}"
+    end
+
+    def negated_failure_message
+      "expected #{actual_description} not to match all of #{description}"
+    end
+
+    def description
+      joined_description(" and ")
+    end
+  end
+
+  class OrMatcher < CompoundMatcher
+    def matches?(actual)
+      reset_result
+      @actual = actual
+
+      @matchers.each do |matcher|
+        if matcher.matches?(actual)
+          @matched_matchers << matcher
+          return true
+        end
+
+        @failed_matchers << matcher
+      end
+
+      false
+    end
+
+    def failure_message
+      message = "expected #{actual_description} to match any of #{description}"
+      details = failure_messages
+      details.empty? ? message : "#{message}; #{details.join('; ')}"
+    end
+
+    def negated_failure_message
+      "expected #{actual_description} not to match any of #{description}"
+    end
+
+    def description
+      joined_description(" or ")
+    end
+  end
+
+  class EqMatcher < Matcher
     def initialize(expected)
       @expected = expected
     end
@@ -77,7 +232,7 @@ module Smartest
     end
   end
 
-  class IncludeMatcher
+  class IncludeMatcher < Matcher
     def initialize(expected)
       @expected = expected
     end
@@ -102,7 +257,7 @@ module Smartest
     end
   end
 
-  class StartWithMatcher
+  class StartWithMatcher < Matcher
     def initialize(*prefixes)
       @prefixes = prefixes
     end
@@ -135,7 +290,7 @@ module Smartest
     end
   end
 
-  class EndWithMatcher
+  class EndWithMatcher < Matcher
     def initialize(*suffixes)
       @suffixes = suffixes
     end
@@ -168,7 +323,7 @@ module Smartest
     end
   end
 
-  class BeAKindOfMatcher
+  class BeAKindOfMatcher < Matcher
     def initialize(expected_class)
       @expected_class = expected_class
     end
@@ -203,7 +358,7 @@ module Smartest
     end
   end
 
-  class BeNilMatcher
+  class BeNilMatcher < Matcher
     def matches?(actual)
       @actual = actual
       actual.nil?
@@ -222,7 +377,7 @@ module Smartest
     end
   end
 
-  class MatchMatcher
+  class MatchMatcher < Matcher
     def initialize(regexp)
       @regexp = regexp
     end
@@ -247,7 +402,7 @@ module Smartest
     end
   end
 
-  class ContainExactlyMatcher
+  class ContainExactlyMatcher < Matcher
     def initialize(expected_items, matcher_name:)
       @expected_items = expected_items
       @matcher_name = matcher_name
@@ -369,7 +524,7 @@ module Smartest
     end
   end
 
-  class RaiseErrorMatcher
+  class RaiseErrorMatcher < Matcher
     def initialize(*expected_error)
       @expected_type = expected_type_for(expected_error)
       @expected_error_class = expected_error.find { |item| error_class?(item) }
@@ -403,6 +558,10 @@ module Smartest
       "expected block not to raise #{expected_description}, but raised #{actual_error_description}"
     end
 
+    def description
+      "raise #{expected_description}"
+    end
+
     private
 
     def expected_type_for(expected_error)
@@ -446,7 +605,7 @@ module Smartest
     end
   end
 
-  class ChangeMatcher
+  class ChangeMatcher < Matcher
     UNSET = Object.new
 
     def initialize(value_block)
@@ -498,6 +657,31 @@ module Smartest
       "expected value not to change, but #{observed_description}"
     end
 
+    def description
+      expected_description
+    end
+
+    def composable_block_expectation?
+      true
+    end
+
+    def prepare_composed_block_expectation
+      reset_result
+      @callable = true
+      @before_value = @value_block.call
+    end
+
+    def finish_composed_block_expectation
+      @after_value = @value_block.call
+      calculate_delta if delta_expected?
+    end
+
+    def composed_block_matches?
+      return false unless @callable
+
+      positive_failures.empty?
+    end
+
     private
 
     def reset_result

data/lib/smartest/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Smartest
-  VERSION = "0.2.1"
+  VERSION = "0.3.0.alpha1"
 end

data/smartest/smartest_test.rb

@@ -218,6 +218,74 @@ test("supports basic matchers") do
   expect(status).to eq(0)
 end
 
+test("supports matcher composition with and and or") do
+  action_calls = 0
+  first_value = 0
+  second_value = 10
+
+  expect("NetworkError").to include("Network").or include("Failed to fetch")
+  expect(304).to eq(200).or(eq(201)).or(eq(304))
+  expect("report.txt").to start_with("report").and end_with(".txt")
+  expect {
+    action_calls += 1
+    first_value += 1
+    second_value += 1
+  }.to change { first_value }.by(1).and change { second_value }.by(1)
+
+  expect(action_calls).to eq(1)
+end
+
+test("reports matcher composition failures") do
+  error = SmartestSelfTest.capture_error(Smartest::AssertionFailed) do
+    expect("permission denied").to include("NetworkError").or include("Failed to fetch")
+  end
+
+  expect(error.message).to include(
+    'expected "permission denied" to match any of include "NetworkError" or include "Failed to fetch"'
+  )
+  expect(error.message).to include('expected "permission denied" to include "NetworkError"')
+  expect(error.message).to include('expected "permission denied" to include "Failed to fetch"')
+
+  error = SmartestSelfTest.capture_error(Smartest::AssertionFailed) do
+    expect("error.log").to start_with("error").and end_with(".txt")
+  end
+
+  expect(error.message).to include('expected "error.log" to match all of start with "error" and end with ".txt"')
+  expect(error.message).to include('expected "error.log" to end with ".txt"')
+end
+
+test("rejects negated matcher composition") do
+  error = SmartestSelfTest.capture_error(ArgumentError) do
+    expect("public token").not_to include("password").or include("secret")
+  end
+
+  expect(error.message).to eq("not_to does not support matcher composition with .and or .or")
+
+  error = SmartestSelfTest.capture_error(ArgumentError) do
+    expect("report.log").not_to start_with("report").and end_with(".txt")
+  end
+
+  expect(error.message).to eq("not_to does not support matcher composition with .and or .or")
+end
+
+test("short-circuits or matcher composition") do
+  right_matcher = Class.new(Smartest::Matcher) do
+    def matches?(_actual)
+      raise "right matcher should not be evaluated"
+    end
+
+    def failure_message
+      "right matcher failed"
+    end
+
+    def negated_failure_message
+      "right matcher matched"
+    end
+  end.new
+
+  expect("ok").to eq("ok").or(right_matcher)
+end
+
 test("reports be_a and match matcher failures") do
   suite = Smartest::Suite.new
   suite.tests.add(
@@ -1368,7 +1436,7 @@ test("cli loads matcher files registered in test helper") do
     RUBY
     File.write(File.join(matchers_dir, "have_status_matcher.rb"), <<~RUBY)
       module HaveStatusMatcher
-        class MatcherImpl
+        class MatcherImpl < Smartest::Matcher
           def initialize(expected)
             @expected = expected
           end
@@ -1385,6 +1453,10 @@ test("cli loads matcher files registered in test helper") do
           def negated_failure_message
             "expected \#{@actual.inspect} not to have status \#{@expected.inspect}"
           end
+
+          def description
+            "have status \#{@expected.inspect}"
+          end
         end
 
         def have_status(expected)
@@ -1566,10 +1638,10 @@ test("cli prints help") do
   expect(status.success?).to eq(true)
   expect(stderr).to eq("")
   expect(stdout).to include("Usage:")
-  expect(stdout).to include("smartest [paths...]")
-  expect(stdout).to include("smartest path/to/test_file.rb:line[-line]")
+  expect(stdout).to include("smartest [--profile N] [paths...]")
+  expect(stdout).to include("smartest [--profile N] path/to/test_file.rb:line[-line]")
   expect(stdout).to include("smartest --init")
-  expect(stdout).to include("smartest --profile [N]")
+  expect(stdout).to include("Use --profile N")
   expect(stdout).to include("smartest/**/*_test.rb")
 end
 
@@ -1664,15 +1736,58 @@ test("--profile is not printed when there are no results") do
   expect(output.string).not_to include("slowest")
 end
 
-test("CLIArguments parses --profile in various forms") do
-  expect(Smartest::CLIArguments.new(["--profile"]).profile_count).to eq(5)
+test("CLIArguments defaults profile count and parses --profile N") do
+  arguments = Smartest::CLIArguments.new([])
+
+  expect(arguments.profile_count).to eq(5)
+  expect(arguments.files).to eq(Dir["smartest/**/*_test.rb"])
   expect(Smartest::CLIArguments.new(["--profile", "3"]).profile_count).to eq(3)
-  expect(Smartest::CLIArguments.new(["--profile=7"]).profile_count).to eq(7)
-  expect(Smartest::CLIArguments.new([]).profile_count).to eq(nil)
-  expect(Smartest::CLIArguments.new(["--profile", "smartest/foo_test.rb"]).profile_count).to eq(5)
 end
 
-test("cli runs with --profile and prints slowest tests") do
+test("CLIArguments leaves unsupported profile forms as paths") do
+  equals_form = Smartest::CLIArguments.new(["--profile=7"])
+  missing_count = Smartest::CLIArguments.new(["--profile"])
+  path_after_profile = Smartest::CLIArguments.new(["--profile", "smartest/foo_test.rb"])
+
+  expect(equals_form.profile_count).to eq(5)
+  expect(equals_form.files).to eq(["--profile=7"])
+  expect(missing_count.profile_count).to eq(5)
+  expect(missing_count.files).to eq(["--profile"])
+  expect(path_after_profile.profile_count).to eq(5)
+  expect(path_after_profile.files).to eq(["--profile", "smartest/foo_test.rb"])
+end
+
+test("cli runs without --profile N and prints default slowest tests") do
+  Dir.mktmpdir do |dir|
+    smartest_dir = File.join(dir, "smartest")
+    FileUtils.mkdir_p(smartest_dir)
+    File.write(File.join(smartest_dir, "sample_test.rb"), <<~RUBY)
+      require "smartest/autorun"
+
+      test("default first") do
+        expect(1).to eq(1)
+      end
+
+      test("default second") do
+        expect(1).to eq(1)
+      end
+    RUBY
+
+    stdout, stderr, status = Open3.capture3(
+      { "RUBYLIB" => File.expand_path("../lib", __dir__) },
+      "ruby",
+      File.expand_path("../exe/smartest", __dir__),
+      chdir: dir
+    )
+
+    expect(status.success?).to eq(true)
+    expect(stderr).to eq("")
+    expect(stdout).to include("Top 2 slowest tests")
+    expect(stdout).to include("2 tests, 2 passed, 0 failed")
+  end
+end
+
+test("cli runs with --profile N and prints requested slowest tests") do
   Dir.mktmpdir do |dir|
     smartest_dir = File.join(dir, "smartest")
     FileUtils.mkdir_p(smartest_dir)
@@ -1730,6 +1845,7 @@ test("cli initializes a runnable test scaffold") do
     expect(helper_contents).to include("use_matcher PredicateMatcher")
     predicate_matcher_contents = File.read(File.join(dir, "smartest/matchers/predicate_matcher.rb"))
     expect(predicate_matcher_contents).to include("module PredicateMatcher")
+    expect(predicate_matcher_contents).to include("class Matcher < Smartest::Matcher")
     expect(File.read(File.join(dir, "smartest/example_test.rb"))).to include('require "test_helper"')
 
     nested_fixtures_dir = File.join(dir, "smartest/fixtures/nested")
@@ -1759,7 +1875,7 @@ test("cli initializes a runnable test scaffold") do
     FileUtils.mkdir_p(nested_matchers_dir)
     File.write(File.join(nested_matchers_dir, "auto_loaded_matcher.rb"), <<~RUBY)
       module AutoLoadedMatcher
-        class Matcher
+        class Matcher < Smartest::Matcher
           def initialize(expected)
             @expected = expected
           end
@@ -1776,6 +1892,10 @@ test("cli initializes a runnable test scaffold") do
           def negated_failure_message
             "expected \#{@actual.inspect} not to auto-eq \#{@expected.inspect}"
           end
+
+          def description
+            "auto-eq \#{@expected.inspect}"
+          end
         end
 
         def auto_eq(expected)
@@ -1803,6 +1923,7 @@ test("cli initializes a runnable test scaffold") do
       test("generated predicate matcher") do
         expect("").to be_empty
         expect(2).to be_between(1, 3)
+        expect(2).to be_odd.or be_even
       end
     RUBY
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smartest
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0.alpha1
 platform: ruby
 authors:
 - Yusuke Iwaki
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-04-28 00:00:00.000000000 Z
+date: 2026-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -91,9 +91,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.4.19
 signing_key: