sorbet-rails 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6a4e4c9b0f6d3cb813771d9673fb2c483507292f
-  data.tar.gz: d34bda0c4a4a9269b8bf6a32cd8e7734888613d3
+  metadata.gz: 319136a77de53915ea8e2999617f3942dc9913dd
+  data.tar.gz: e3cd87219252f35701df8647edcf752244bf0534
 SHA512:
-  metadata.gz: 8a346f014c1761602c445cc5ce1241e9643988433776c7d05f250f0a85d355bf5226a15b160ed1bf843b1d2268069ed736e16687a9a013e0494a3000aae20eb5
-  data.tar.gz: 7844cc11287fe4108610435b9b8cba3387d122c0a074b92c89d22ad058ffcbc0c17cca311c9e38c38314ec049c30c25933359183d5b3f7cfbfe7de8a3c5e0f6e
+  metadata.gz: fbd53d9c25ae7d561d1a817f07c042fc7f014a3765726dfdefc7d2ab528a0321463d3f2511bbcdf1dcc4a9a6d10b973eaf4f0497f2b59b3edd6fe947f0ca178e
+  data.tar.gz: b5e9cdb6b32400026629532bdb75da9aee0518432dac9608ac68b7587ec8d04c602a0aa2983ff9ff905f8220fe2a89ad4ea5b479d302cfda2dd5349dbf74b892

data/.gitignore

@@ -42,7 +42,7 @@ build-iPhoneSimulator/
 
 # for a library or gem, you might want to ignore these files since the code is
 # intended to run in multiple environments; otherwise, check them in:
-Gemfile.lock
+/Gemfile.lock
 .ruby-version
 .ruby-gemset
 
@@ -80,4 +80,7 @@ Gemfile.lock
 /spec/support/**/sorbet/rails-rbi/*
 /spec/support/**/sorbet/rails-rbi/**/*
 
-
+# Ignore sorbet files in v5.2-no-sorbet
+/spec/support/v5.2-no-sorbet/sorbet_test_cases.rb
+/spec/support/v5.2-no-sorbet/sorbet/*
+/spec/support/v5.2-no-sorbet/sorbet/**/*

data/.travis.yml

@@ -15,6 +15,11 @@ rvm:
 - 2.6
 - ruby-head
 matrix:
+  include:
+  - rvm: 2.5
+    env: RAILS_VERSION=5.2 SORBET_VERSION=0.4.4386
+  - rvm: 2.5
+    env: TEST_SRB_INIT=true
   exclude:
   - rvm: 2.3
     env: RAILS_VERSION=6.0
@@ -22,6 +27,7 @@ matrix:
     env: RAILS_VERSION=6.0
   allow_failures:
   - rvm: ruby-head
+  - env: RAILS_VERSION=5.2
 before_install:
 - gem install bundler -v 2.0.1 --no-doc
 - gem install bundler -v 1.17.3 --no-doc
@@ -34,5 +40,5 @@ deploy:
     secure: AVQi+tC5+HEoGgOKj/+/UeizOkwgVoB8zdPrd48/H9rx1KsAAmQ+2N9srOnrrEkm9I/bvHLOs0JpM96IiXFhztzrDefkaYQc1Zhu3tbWKZf6kuw0gabTMGhx3JsLoQiYRbJYea1qfrL0XlvQTxgkaa4zGJQaIBIZ97X7jlG5lVcys7JGjUFkozGJgS0t2HDffgDPLs3SiWR380Zvo4xcogw9tFHg5MuirZM/bXb9C/WhdDmKV9LbM8bTkJBjkZ0jbzKITtDJWSCXzdjRebLesTVN6F6cNWkwp2TumefgpQId4uGa5iUN8nXriqN890jjeZ3xHDq7xF0dRZgr8TyreocevCtNPCl+12c9ook0+mJn2GFTJL4W9BTuBGkBFekcQZ5MChWywcJ280iuPfX56Ilpt0wkCtWgB0k+k+eGTgEUv0iLykRFytNfiXr1oySG6mzxcUMf90IxfIKMydjFl8ZmAoTmZDfECtk59IW3PRwfHnNiNwmGMIGz9x9geO0wORWWnqdAwvHnQ7wMdScbSZ/VIPvpBdNe3rbhh4xAXXen+t1V0jvAlkBng9GLCwaRWuAsQG3fvRCbjWGxVmCLaQjUqIoJOtNVgeww+s5bXc8eVUtJ2UNRNnlN78lCWrRBhEfgRoyhVzl47vSZjhOE/2JlmQhpot9nwmMOz1h9wk8=
   gem: sorbet-rails
   on:
