From 5b2b70ac8cbe558c5f929f4ac2d2005f4a3f0f70 Mon Sep 17 00:00:00 2001 From: nijeeshjoshy Date: Thu, 5 Mar 2026 13:02:06 +0100 Subject: [PATCH 1/6] chore: relax faraday and sorbet-runtime version constraints - faraday: ~> 2.12.2 -> ~> 2.12 (unblocks security fix in 2.14.1) - faraday-multipart: ~> 1.1.0 -> ~> 1.1 (allows 1.2.x, Ruby 4 compat) - faraday-net_http_persistent: ~> 2.3.0 -> ~> 2.3 - sorbet-runtime: ~> 0.5.11820 -> >= 0.5.11820, < 2 (allows 0.5.x and 0.6.x) - sorbet (dev): ~> 0.5 -> ~> 0.6 Closes #196, closes #189 --- Gemfile | 2 +- stream-chat.gemspec | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/Gemfile b/Gemfile index 9f46f9e..699f257 100644 --- a/Gemfile +++ b/Gemfile @@ -14,7 +14,7 @@ group :dev do gem 'rubocop-ast', '~> 1.23', require: false gem 'simplecov', '~> 0.21.2' gem 'simplecov-console', '~> 0.9.1' - gem 'sorbet', '~> 0.5.10539' + gem 'sorbet', '~> 0.6' end group :test do diff --git a/stream-chat.gemspec b/stream-chat.gemspec index 0ecc866..1d9db03 100644 --- a/stream-chat.gemspec +++ b/stream-chat.gemspec @@ -26,10 +26,10 @@ Gem::Specification.new do |gem| 'source_code_uri' => 'https://github.com/GetStream/stream-chat-ruby' } - gem.add_dependency 'faraday', '~> 2.12.2' - gem.add_dependency 'faraday-multipart', '~> 1.1.0' - gem.add_dependency 'faraday-net_http_persistent', '~> 2.3.0' + gem.add_dependency 'faraday', '~> 2.12' + gem.add_dependency 'faraday-multipart', '~> 1.1' + gem.add_dependency 'faraday-net_http_persistent', '~> 2.3' gem.add_dependency 'jwt', '~> 2.10' gem.add_dependency 'net-http-persistent', '~> 4.0' - gem.add_dependency 'sorbet-runtime', '~> 0.5.11820' + gem.add_dependency 'sorbet-runtime', '>= 0.5.11820', '< 2' end From e26955d17c77943fd5cdec43afce8a9bcc8a8df6 Mon Sep 17 00:00:00 2001 From: nijeeshjoshy Date: Thu, 5 Mar 2026 13:02:09 +0100 Subject: [PATCH 2/6] chore: add Ruby 4.0 to CI matrix, run lint checks on 3.4 and 4.0 --- .github/workflows/ci.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index edb679e..6b82e9a 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -8,7 +8,7 @@ jobs: strategy: max-parallel: 1 matrix: - ruby: ["3.0", "3.1", "3.4"] + ruby: ["3.0", "3.1", "3.4", "4.0"] name: 💎 Ruby ${{ matrix.ruby }} steps: - uses: actions/checkout@v4 @@ -21,10 +21,10 @@ jobs: bundler-cache: true - run: bundle exec rake rubocop - if: ${{ matrix.ruby == '3.4' }} + if: ${{ matrix.ruby == '3.4' || matrix.ruby == '4.0' }} - run: bundle exec srb tc - if: ${{ matrix.ruby == '3.4' }} + if: ${{ matrix.ruby == '3.4' || matrix.ruby == '4.0' }} - run: bundle exec rspec ./spec --require spec_helper env: From 5086c4776656a48002bae3225cef1d311c7e96ba Mon Sep 17 00:00:00 2001 From: nijeeshjoshy Date: Thu, 5 Mar 2026 13:02:14 +0100 Subject: [PATCH 3/6] fix: update sorbet RBI stubs for Sorbet 0.6 compatibility - Remove conflicting method stubs from hidden.rbi (now in Sorbet 0.6 stdlib) - Add typed: true headers to gem RBIs missing sigils - Ignore sorbet/rbi/sorbet-typed in sorbet config (stale 0.5 community stubs) - Delete sorbet/rbi/sorbet-typed (ignored, 1071 lines of stale stubs removed) --- sorbet/config | 8 +- sorbet/rbi/gems/connection_pool.rbi | 1 + sorbet/rbi/gems/docile.rbi | 1 + sorbet/rbi/gems/faraday-em_http.rbi | 1 + sorbet/rbi/gems/faraday-em_synchrony.rbi | 1 + sorbet/rbi/gems/faraday-excon.rbi | 1 + sorbet/rbi/gems/faraday-httpclient.rbi | 1 + sorbet/rbi/gems/faraday-multipart.rbi | 1 + sorbet/rbi/gems/faraday-net_http.rbi | 1 + .../rbi/gems/faraday-net_http_persistent.rbi | 1 + sorbet/rbi/gems/faraday-patron.rbi | 1 + sorbet/rbi/gems/faraday-rack.rbi | 1 + sorbet/rbi/gems/method_source.rbi | 1 + sorbet/rbi/gems/multipart-post.rbi | 1 + sorbet/rbi/gems/net-http-persistent.rbi | 1 + sorbet/rbi/gems/simplecov-html.rbi | 1 + sorbet/rbi/gems/simplecov_json_formatter.rbi | 1 + sorbet/rbi/hidden-definitions/hidden.rbi | 4 - .../sorbet-typed/lib/faraday/all/faraday.rbi | 82 --- .../sorbet-typed/lib/rainbow/all/rainbow.rbi | 276 -------- sorbet/rbi/sorbet-typed/lib/rake/all/rake.rbi | 645 ------------------ .../lib/rspec-core/all/rspec-core.rbi | 24 - .../lib/rubocop/>=1.8/rubocop.rbi | 12 - sorbet/rbi/sorbet-typed/lib/yard/all/yard.rbi | 32 - 24 files changed, 22 insertions(+), 1077 deletions(-) delete mode 100644 sorbet/rbi/sorbet-typed/lib/faraday/all/faraday.rbi delete mode 100644 sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi delete mode 100644 sorbet/rbi/sorbet-typed/lib/rake/all/rake.rbi delete mode 100644 sorbet/rbi/sorbet-typed/lib/rspec-core/all/rspec-core.rbi delete mode 100644 sorbet/rbi/sorbet-typed/lib/rubocop/>=1.8/rubocop.rbi delete mode 100644 sorbet/rbi/sorbet-typed/lib/yard/all/yard.rbi diff --git a/sorbet/config b/sorbet/config index ea62791..bec7794 100644 --- a/sorbet/config +++ b/sorbet/config @@ -1,4 +1,8 @@ --dir . ---ignore=vendor/bundle,spec ---disable-watchman \ No newline at end of file +--ignore=vendor/bundle,spec,sorbet/rbi/sorbet-typed +# sorbet/rbi/sorbet-typed contains community stubs generated for Sorbet 0.5. +# Sorbet 0.6 defaults unsigned RBI files to typed: strict, causing 7017 errors +# in these stale stubs. They cover dev tools (rake, rspec, rubocop) that don't +# need type checking. Migrate to Tapioca in a follow-up to replace all stubs. +--disable-watchman diff --git a/sorbet/rbi/gems/connection_pool.rbi b/sorbet/rbi/gems/connection_pool.rbi index 59c8ecd..6dac365 100644 --- a/sorbet/rbi/gems/connection_pool.rbi +++ b/sorbet/rbi/gems/connection_pool.rbi @@ -1,3 +1,4 @@ +# typed: true # This file is autogenerated. Do not edit it by hand. Regenerate it with: # srb rbi gems diff --git a/sorbet/rbi/gems/docile.rbi b/sorbet/rbi/gems/docile.rbi index 6314c6c..7bd99ea 100644 --- a/sorbet/rbi/gems/docile.rbi +++ b/sorbet/rbi/gems/docile.rbi @@ -1,3 +1,4 @@ +# typed: true # This file is autogenerated. Do not edit it by hand. Regenerate it with: # srb rbi gems diff --git a/sorbet/rbi/gems/faraday-em_http.rbi b/sorbet/rbi/gems/faraday-em_http.rbi index d360462..88de3d2 100644 --- a/sorbet/rbi/gems/faraday-em_http.rbi +++ b/sorbet/rbi/gems/faraday-em_http.rbi @@ -1,3 +1,4 @@ +# typed: true # This file is autogenerated. Do not edit it by hand. Regenerate it with: # srb rbi gems diff --git a/sorbet/rbi/gems/faraday-em_synchrony.rbi b/sorbet/rbi/gems/faraday-em_synchrony.rbi index 1a3cd1e..6e0ecde 100644 --- a/sorbet/rbi/gems/faraday-em_synchrony.rbi +++ b/sorbet/rbi/gems/faraday-em_synchrony.rbi @@ -1,3 +1,4 @@ +# typed: true # This file is autogenerated. Do not edit it by hand. Regenerate it with: # srb rbi gems diff --git a/sorbet/rbi/gems/faraday-excon.rbi b/sorbet/rbi/gems/faraday-excon.rbi index 6d5752a..a102694 100644 --- a/sorbet/rbi/gems/faraday-excon.rbi +++ b/sorbet/rbi/gems/faraday-excon.rbi @@ -1,3 +1,4 @@ +# typed: true # This file is autogenerated. Do not edit it by hand. Regenerate it with: # srb rbi gems diff --git a/sorbet/rbi/gems/faraday-httpclient.rbi b/sorbet/rbi/gems/faraday-httpclient.rbi index a292f08..9cc8fcd 100644 --- a/sorbet/rbi/gems/faraday-httpclient.rbi +++ b/sorbet/rbi/gems/faraday-httpclient.rbi @@ -1,3 +1,4 @@ +# typed: true # This file is autogenerated. Do not edit it by hand. Regenerate it with: # srb rbi gems diff --git a/sorbet/rbi/gems/faraday-multipart.rbi b/sorbet/rbi/gems/faraday-multipart.rbi index 7a68c62..6890122 100644 --- a/sorbet/rbi/gems/faraday-multipart.rbi +++ b/sorbet/rbi/gems/faraday-multipart.rbi @@ -1,3 +1,4 @@ +# typed: true # This file is autogenerated. Do not edit it by hand. Regenerate it with: # srb rbi gems diff --git a/sorbet/rbi/gems/faraday-net_http.rbi b/sorbet/rbi/gems/faraday-net_http.rbi index 7da571a..78b8a17 100644 --- a/sorbet/rbi/gems/faraday-net_http.rbi +++ b/sorbet/rbi/gems/faraday-net_http.rbi @@ -1,3 +1,4 @@ +# typed: true # This file is autogenerated. Do not edit it by hand. Regenerate it with: # srb rbi gems diff --git a/sorbet/rbi/gems/faraday-net_http_persistent.rbi b/sorbet/rbi/gems/faraday-net_http_persistent.rbi index ff453f4..20002f8 100644 --- a/sorbet/rbi/gems/faraday-net_http_persistent.rbi +++ b/sorbet/rbi/gems/faraday-net_http_persistent.rbi @@ -1,3 +1,4 @@ +# typed: true # This file is autogenerated. Do not edit it by hand. Regenerate it with: # srb rbi gems diff --git a/sorbet/rbi/gems/faraday-patron.rbi b/sorbet/rbi/gems/faraday-patron.rbi index 5a9c793..a252bfe 100644 --- a/sorbet/rbi/gems/faraday-patron.rbi +++ b/sorbet/rbi/gems/faraday-patron.rbi @@ -1,3 +1,4 @@ +# typed: true # This file is autogenerated. Do not edit it by hand. Regenerate it with: # srb rbi gems diff --git a/sorbet/rbi/gems/faraday-rack.rbi b/sorbet/rbi/gems/faraday-rack.rbi index ec6296e..6774194 100644 --- a/sorbet/rbi/gems/faraday-rack.rbi +++ b/sorbet/rbi/gems/faraday-rack.rbi @@ -1,3 +1,4 @@ +# typed: true # This file is autogenerated. Do not edit it by hand. Regenerate it with: # srb rbi gems diff --git a/sorbet/rbi/gems/method_source.rbi b/sorbet/rbi/gems/method_source.rbi index 92cdecd..57b7391 100644 --- a/sorbet/rbi/gems/method_source.rbi +++ b/sorbet/rbi/gems/method_source.rbi @@ -1,3 +1,4 @@ +# typed: true # This file is autogenerated. Do not edit it by hand. Regenerate it with: # srb rbi gems diff --git a/sorbet/rbi/gems/multipart-post.rbi b/sorbet/rbi/gems/multipart-post.rbi index 6e55beb..1607ae2 100644 --- a/sorbet/rbi/gems/multipart-post.rbi +++ b/sorbet/rbi/gems/multipart-post.rbi @@ -1,3 +1,4 @@ +# typed: true # This file is autogenerated. Do not edit it by hand. Regenerate it with: # srb rbi gems diff --git a/sorbet/rbi/gems/net-http-persistent.rbi b/sorbet/rbi/gems/net-http-persistent.rbi index a029d8b..cb988ef 100644 --- a/sorbet/rbi/gems/net-http-persistent.rbi +++ b/sorbet/rbi/gems/net-http-persistent.rbi @@ -1,3 +1,4 @@ +# typed: true # This file is autogenerated. Do not edit it by hand. Regenerate it with: # srb rbi gems diff --git a/sorbet/rbi/gems/simplecov-html.rbi b/sorbet/rbi/gems/simplecov-html.rbi index 88f5104..18394a8 100644 --- a/sorbet/rbi/gems/simplecov-html.rbi +++ b/sorbet/rbi/gems/simplecov-html.rbi @@ -1,3 +1,4 @@ +# typed: true # This file is autogenerated. Do not edit it by hand. Regenerate it with: # srb rbi gems diff --git a/sorbet/rbi/gems/simplecov_json_formatter.rbi b/sorbet/rbi/gems/simplecov_json_formatter.rbi index dc31ea5..c8d64fd 100644 --- a/sorbet/rbi/gems/simplecov_json_formatter.rbi +++ b/sorbet/rbi/gems/simplecov_json_formatter.rbi @@ -1,3 +1,4 @@ +# typed: true # This file is autogenerated. Do not edit it by hand. Regenerate it with: # srb rbi gems diff --git a/sorbet/rbi/hidden-definitions/hidden.rbi b/sorbet/rbi/hidden-definitions/hidden.rbi index e0cc8b2..a82e732 100644 --- a/sorbet/rbi/hidden-definitions/hidden.rbi +++ b/sorbet/rbi/hidden-definitions/hidden.rbi @@ -4607,8 +4607,6 @@ class Gem::SpecFetcher def specs(); end - def suggest_gems_from_name(gem_name, type=T.unsafe(nil)); end - def tuples_for(source, type, gracefully_ignore=T.unsafe(nil)); end end @@ -4728,8 +4726,6 @@ class IO def wait(*arg); end - def wait_readable(*arg); end - def wait_writable(*arg); end end diff --git a/sorbet/rbi/sorbet-typed/lib/faraday/all/faraday.rbi b/sorbet/rbi/sorbet-typed/lib/faraday/all/faraday.rbi deleted file mode 100644 index b3f7389..0000000 --- a/sorbet/rbi/sorbet-typed/lib/faraday/all/faraday.rbi +++ /dev/null @@ -1,82 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi sorbet-typed -# -# If you would like to make changes to this file, great! Please upstream any changes you make here: -# -# https://github.com/sorbet/sorbet-typed/edit/master/lib/faraday/all/faraday.rbi -# -# typed: strict - -module Faraday - def self.new(url = nil, options = nil, &block); end - - # HTTP verb methods. These are proxied to Faraday::Connecation, - # which should have corresponding sigs - - # Query methods - sig do - params( - url: String, - params: T.nilable(T::Hash[Object, Object]), - headers: T.nilable(T::Hash[Object, String]), - block: T.nilable(T.proc.params(req: Faraday::Request).void), - ).returns(Faraday::Response) - end - def self.get(url, params = nil, headers = nil, &block); end - sig do - params( - url: String, - params: T.nilable(T::Hash[Object, Object]), - headers: T.nilable(T::Hash[Object, String]), - block: T.nilable(T.proc.params(req: Faraday::Request).void), - ).returns(Faraday::Response) - end - def self.head(url, params = nil, headers = nil, &block); end - sig do - params( - url: String, - params: T.nilable(T::Hash[Object, Object]), - headers: T.nilable(T::Hash[Object, String]), - block: T.nilable(T.proc.params(req: Faraday::Request).void), - ).returns(Faraday::Response) - end - def self.delete(url, params = nil, headers = nil, &block); end - sig do - params( - url: String, - params: T.nilable(T::Hash[Object, Object]), - headers: T.nilable(T::Hash[Object, String]), - block: T.nilable(T.proc.params(req: Faraday::Request).void), - ).returns(Faraday::Response) - end - def self.trace(url, params = nil, headers = nil, &block); end - - # Body methods - sig do - params( - url: String, - body: T.any(String, T.nilable(T::Hash[Object, Object])), - headers: T.nilable(T::Hash[Object, String]), - block: T.nilable(T.proc.params(req: Faraday::Request).void), - ).returns(Faraday::Response) - end - def self.post(url, body = nil, headers = nil, &block); end - sig do - params( - url: String, - body: T.any(String, T.nilable(T::Hash[Object, Object])), - headers: T.nilable(T::Hash[Object, String]), - block: T.nilable(T.proc.params(req: Faraday::Request).void), - ).returns(Faraday::Response) - end - def self.put(url, body = nil, headers = nil, &block); end - sig do - params( - url: String, - body: T.any(String, T.nilable(T::Hash[Object, Object])), - headers: T.nilable(T::Hash[Object, String]), - block: T.nilable(T.proc.params(req: Faraday::Request).void), - ).returns(Faraday::Response) - end - def self.patch(url, body = nil, headers = nil, &block); end -end diff --git a/sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi b/sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi deleted file mode 100644 index abbae7b..0000000 --- a/sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi +++ /dev/null @@ -1,276 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi sorbet-typed -# -# If you would like to make changes to this file, great! Please upstream any changes you make here: -# -# https://github.com/sorbet/sorbet-typed/edit/master/lib/rainbow/all/rainbow.rbi -# -# typed: strong - -module Rainbow - sig { returns(T::Boolean) } - attr_accessor :enabled - - class Color - sig { returns(Symbol) } - attr_reader :ground - - sig do - params( - ground: Symbol, - values: T.any([Integer], [Integer, Integer, Integer]) - ).returns(Color) - end - def self.build(ground, values); end - - sig { params(hex: String).returns([Integer, Integer, Integer]) } - def self.parse_hex_color(hex); end - - class Indexed < Color - sig { returns(Integer) } - attr_reader :num - - sig { params(ground: Symbol, num: Integer).void } - def initialize(ground, num); end - - sig { returns(T::Array[Integer]) } - def codes; end - end - - class Named < Indexed - NAMES = T.let(nil, T::Hash[Symbol, Integer]) - - sig { returns(T::Array[Symbol]) } - def self.color_names; end - - sig { returns(String) } - def self.valid_names; end - - sig { params(ground: Symbol, name: Symbol).void } - def initialize(ground, name); end - end - - class RGB < Indexed - sig { returns(Integer) } - attr_accessor :r, :g, :b - - sig { params(value: Numeric).returns(Integer) } - def to_ansi_domain(value); end - - sig { params(ground: Symbol, values: Integer).void } - def initialize(ground, *values); end - - sig { returns(T::Array[Integer]) } - def codes; end - end - - class X11Named < RGB - include X11ColorNames - - sig { returns(T::Array[Symbol]) } - def self.color_names; end - - sig { returns(String) } - def self.valid_names; end - - sig { params(ground: Symbol, name: Symbol).void } - def initialize(ground, name); end - end - end - - sig { returns(Wrapper) } - def self.global; end - - sig { returns(T::Boolean) } - def self.enabled; end - - sig { params(value: T::Boolean).returns(T::Boolean) } - def self.enabled=(value); end - - sig { params(string: String).returns(String) } - def self.uncolor(string); end - - class NullPresenter < String - sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) } - def color(*values); end - - sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) } - def foreground(*values); end - - sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) } - def fg(*values); end - - sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) } - def background(*values); end - - sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) } - def bg(*values); end - - sig { returns(NullPresenter) } - def reset; end - - sig { returns(NullPresenter) } - def bright; end - - sig { returns(NullPresenter) } - def faint; end - - sig { returns(NullPresenter) } - def italic; end - - sig { returns(NullPresenter) } - def underline; end - - sig { returns(NullPresenter) } - def blink; end - - sig { returns(NullPresenter) } - def inverse; end - - sig { returns(NullPresenter) } - def hide; end - - sig { returns(NullPresenter) } - def cross_out; end - - sig { returns(NullPresenter) } - def black; end - - sig { returns(NullPresenter) } - def red; end - - sig { returns(NullPresenter) } - def green; end - - sig { returns(NullPresenter) } - def yellow; end - - sig { returns(NullPresenter) } - def blue; end - - sig { returns(NullPresenter) } - def magenta; end - - sig { returns(NullPresenter) } - def cyan; end - - sig { returns(NullPresenter) } - def white; end - - sig { returns(NullPresenter) } - def bold; end - - sig { returns(NullPresenter) } - def dark; end - - sig { returns(NullPresenter) } - def strike; end - end - - class Presenter < String - TERM_EFFECTS = T.let(nil, T::Hash[Symbol, Integer]) - - sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) } - def color(*values); end - - sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) } - def foreground(*values); end - - sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) } - def fg(*values); end - - sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) } - def background(*values); end - - sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) } - def bg(*values); end - - sig { returns(Presenter) } - def reset; end - - sig { returns(Presenter) } - def bright; end - - sig { returns(Presenter) } - def faint; end - - sig { returns(Presenter) } - def italic; end - - sig { returns(Presenter) } - def underline; end - - sig { returns(Presenter) } - def blink; end - - sig { returns(Presenter) } - def inverse; end - - sig { returns(Presenter) } - def hide; end - - sig { returns(Presenter) } - def cross_out; end - - sig { returns(Presenter) } - def black; end - - sig { returns(Presenter) } - def red; end - - sig { returns(Presenter) } - def green; end - - sig { returns(Presenter) } - def yellow; end - - sig { returns(Presenter) } - def blue; end - - sig { returns(Presenter) } - def magenta; end - - sig { returns(Presenter) } - def cyan; end - - sig { returns(Presenter) } - def white; end - - sig { returns(Presenter) } - def bold; end - - sig { returns(Presenter) } - def dark; end - - sig { returns(Presenter) } - def strike; end - end - - class StringUtils - sig { params(string: String, codes: T::Array[Integer]).returns(String) } - def self.wrap_with_sgr(string, codes); end - - sig { params(string: String).returns(String) } - def uncolor(string); end - end - - VERSION = T.let(nil, String) - - class Wrapper - sig { returns(T::Boolean) } - attr_accessor :enabled - - sig { params(enabled: T::Boolean).void } - def initialize(enabled = true); end - - sig { params(string: String).returns(T.any(Rainbow::Presenter, Rainbow::NullPresenter)) } - def wrap(string); end - end - - module X11ColorNames - NAMES = T.let(nil, T::Hash[Symbol, [Integer, Integer, Integer]]) - end -end - -sig { params(string: String).returns(Rainbow::Presenter) } -def Rainbow(string); end diff --git a/sorbet/rbi/sorbet-typed/lib/rake/all/rake.rbi b/sorbet/rbi/sorbet-typed/lib/rake/all/rake.rbi deleted file mode 100644 index 4ac93ac..0000000 --- a/sorbet/rbi/sorbet-typed/lib/rake/all/rake.rbi +++ /dev/null @@ -1,645 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi sorbet-typed -# -# If you would like to make changes to this file, great! Please upstream any changes you make here: -# -# https://github.com/sorbet/sorbet-typed/edit/master/lib/rake/all/rake.rbi -# -# typed: strict - -module Rake - def self.add_rakelib(*files); end - def self.application; end - def self.application=(app); end - def self.each_dir_parent(dir); end - def self.from_pathname(path); end - def self.load_rakefile(path); end - def self.original_dir; end - def self.suggested_thread_count; end - def self.with_application(block_application = nil); end - extend Rake::FileUtilsExt -end -module Rake::Version -end -class Module - def rake_extension(method); end -end -class String - def ext(newext = nil); end - def pathmap(spec = nil, &block); end - def pathmap_explode; end - def pathmap_partial(n); end - def pathmap_replace(patterns, &block); end -end -module Rake::Win32 - def self.normalize(path); end - def self.win32_system_dir; end - def self.windows?; end -end -class Rake::Win32::Win32HomeError < RuntimeError -end -class Rake::LinkedList - def ==(other); end - def conj(item); end - def each; end - def empty?; end - def head; end - def initialize(head, tail = nil); end - def inspect; end - def self.cons(head, tail); end - def self.empty; end - def self.make(*args); end - def tail; end - def to_s; end - include Enumerable -end -class Rake::LinkedList::EmptyLinkedList < Rake::LinkedList - def empty?; end - def initialize; end - def self.cons(head, tail); end -end -class Rake::CpuCounter - def count; end - def count_with_default(default = nil); end - def self.count; end -end -class Rake::Scope < Rake::LinkedList - def path; end - def path_with_task_name(task_name); end - def trim(n); end -end -class Rake::Scope::EmptyScope < Rake::LinkedList::EmptyLinkedList - def path; end - def path_with_task_name(task_name); end -end -class Rake::TaskArgumentError < ArgumentError -end -class Rake::RuleRecursionOverflowError < StandardError - def add_target(target); end - def initialize(*args); end - def message; end -end -module Rake::TaskManager - def [](task_name, scopes = nil); end - def add_location(task); end - def attempt_rule(task_name, task_pattern, args, extensions, block, level); end - def clear; end - def create_rule(*args, &block); end - def current_scope; end - def define_task(task_class, *args, &block); end - def enhance_with_matching_rule(task_name, level = nil); end - def find_location; end - def generate_did_you_mean_suggestions(task_name); end - def generate_message_for_undefined_task(task_name); end - def generate_name; end - def get_description(task); end - def in_namespace(name); end - def initialize; end - def intern(task_class, task_name); end - def last_description; end - def last_description=(arg0); end - def lookup(task_name, initial_scope = nil); end - def lookup_in_scope(name, scope); end - def make_sources(task_name, task_pattern, extensions); end - def resolve_args(args); end - def resolve_args_with_dependencies(args, hash); end - def resolve_args_without_dependencies(args); end - def self.record_task_metadata; end - def self.record_task_metadata=(arg0); end - def synthesize_file_task(task_name); end - def tasks; end - def tasks_in_scope(scope); end - def trace_rule(level, message); end -end -module Rake::Cloneable - def initialize_copy(source); end -end -module FileUtils - def create_shell_runner(cmd); end - def ruby(*args, **options, &block); end - def safe_ln(*args, **options); end - def set_verbose_option(options); end - def sh(*cmd, &block); end - def sh_show_command(cmd); end - def split_all(path); end -end -module Rake::FileUtilsExt - def cd(*args, **options, &block); end - def chdir(*args, **options, &block); end - def chmod(*args, **options, &block); end - def chmod_R(*args, **options, &block); end - def chown(*args, **options, &block); end - def chown_R(*args, **options, &block); end - def copy(*args, **options, &block); end - def cp(*args, **options, &block); end - def cp_lr(*args, **options, &block); end - def cp_r(*args, **options, &block); end - def install(*args, **options, &block); end - def link(*args, **options, &block); end - def ln(*args, **options, &block); end - def ln_s(*args, **options, &block); end - def ln_sf(*args, **options, &block); end - def makedirs(*args, **options, &block); end - def mkdir(*args, **options, &block); end - def mkdir_p(*args, **options, &block); end - def mkpath(*args, **options, &block); end - def move(*args, **options, &block); end - def mv(*args, **options, &block); end - def nowrite(value = nil); end - def rake_check_options(options, *optdecl); end - def rake_output_message(message); end - def remove(*args, **options, &block); end - def rm(*args, **options, &block); end - def rm_f(*args, **options, &block); end - def rm_r(*args, **options, &block); end - def rm_rf(*args, **options, &block); end - def rmdir(*args, **options, &block); end - def rmtree(*args, **options, &block); end - def safe_unlink(*args, **options, &block); end - def self.nowrite_flag; end - def self.nowrite_flag=(arg0); end - def self.verbose_flag; end - def self.verbose_flag=(arg0); end - def symlink(*args, **options, &block); end - def touch(*args, **options, &block); end - def verbose(value = nil); end - def when_writing(msg = nil); end - extend Rake::FileUtilsExt - include FileUtils -end -class Rake::FileList - def &(*args, &block); end - def *(other); end - def +(*args, &block); end - def -(*args, &block); end - def <<(obj); end - def <=>(*args, &block); end - def ==(array); end - def [](*args, &block); end - def []=(*args, &block); end - def add(*filenames); end - def add_matching(pattern); end - def all?(*args, &block); end - def any?(*args, &block); end - def append(*args, &block); end - def assoc(*args, &block); end - def at(*args, &block); end - def bsearch(*args, &block); end - def bsearch_index(*args, &block); end - def chain(*args, &block); end - def chunk(*args, &block); end - def chunk_while(*args, &block); end - def clear(*args, &block); end - def clear_exclude; end - def collect!(*args, &block); end - def collect(*args, &block); end - def collect_concat(*args, &block); end - def combination(*args, &block); end - def compact!(*args, &block); end - def compact(*args, &block); end - def concat(*args, &block); end - def count(*args, &block); end - def cycle(*args, &block); end - def delete(*args, &block); end - def delete_at(*args, &block); end - def delete_if(*args, &block); end - def detect(*args, &block); end - def difference(*args, &block); end - def dig(*args, &block); end - def drop(*args, &block); end - def drop_while(*args, &block); end - def each(*args, &block); end - def each_cons(*args, &block); end - def each_entry(*args, &block); end - def each_index(*args, &block); end - def each_slice(*args, &block); end - def each_with_index(*args, &block); end - def each_with_object(*args, &block); end - def egrep(pattern, *options); end - def empty?(*args, &block); end - def entries(*args, &block); end - def exclude(*patterns, &block); end - def excluded_from_list?(fn); end - def existing!; end - def existing; end - def ext(newext = nil); end - def fetch(*args, &block); end - def fill(*args, &block); end - def filter!(*args, &block); end - def filter(*args, &block); end - def find(*args, &block); end - def find_all(*args, &block); end - def find_index(*args, &block); end - def first(*args, &block); end - def flat_map(*args, &block); end - def flatten!(*args, &block); end - def flatten(*args, &block); end - def grep(*args, &block); end - def grep_v(*args, &block); end - def group_by(*args, &block); end - def gsub!(pat, rep); end - def gsub(pat, rep); end - def import(array); end - def include(*filenames); end - def include?(*args, &block); end - def index(*args, &block); end - def initialize(*patterns); end - def inject(*args, &block); end - def insert(*args, &block); end - def inspect(*args, &block); end - def is_a?(klass); end - def join(*args, &block); end - def keep_if(*args, &block); end - def kind_of?(klass); end - def last(*args, &block); end - def lazy(*args, &block); end - def length(*args, &block); end - def map!(*args, &block); end - def map(*args, &block); end - def max(*args, &block); end - def max_by(*args, &block); end - def member?(*args, &block); end - def min(*args, &block); end - def min_by(*args, &block); end - def minmax(*args, &block); end - def minmax_by(*args, &block); end - def none?(*args, &block); end - def one?(*args, &block); end - def pack(*args, &block); end - def partition(&block); end - def pathmap(spec = nil, &block); end - def permutation(*args, &block); end - def pop(*args, &block); end - def prepend(*args, &block); end - def product(*args, &block); end - def push(*args, &block); end - def rassoc(*args, &block); end - def reduce(*args, &block); end - def reject!(*args, &block); end - def reject(*args, &block); end - def repeated_combination(*args, &block); end - def repeated_permutation(*args, &block); end - def replace(*args, &block); end - def resolve; end - def resolve_add(fn); end - def resolve_exclude; end - def reverse!(*args, &block); end - def reverse(*args, &block); end - def reverse_each(*args, &block); end - def rindex(*args, &block); end - def rotate!(*args, &block); end - def rotate(*args, &block); end - def sample(*args, &block); end - def select!(*args, &block); end - def select(*args, &block); end - def self.[](*args); end - def self.glob(pattern, *args); end - def shelljoin(*args, &block); end - def shift(*args, &block); end - def shuffle!(*args, &block); end - def shuffle(*args, &block); end - def size(*args, &block); end - def slice!(*args, &block); end - def slice(*args, &block); end - def slice_after(*args, &block); end - def slice_before(*args, &block); end - def slice_when(*args, &block); end - def sort!(*args, &block); end - def sort(*args, &block); end - def sort_by!(*args, &block); end - def sort_by(*args, &block); end - def sub!(pat, rep); end - def sub(pat, rep); end - def sum(*args, &block); end - def take(*args, &block); end - def take_while(*args, &block); end - def to_a; end - def to_ary; end - def to_h(*args, &block); end - def to_s; end - def to_set(*args, &block); end - def transpose(*args, &block); end - def union(*args, &block); end - def uniq!(*args, &block); end - def uniq(*args, &block); end - def unshift(*args, &block); end - def values_at(*args, &block); end - def zip(*args, &block); end - def |(*args, &block); end - include Rake::Cloneable -end -class Rake::Promise - def chore; end - def complete?; end - def discard; end - def error?; end - def initialize(args, &block); end - def recorder; end - def recorder=(arg0); end - def result?; end - def stat(*args); end - def value; end - def work; end -end -class Rake::ThreadPool - def __queue__; end - def future(*args, &block); end - def gather_history; end - def history; end - def initialize(thread_count); end - def join; end - def process_queue_item; end - def safe_thread_count; end - def start_thread; end - def stat(event, data = nil); end - def statistics; end -end -module Rake::PrivateReader - def self.included(base); end -end -module Rake::PrivateReader::ClassMethods - def private_reader(*names); end -end -class Rake::ThreadHistoryDisplay - def initialize(stats); end - def items; end - def rename(hash, key, renames); end - def show; end - def stats; end - def threads; end - extend Rake::PrivateReader::ClassMethods - include Rake::PrivateReader -end -module Rake::TraceOutput - def trace_on(out, *strings); end -end -class Rake::CommandLineOptionError < StandardError -end -class Rake::Application - def add_import(fn); end - def add_loader(ext, loader); end - def collect_command_line_tasks(args); end - def default_task_name; end - def deprecate(old_usage, new_usage, call_site); end - def display_cause_details(ex); end - def display_error_message(ex); end - def display_exception_backtrace(ex); end - def display_exception_details(ex); end - def display_exception_details_seen; end - def display_exception_message_details(ex); end - def display_prerequisites; end - def display_tasks_and_comments; end - def dynamic_width; end - def dynamic_width_stty; end - def dynamic_width_tput; end - def exit_because_of_exception(ex); end - def find_rakefile_location; end - def glob(path, &block); end - def handle_options(argv); end - def has_cause?(ex); end - def has_chain?(exception); end - def have_rakefile; end - def init(app_name = nil, argv = nil); end - def initialize; end - def invoke_task(task_string); end - def load_imports; end - def load_rakefile; end - def name; end - def options; end - def original_dir; end - def parse_task_string(string); end - def print_rakefile_directory(location); end - def rake_require(file_name, paths = nil, loaded = nil); end - def rakefile; end - def rakefile_location(backtrace = nil); end - def raw_load_rakefile; end - def run(argv = nil); end - def run_with_threads; end - def select_tasks_to_show(options, show_tasks, value); end - def select_trace_output(options, trace_option, value); end - def set_default_options; end - def sort_options(options); end - def standard_exception_handling; end - def standard_rake_options; end - def standard_system_dir; end - def system_dir; end - def terminal_columns; end - def terminal_columns=(arg0); end - def terminal_width; end - def thread_pool; end - def top_level; end - def top_level_tasks; end - def trace(*strings); end - def truncate(string, width); end - def truncate_output?; end - def tty_output=(arg0); end - def tty_output?; end - def unix?; end - def windows?; end - include Rake::TaskManager - include Rake::TraceOutput -end -class Rake::PseudoStatus - def >>(n); end - def exited?; end - def exitstatus; end - def initialize(code = nil); end - def stopped?; end - def to_i; end -end -class Rake::TaskArguments - def [](index); end - def each(&block); end - def extras; end - def fetch(*args, &block); end - def has_key?(key); end - def initialize(names, values, parent = nil); end - def inspect; end - def key?(key); end - def lookup(name); end - def method_missing(sym, *args); end - def names; end - def new_scope(names); end - def to_a; end - def to_hash; end - def to_s; end - def values_at(*keys); end - def with_defaults(defaults); end - include Enumerable -end -class Rake::InvocationChain < Rake::LinkedList - def append(invocation); end - def member?(invocation); end - def prefix; end - def self.append(invocation, chain); end - def to_s; end -end -class Rake::InvocationChain::EmptyInvocationChain < Rake::LinkedList::EmptyLinkedList - def append(invocation); end - def member?(obj); end - def to_s; end -end -module Rake::InvocationExceptionMixin - def chain; end - def chain=(value); end -end -class Rake::Task - def actions; end - def add_chain_to(exception, new_chain); end - def add_comment(comment); end - def add_description(description); end - def all_prerequisite_tasks; end - def already_invoked; end - def application; end - def application=(arg0); end - def arg_description; end - def arg_names; end - def clear; end - def clear_actions; end - def clear_args; end - def clear_comments; end - def clear_prerequisites; end - def collect_prerequisites(seen); end - def comment; end - def comment=(comment); end - def enhance(deps = nil, &block); end - def execute(args = nil); end - def first_sentence(string); end - def format_trace_flags; end - def full_comment; end - def initialize(task_name, app); end - def inspect; end - def investigation; end - def invoke(*args); end - def invoke_prerequisites(task_args, invocation_chain); end - def invoke_prerequisites_concurrently(task_args, invocation_chain); end - def invoke_with_call_chain(task_args, invocation_chain); end - def locations; end - def lookup_prerequisite(prerequisite_name); end - def name; end - def name_with_args; end - def needed?; end - def order_only_prerequisites; end - def prereqs; end - def prerequisite_tasks; end - def prerequisites; end - def reenable; end - def scope; end - def self.[](task_name); end - def self.clear; end - def self.create_rule(*args, &block); end - def self.define_task(*args, &block); end - def self.format_deps(deps); end - def self.scope_name(scope, task_name); end - def self.task_defined?(task_name); end - def self.tasks; end - def set_arg_names(args); end - def source; end - def sources; end - def sources=(arg0); end - def timestamp; end - def to_s; end - def transform_comments(separator, &block); end - def |(deps); end -end -class Rake::EarlyTime - def <=>(other); end - def self.allocate; end - def self.instance; end - def self.new(*arg0); end - def to_s; end - extend Singleton::SingletonClassMethods - include Comparable - include Singleton -end -class Rake::FileTask < Rake::Task - def needed?; end - def out_of_date?(stamp); end - def self.scope_name(scope, task_name); end - def timestamp; end -end -class Rake::FileCreationTask < Rake::FileTask - def needed?; end - def timestamp; end -end -class Rake::MultiTask < Rake::Task - def invoke_prerequisites(task_args, invocation_chain); end -end -module Rake::DSL - def cd(*args, **options, &block); end - def chdir(*args, **options, &block); end - def chmod(*args, **options, &block); end - def chmod_R(*args, **options, &block); end - def chown(*args, **options, &block); end - def chown_R(*args, **options, &block); end - def copy(*args, **options, &block); end - def cp(*args, **options, &block); end - def cp_lr(*args, **options, &block); end - def cp_r(*args, **options, &block); end - def desc(description); end - def directory(*args, &block); end - def file(*args, &block); end - def file_create(*args, &block); end - def import(*fns); end - def install(*args, **options, &block); end - def link(*args, **options, &block); end - def ln(*args, **options, &block); end - def ln_s(*args, **options, &block); end - def ln_sf(*args, **options, &block); end - def makedirs(*args, **options, &block); end - def mkdir(*args, **options, &block); end - def mkdir_p(*args, **options, &block); end - def mkpath(*args, **options, &block); end - def move(*args, **options, &block); end - def multitask(*args, &block); end - def mv(*args, **options, &block); end - def namespace(name = nil, &block); end - def nowrite(value = nil); end - def rake_check_options(options, *optdecl); end - def rake_output_message(message); end - def remove(*args, **options, &block); end - def rm(*args, **options, &block); end - def rm_f(*args, **options, &block); end - def rm_r(*args, **options, &block); end - def rm_rf(*args, **options, &block); end - def rmdir(*args, **options, &block); end - def rmtree(*args, **options, &block); end - def ruby(*args, **options, &block); end - def rule(*args, &block); end - def safe_ln(*args, **options); end - def safe_unlink(*args, **options, &block); end - def sh(*cmd, &block); end - def split_all(path); end - def symlink(*args, **options, &block); end - def task(*args, &block); end - def touch(*args, **options, &block); end - def verbose(value = nil); end - def when_writing(msg = nil); end - include Rake::FileUtilsExt -end -class Rake::DefaultLoader - def load(fn); end -end -class Rake::LateTime - def <=>(other); end - def self.allocate; end - def self.instance; end - def self.new(*arg0); end - def to_s; end - extend Singleton::SingletonClassMethods - include Comparable - include Singleton -end -class Rake::NameSpace - def [](name); end - def initialize(task_manager, scope_list); end - def scope; end - def tasks; end -end -module Rake::Backtrace - def self.collapse(backtrace); end -end -class Rake::TaskLib - include Rake::Cloneable - include Rake::DSL -end diff --git a/sorbet/rbi/sorbet-typed/lib/rspec-core/all/rspec-core.rbi b/sorbet/rbi/sorbet-typed/lib/rspec-core/all/rspec-core.rbi deleted file mode 100644 index f11b3ec..0000000 --- a/sorbet/rbi/sorbet-typed/lib/rspec-core/all/rspec-core.rbi +++ /dev/null @@ -1,24 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi sorbet-typed -# -# If you would like to make changes to this file, great! Please upstream any changes you make here: -# -# https://github.com/sorbet/sorbet-typed/edit/master/lib/rspec-core/all/rspec-core.rbi -# -# typed: strict - -module RSpec::Core::ShellEscape - def conditionally_quote(id); end - def escape(shell_command); end - def quote(argument); end - def self.conditionally_quote(id); end - def self.escape(shell_command); end - def self.quote(argument); end - def self.shell_allows_unquoted_ids?; end - def shell_allows_unquoted_ids?; end -end -class RSpec::Core::RakeTask < ::Rake::TaskLib - include ::Rake::DSL - include RSpec::Core::ShellEscape - def initialize(*args, &task_block); end -end diff --git a/sorbet/rbi/sorbet-typed/lib/rubocop/>=1.8/rubocop.rbi b/sorbet/rbi/sorbet-typed/lib/rubocop/>=1.8/rubocop.rbi deleted file mode 100644 index 8c3fd24..0000000 --- a/sorbet/rbi/sorbet-typed/lib/rubocop/>=1.8/rubocop.rbi +++ /dev/null @@ -1,12 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi sorbet-typed -# -# If you would like to make changes to this file, great! Please upstream any changes you make here: -# -# https://github.com/sorbet/sorbet-typed/edit/master/lib/rubocop/>=1.8/rubocop.rbi -# -# typed: strict - -class RuboCop::RakeTask < ::Rake::TaskLib - def initialize(name = :rubocop, *args, &task_block); end -end diff --git a/sorbet/rbi/sorbet-typed/lib/yard/all/yard.rbi b/sorbet/rbi/sorbet-typed/lib/yard/all/yard.rbi deleted file mode 100644 index 47476a2..0000000 --- a/sorbet/rbi/sorbet-typed/lib/yard/all/yard.rbi +++ /dev/null @@ -1,32 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi sorbet-typed -# -# If you would like to make changes to this file, great! Please upstream any changes you make here: -# -# https://github.com/sorbet/sorbet-typed/edit/master/lib/yard/all/yard.rbi -# -# typed: strict - -class YARD::CodeObjects::Base - def initialize(namespace, name, *arg2); end -end -class YARD::CodeObjects::NamespaceObject < YARD::CodeObjects::Base - def mixins(*scopes); end -end -class YARD::CodeObjects::ClassObject < YARD::CodeObjects::NamespaceObject -end -class YARD::CodeObjects::ConstantObject < YARD::CodeObjects::Base -end -class YARD::CodeObjects::Proxy - def initialize(namespace, name, type = nil); end -end -class YARD::Handlers::Base - def handlers; end - def self.handlers; end -end -class YARD::Handlers::Ruby::Base < YARD::Handlers::Base -end -class YARD::Handlers::Ruby::AttributeHandler < YARD::Handlers::Ruby::Base -end -class YARD::Handlers::Ruby::MethodHandler < YARD::Handlers::Ruby::Base -end From 88129b97490753a6131b87cbea558f0baa1cf4a5 Mon Sep 17 00:00:00 2001 From: nijeeshjoshy Date: Thu, 5 Mar 2026 13:13:09 +0100 Subject: [PATCH 4/6] chore: make lint configurable via matrix flag instead of hardcoded ruby version check Co-Authored-By: Claude Sonnet 4.6 --- .github/workflows/ci.yml | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 6b82e9a..474ec78 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -9,6 +9,11 @@ jobs: max-parallel: 1 matrix: ruby: ["3.0", "3.1", "3.4", "4.0"] + include: + # Add lint: true to any Ruby version that should run rubocop + srb tc. + # Always include 4.0; also add it to the latest Ruby when a newer version is added. + - ruby: "4.0" + lint: true name: 💎 Ruby ${{ matrix.ruby }} steps: - uses: actions/checkout@v4 @@ -21,10 +26,10 @@ jobs: bundler-cache: true - run: bundle exec rake rubocop - if: ${{ matrix.ruby == '3.4' || matrix.ruby == '4.0' }} + if: ${{ matrix.lint == true }} - run: bundle exec srb tc - if: ${{ matrix.ruby == '3.4' || matrix.ruby == '4.0' }} + if: ${{ matrix.lint == true }} - run: bundle exec rspec ./spec --require spec_helper env: From 349765179e2e86b2e316e8d519d358ec0875ebb5 Mon Sep 17 00:00:00 2001 From: nijeesh-stream Date: Thu, 5 Mar 2026 13:43:26 +0100 Subject: [PATCH 5/6] enabled lint check on ruby 3.4 as well --- .github/workflows/ci.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 474ec78..8905680 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -14,6 +14,8 @@ jobs: # Always include 4.0; also add it to the latest Ruby when a newer version is added. - ruby: "4.0" lint: true + - ruby: "3.4" + lint: true name: 💎 Ruby ${{ matrix.ruby }} steps: - uses: actions/checkout@v4 From 4e3be11ba7fd1657f8ab15bc6fcc30e8ab4147c5 Mon Sep 17 00:00:00 2001 From: nijeesh-stream Date: Thu, 5 Mar 2026 13:43:29 +0100 Subject: [PATCH 6/6] fix: tighten sorbet-runtime upper bound from < 2 to < 1 Current sorbet versions are 0.5.x and 0.6.x, both of which are < 1. Using < 2 was unnecessarily wide and would allow a hypothetical 1.x series without explicit opt-in. --- stream-chat.gemspec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/stream-chat.gemspec b/stream-chat.gemspec index 1d9db03..5204491 100644 --- a/stream-chat.gemspec +++ b/stream-chat.gemspec @@ -31,5 +31,5 @@ Gem::Specification.new do |gem| gem.add_dependency 'faraday-net_http_persistent', '~> 2.3' gem.add_dependency 'jwt', '~> 2.10' gem.add_dependency 'net-http-persistent', '~> 4.0' - gem.add_dependency 'sorbet-runtime', '>= 0.5.11820', '< 2' + gem.add_dependency 'sorbet-runtime', '>= 0.5.11820', '< 1' end