+    tags: true
     repo: chanzuckerberg/sorbet-rails
-    branch: setup_travis

data/CONTRIBUTING.md

@@ -85,8 +85,10 @@ You can also switch to a version of Rails with `RAILS_VERSION`:
 
 ```sh
 ❯ RAILS_VERSION=4.2 ./spec/bin/run_spec.sh
+❯ RAILS_VERSION=5.0 ./spec/bin/run_spec.sh
 ❯ RAILS_VERSION=5.1 ./spec/bin/run_spec.sh
 ❯ RAILS_VERSION=5.2 ./spec/bin/run_spec.sh
+❯ RAILS_VERSION=6.0 ./spec/bin/run_spec.sh
 ```
 
 #### Debugging
@@ -107,7 +109,7 @@ execution to stop, which will then start a debugger. For more, check out the
 
 ### Writing Tests
 
-Tests are in the `_spec.rb` files in the [`spec/`](spec/) directory.
+Tests are in the `_spec.rb` files in the [`spec/`](spec/) directory. Sorbet's `srb tc` test cases are in [`spec/support/rails_shared/sorbet_test_cases.rb`](spec/support/rails_shared/sorbet_test_cases.rb).
 
 Rails apps are stored in [`spec/support/`](spec/support/). Code shared across Rails versions
 (models, views, controllers) are in [`spec/support/rails_shared/`](spec/support/rails_shared/)

data/Gemfile

@@ -38,3 +38,14 @@ else
   gem "bundler", ">= 2.0"
   gem "sqlite3", "~> 1.4.1"
 end
+
+sorbet_version = ENV["SORBET_VERSION"]
+if sorbet_version
+  # mostly used to test against a stable version of Sorbet in Travis.
+  gem 'sorbet', sorbet_version
+  gem 'sorbet-runtime', sorbet_version
+else
+  # prefer to test against latest version because sorbet is updated frequently
+  gem 'sorbet'
+  gem 'sorbet-runtime'
+end

data/README.md

@@ -13,8 +13,6 @@ This gem adds a few Rake tasks to generate Ruby Interface (RBI) files for dynami
 
 1. Follow the steps [here](https://sorbet.org/docs/adopting) to set up the latest version of Sorbet, up to being able to run `srb tc`.
 
-Note: Do not add `sorbet-rails` to your Gemfile until after you've set up Sorbet. `sorbet-rails` adds RBI files that may [break](https://github.com/sorbet/sorbet/issues/1158) `srb init`.
-
 2. Add `sorbet-rails` to your Gemfile and install them with Bundler.
 
 ```

data/{rbi → lib/sorbet-rails/rbi}/activerecord.rbi

@@ -3,7 +3,7 @@ class ActiveRecord::Relation
   extend T::Sig
   extend T::Generic
   include Enumerable
-  include ActiveRecord::Querying::Typed
+  include SorbetRails::CustomFinderMethods
 
   Elem = type_member(fixed: ActiveRecord::Base)
 
@@ -17,47 +17,28 @@ class ActiveRecord::Relation
   def to_a; end
 
   # This is part of both FinderMethods & Enumerable module.
-  # We need to define here to override the typedef in Enumerable module.
-  # TODO normally this method could return Elem or Array[Elem]
-  # however, we think it's better to limit the interface to returning Elem only
-  # Use `find_n` as a replacement if you want to get an array from `find`
+  # These methods would return 1 single element when there is no limit, and return an
+  # array of element when there is a limit passed in.
+  # The more common use case is to find 1 object. We use that as the default sig
+  # and add custom first_n, last_n method for the cases that return an array
   sig { params(args: T.untyped).returns(Elem) }
   def find(*args); end
-end
-
-class ActiveRecord::Associations::CollectionProxy < ActiveRecord::Relation
-  extend T::Generic
-
-  Elem = type_member(fixed: ActiveRecord::Base)
-
-  # -- << and aliases
-  sig { params(records: T.any(Elem, T::Array[Elem])).returns(T.self_type) }
-  def <<(*records); end
-  sig { params(records: T.any(Elem, T::Array[Elem])).returns(T.self_type) }
-  def append(*records); end
-  sig { params(records: T.any(Elem, T::Array[Elem])).returns(T.self_type) }
-  def push(*records); end
-  sig { params(records: T.any(Elem, T::Array[Elem])).returns(T.self_type) }
-  def concat(*records); end
-end
-
-
-module ActiveRecord::Querying::Typed
-  extend T::Sig
-  extend T::Generic
-  Elem = type_member(fixed: ActiveRecord::Base)
+  sig { params(limit: T.nilable(Integer)).returns(T.nilable(Elem)) }
+  def first(limit = nil); end
+  sig { params(limit: T.nilable(Integer)).returns(T.nilable(Elem)) }
+  def last(limit = nil); end
 
-  # -- Booleans
-  sig { params(args: T.untyped, block: T.nilable(T.proc.void)).returns(T::Boolean) }
-  def exists?(*args, &block); end
-  sig { params(args: T.untyped, block: T.nilable(T.proc.void)).returns(T::Boolean) }
-  def any?(*args, &block); end
-  sig { params(args: T.untyped, block: T.nilable(T.proc.void)).returns(T::Boolean) }
-  def many?(*args, &block); end
-  sig { params(args: T.untyped, block: T.nilable(T.proc.void)).returns(T::Boolean) }
-  def none?(*args, &block); end
-  sig { params(args: T.untyped, block: T.nilable(T.proc.void)).returns(T::Boolean) }
-  def one?(*args, &block); end
+  # -- place here to avoid conflicts with sorbet generated gem rbi
+  sig { params(conditions: T.untyped).returns(T::Boolean) }
+  def exists?(conditions = nil); end
+  sig { returns(T::Boolean) }
+  def any?; end
+  sig { returns(T::Boolean) }
+  def many?; end
+  sig { returns(T::Boolean) }
+  def none?; end
+  sig { returns(T::Boolean) }
+  def one?; end
 
   # -- finder methods
   sig { returns(Elem) }
@@ -90,18 +71,45 @@ module ActiveRecord::Querying::Typed
   sig { returns(T.nilable(Elem)) }
   def second_to_last; end
 
-  # These methods would return 1 single element when there is no limit, and return an
-  # array of element when there is a limit passed in.
-  # The more common use case is to find 1 object. We use that as the default sig
-  # and add custom first_n, last_n method for the cases that return an array
-  sig { params(limit: T.nilable(Integer)).returns(T.nilable(Elem)) }
-  def first(limit = nil); end
-  sig { params(limit: T.nilable(Integer)).returns(T.nilable(Elem)) }
-  def last(limit = nil); end
-  # Similar to first & last, normally this method could return Elem or Array[Elem]
-  # But we enforce that `find` return Elem by default and provide find_n as an alternative
-  sig { params(args: T.any(Integer, String)).returns(Elem) }
+  sig { params(arg: T.untyped, args: T.untyped).returns(T.nilable(Elem)) }
+  def find_by(arg, *args); end
+  sig { params(arg: T.untyped, args: T.untyped).returns(Elem) }
+  def find_by!(arg, *args); end
+end
+
+class ActiveRecord::Associations::CollectionProxy < ActiveRecord::Relation
+  extend T::Generic
+
+  Elem = type_member(fixed: ActiveRecord::Base)
+
+  sig { params(block: T.proc.params(e: Elem).void).void }
+  def each(&block); end
+
+  sig { returns(T::Array[Elem]) }
+  def to_a; end
+
+  # -- << and aliases
+  sig { params(records: T.any(Elem, T::Array[Elem])).returns(T.self_type) }
+  def <<(*records); end
+  sig { params(records: T.any(Elem, T::Array[Elem])).returns(T.self_type) }
+  def append(*records); end
+  sig { params(records: T.any(Elem, T::Array[Elem])).returns(T.self_type) }
+  def push(*records); end
+  sig { params(records: T.any(Elem, T::Array[Elem])).returns(T.self_type) }
+  def concat(*records); end
+
+  # -- Overridden finder methods
+  sig { params(args: T.untyped).returns(Elem) }
   def find(*args); end
+  # sig { params(limit: T.nilable(Integer)).returns(T.nilable(Elem)) }
+  # def last(limit = nil); end
+end
+
+module SorbetRails::CustomFinderMethods
+  extend T::Sig
+  extend T::Generic
+  Elem = type_member(fixed: ActiveRecord::Base)
+
   # These are custom finder methods to provide strong type for secondary use case of first, last & find
   # See sorbet_rails/custom_finder_methods
   sig { params(limit: Integer).returns(T::Array[Elem]) }
@@ -111,23 +119,11 @@ module ActiveRecord::Querying::Typed
   sig { params(args: T::Array[T.any(Integer, String)]).returns(T::Array[Elem]) }
   def find_n(*args); end
 
-  sig { params(args: T.untyped, block: T.nilable(T.proc.void)).returns(T.nilable(Elem)) }
-  def find_by(*args, &block); end
-
-  sig { params(args: T.untyped, block: T.nilable(T.proc.void)).returns(Elem) }
-  def find_by!(*args, &block); end
-
+  # allow common cases of find_by
   sig { params(id: Integer).returns(T.nilable(Elem)) }
   def find_by_id(id); end
-
   sig { params(id: Integer).returns(Elem) }
   def find_by_id!(id); end
-
-  # -- Calculation
-  # There can be a complication of using count with .group
-  # https://api.rubyonrails.org/classes/ActiveRecord/Calculations.html#method-i-count
-  # sig { params(args: T.untyped, block: T.nilable(T.proc.void)).returns(Integer) }
-  # def count(*args, &block); end
 end
 
 module ActiveRecord::QueryMethods
@@ -139,37 +135,73 @@ module ActiveRecord::QueryMethods
 end
 
 class ActiveRecord::Base
-  extend ActiveRecord::Querying::Typed
+  extend SorbetRails::CustomFinderMethods
   extend T::Generic
   Elem = type_template(fixed: ActiveRecord::Base)
-  include ActiveRecord::AttributeMethods::Dirty
-  include ActiveModel::Dirty
-end
 
-class ApplicationRecord
-  extend T::Generic
-  Elem = type_template(fixed: ApplicationRecord)
-end
+  # -- place here to avoid conflicts with sorbet generated gem rbis
 
-module ActiveModel::Dirty
-  extend T::Sig
+  # These methods would return 1 single element when there is no limit, and return an
+  # array of element when there is a limit passed in.
+  # The more common use case is to find 1 object. We use that as the default sig
+  # and add custom first_n, last_n method for the cases that return an array
+  sig { params(args: T.untyped).returns(Elem) }
+  def self.find(*args); end
+  sig { params(limit: T.nilable(Integer)).returns(T.nilable(Elem)) }
+  def self.first(limit = nil); end
+  sig { params(limit: T.nilable(Integer)).returns(T.nilable(Elem)) }
+  def self.last(limit = nil); end
 
-  sig { params(attr: Symbol, from: T.untyped, to: T.untyped).returns(T::Boolean) }
-  def attribute_changed?(attr, from: nil, to: nil); end
+  # -- place here to avoid conflicts with sorbet generated gem rbi
+  sig { params(conditions: T.untyped).returns(T::Boolean) }
+  def self.exists?(conditions = nil); end
+  sig { returns(T::Boolean) }
+  def self.any?; end
+  sig { returns(T::Boolean) }
+  def self.many?; end
+  sig { returns(T::Boolean) }
+  def self.none?; end
+  sig { returns(T::Boolean) }
+  def self.one?; end
 
-  sig { params(attr_name: Symbol).returns(T::Boolean) }
-  def attribute_changed_in_place?(attr_name); end
+  # -- finder methods
+  sig { returns(Elem) }
+  def self.first!; end
+  sig { returns(Elem) }
+  def self.second!; end
+  sig { returns(T.nilable(Elem)) }
+  def self.second; end
+  sig { returns(Elem) }
+  def self.third!; end
+  sig { returns(T.nilable(Elem)) }
+  def self.third; end
+  sig { returns(Elem) }
+  def self.fourth!; end
+  sig { returns(T.nilable(Elem)) }
+  def self.fourth; end
+  sig { returns(Elem) }
+  def self.fifth!; end
+  sig { returns(T.nilable(Elem)) }
+  def self.fifth; end
 
-  sig { params(attr_name: Symbol).returns(T::Boolean) }
-  def attribute_previously_changed?(attr_name); end
+  sig { returns(Elem) }
+  def self.last!; end
+  sig { returns(Elem) }
+  def self.third_to_last!; end
+  sig { returns(T.nilable(Elem)) }
+  def self.third_to_last; end
+  sig { returns(Elem) }
+  def self.second_to_last!; end
+  sig { returns(T.nilable(Elem)) }
+  def self.second_to_last; end
 
-  sig { returns(T::Boolean) }
-  def changed?; end
+  sig { params(arg: T.untyped, args: T.untyped).returns(T.nilable(Elem)) }
+  def self.find_by(arg, *args); end
+  sig { params(arg: T.untyped, args: T.untyped).returns(Elem) }
+  def self.find_by!(arg, *args); end
 end
 
-module ActiveRecord::AttributeMethods::Dirty
-  extend T::Sig
-
-  sig { params(attr_name: Symbol, options: T.untyped).returns(T::Boolean) }
-  def saved_change_to_attribute?(attr_name, **options); end
+class ApplicationRecord < ActiveRecord::Base
+  extend T::Generic
+  Elem = type_template(fixed: ApplicationRecord)
 end

data/lib/sorbet-rails/tasks/rails_rbi.rake

@@ -1,5 +1,10 @@
 require("sorbet-rails/model_rbi_formatter")
 require("sorbet-rails/routes_rbi_formatter")
+require("sorbet-rails/utils")
+
+# this is ugly but it's a way to get the current directory of this script
+# maybe someone coming along will know a better way
+@@sorbet_rails_rake_dir = File.dirname(__FILE__)
 
 namespace :rails_rbi do
 
@@ -16,12 +21,9 @@ namespace :rails_rbi do
 
   desc "Generate rbi for rails models. Pass models name to regenrate rbi for only the given models."
   task models: :environment do |t, args|
-    # need to eager load to see all models
-    Rails.application.eager_load!
-    # Rails 6.0 change the loading logic to use Zeitwerk
-    # https://github.com/rails/rails/blob/master/railties/lib/rails/application/finisher.rb#L116
-    # But this is not applied to Rails.application.eager_load! method
-    Zeitwerk::Loader.eager_load_all if defined?(Zeitwerk)
+    SorbetRails::Utils.rails_eager_load_all!
+
+    copy_bundled_rbi
 
     all_models = Set.new(ActiveRecord::Base.descendants + whitelisted_models - blacklisted_models)
 
@@ -37,6 +39,13 @@ namespace :rails_rbi do
     end
   end
 
+  def copy_bundled_rbi
+    bundled_rbi_path = File.join(@@sorbet_rails_rake_dir, "..", "rbi", ".")
+    copy_to_path = Rails.root.join("sorbet", "rails-rbi")
+    FileUtils.mkdir_p(File.dirname(copy_to_path))
+    FileUtils.cp_r(bundled_rbi_path, copy_to_path)
+  end
+
   def generate_rbis_for_models(model_classes, available_classes)
     available_class_names = Set.new(available_classes.map { |c| c.name })
     formatted = model_classes.map do |model_class|

data/lib/sorbet-rails/utils.rb

@@ -0,0 +1,11 @@
+
+module SorbetRails::Utils
+  def self.rails_eager_load_all!
+    # need to eager load to see all models
+    Rails.configuration.eager_load_namespaces.each { |ns| ns.try(:eager_load!) }
+    # Rails 6.0 change the loading logic to use Zeitwerk
+    # https://github.com/rails/rails/blob/master/railties/lib/rails/application/finisher.rb#L116
+    # But this is not applied to Rails.application.eager_load! method
+    Zeitwerk::Loader.eager_load_all if defined?(Zeitwerk)
+  end
+end

data/sorbet-rails.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name          = %q{sorbet-rails}
-  s.version       = "0.3.0"
+  s.version       = "0.4.0"
   s.date          = %q{2019-04-18}
   s.summary       = %q{Set of tools to make Sorbet work with Rails seamlessly.}
   s.authors       = ["Chan Zuckerberg Initiative"]

data/spec/bin/run_all_specs.sh

@@ -6,8 +6,9 @@ wd="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 RAILS_VERSION=4.2 bash $wd/run_spec.sh
 RAILS_VERSION=5.0 bash $wd/run_spec.sh
 RAILS_VERSION=5.1 bash $wd/run_spec.sh
-RAILS_VERSION=5.2 bash $wd/run_spec.sh
 RAILS_VERSION=6.0 bash $wd/run_spec.sh
 
-# Always end with the default version
+TEST_SRB_INIT=1 bash $wd/run_spec.sh
+
+# Always end with the default version, which is Rails 5.2
 sh $wd/run_spec.sh

data/spec/bin/run_spec.sh

@@ -3,31 +3,38 @@
 
 # need to use bash so that $wd returns the location of the script
 wd="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+current_dir=$(pwd)
+
+if [[ -z $RAILS_VERSION ]]; then
+  if [[ -z $TEST_SRB_INIT ]]; then
+    rails_dir="$wd/../support/v5.2"
+  else
+    rails_dir="$wd/../support/v5.2-no-sorbet"
+  fi
+else
+  rails_dir="$wd/../support/v$RAILS_VERSION"
+fi
+
+bundle_version=$([ "$RAILS_VERSION" == 4.2 ] && echo "_1.17.3_" || echo "")
+
+# clean up & install gems
 rm $wd/../../Gemfile.lock 2>/dev/null # clean up Gemfile.lock first
+bundle $bundle_version install
+
+echo $rails_dir
+
+# update gems in rails_dir
+cd $rails_dir
+bundle $bundle_version install
+
+# move back to current dir to run test
+cd $current_dir
 
-case $RAILS_VERSION in
-  4.2)
-    echo 'run spec with Rails 4.2'
-    RAILS_VERSION=4.2 bundle _1.17.3_ update && RAILS_VERSION=4.2 bundle _1.17.3_ exec rake
-    ;;
-  5.0)
-    echo 'run spec with Rails 5.0'
-    RAILS_VERSION=5.0 bundle update && RAILS_VERSION=5.0 bundle exec rake
-    ;;
-  5.1)
-    echo 'run spec with Rails 5.1'
-    RAILS_VERSION=5.1 bundle update && RAILS_VERSION=5.1 bundle exec rake
-    ;;
-  5.2)
-    echo 'run spec with Rails 5.2'
-    RAILS_VERSION=5.2 bundle update && RAILS_VERSION=5.2 bundle exec rake
-    ;;
-  6.0)
-    echo 'run spec with Rails 6.0'
-    RAILS_VERSION=6.0 bundle update && RAILS_VERSION=6.0 bundle exec rake
-    ;;
-  *)
-    echo 'run default'
-    bundle update && bundle exec rake
-    ;;
-esac
+if [[ -z $RAILS_VERSION ]]; then
+  echo "---- Run DEFAULT ----"
+  bundle update && bundle exec rake
+else
+  echo "---- Run $RAILS_VERSION ----"
+  RAILS_VERSION=$RAILS_VERSION bundle $bundle_version update
+  RAILS_VERSION=$RAILS_VERSION bundle $bundle_version exec rake
+fi

data/spec/model_rbi_formatter_spec.rb

@@ -3,21 +3,6 @@ require 'sorbet-rails/model_rbi_formatter'
 
 RSpec.describe ModelRbiFormatter do
 
-  it 'loads all the models in the app' do
-    expected_models = [
-      Potion,
-      SpellBook,
-      Wand,
-      Wizard,
-    ]
-
-    Rails.application.eager_load!
-    # Needed for Rails 6.0
-    Zeitwerk::Loader.eager_load_all if defined?(Zeitwerk)
-    all_models = ActiveRecord::Base.descendants
-    expect((expected_models - all_models)).to eql([])
-  end
-
   it 'does not throw an error when given an abstract class' do
     formatter = ModelRbiFormatter.new(Potion, ['Potion'])
     expect_match_file(

data/spec/rails_helper.rb

@@ -22,7 +22,7 @@ rails_folder =
   when "6.0"
     "v6.0"
   else
-    "v5.2"
+    ENV["TEST_SRB_INIT"] ? "v5.2-no-sorbet" : "v5.2"
   end
 
 TEST_DATA_FOLDER = "spec/test_data/#{rails_folder}"
@@ -31,10 +31,16 @@ require "support/#{rails_folder}/config/environment"
 
 ActiveRecord::Migration.maintain_test_schema!
 
+require 'rake_helper'
+
 RSpec.configure do |config|
   config.before(:suite) do
     next if ENV["DISABLE_DATABASE_CLEANER"] == 'true'
-    DatabaseCleaner.clean_with(:truncation, {pre_count: true, reset_ids: false})
+    DatabaseCleaner.clean_with(:truncation, {
+      pre_count: true,
+      reset_ids: false,
+      except: %w(ar_internal_metadata),
+    })
   end
 
   config.around(:each) do |example|
@@ -42,11 +48,10 @@ RSpec.configure do |config|
       example.run
       next
     end
-    if example.metadata.fetch(:transaction, true)
-      DatabaseCleaner.strategy = :transaction
-    else
-      DatabaseCleaner.strategy = :truncation, {pre_count: true, reset_ids: false}
-    end
+    DatabaseCleaner.strategy = :truncation, {
+      pre_count: true,
+      reset_ids: false,
+    }
     DatabaseCleaner.start
     example.run
     DatabaseCleaner.clean

data/spec/rake_rails_rbi_models_spec.rb

@@ -1,8 +1,7 @@
 require 'rails_helper'
-require 'rake_helper'
 
 RSpec.describe 'rake rails_rbi:models', type: :task do
-  let!(:expected_dir_path) { Rails.root.join("sorbet", "rails-rbi", "models") }
+  let!(:generated_dir_path) { Rails.root.join("sorbet", "rails-rbi", "models") }
 
   it "preloads the Rails environment" do
     expect(task.prerequisites).to include("environment")
@@ -11,7 +10,7 @@ RSpec.describe 'rake rails_rbi:models', type: :task do
   it "generates model files correctly" do
     task.invoke
     expect_files(
-      base_dir: expected_dir_path,
+      base_dir: generated_dir_path,
       files: [
         'potion.rbi',
         'spell_book.rbi',
@@ -19,12 +18,30 @@ RSpec.describe 'rake rails_rbi:models', type: :task do
         'wizard.rbi',
       ]
     )
+    if Object.const_defined?('ActiveStorage')
+      expect_files(
+        base_dir: generated_dir_path.join('active_storage'),
+        files: [
+          'attachment.rbi',
+          'blob.rbi',
+        ],
+      )
+    end
+    if Object.const_defined?('ActiveRecord::InternalMetadata')
+      expect_files(
+        base_dir: generated_dir_path.join('active_record'),
+        files: [
+          'internal_metadata.rbi',
+          'schema_migration.rbi',
+        ]
+      )
+    end
   end
 
   it 'generates selected model correctly' do
     task.invoke("Wizard")
     expect_files(
-      base_dir: expected_dir_path,
+      base_dir: generated_dir_path,
       files: [
         'wizard.rbi',
       ]
@@ -34,7 +51,7 @@ RSpec.describe 'rake rails_rbi:models', type: :task do
   it 'generates more than 1 selected models correctly' do
     task.invoke("Wizard","SpellBook")
     expect_files(
-      base_dir: expected_dir_path,
+      base_dir: generated_dir_path,
       files: [
         'spell_book.rbi',
         'wizard.rbi',

data/spec/rake_rails_rbi_routes_spec.rb

@@ -1,5 +1,4 @@
 require 'rails_helper'
-require 'rake_helper'
 
 RSpec.describe 'rake rails_rbi:routes', type: :task do
   it "preloads the Rails environment" do