sorbet-rails 0.6.2 → 0.6.3

data/spec/generators/sorbet_test_cases.rb

@@ -1,4 +1,4 @@
-# typed: false
+# typed: true
 require 'sorbet-runtime'
 
 wand = Wand.first!
@@ -27,6 +27,7 @@ T.assert_type!(T.must(wizard.wand).wizard, Wizard)
 # T.assert_type!(wizard.spell_books, SpellBook::ActiveRecord_Relation)
 # T.assert_type!(wizard.spell_books, SpellBook::ActiveRecord_AssociationRelation)
 T.assert_type!(wizard.spell_books, SpellBook::ActiveRecord_Associations_CollectionProxy)
+T.assert_type!(wizard.spell_book_ids, T::Array[Integer])
 
 # -- model relation
 # default
@@ -53,6 +54,14 @@ T.assert_type!(Wizard.exists?(name: 'Test'), T::Boolean)
 T.assert_type!(Wizard.find(wizard.id), Wizard)
 T.assert_type!(Wizard.first!, Wizard)
 T.assert_type!(Wizard.first, T.nilable(Wizard))
+T.assert_type!(Wizard.second!, Wizard)
+T.assert_type!(Wizard.second, T.nilable(Wizard))
+T.assert_type!(Wizard.third!, Wizard)
+T.assert_type!(Wizard.third, T.nilable(Wizard))
+T.assert_type!(Wizard.third_to_last!, Wizard)
+T.assert_type!(Wizard.third_to_last, T.nilable(Wizard))
+T.assert_type!(Wizard.second_to_last!, Wizard)
+T.assert_type!(Wizard.second_to_last, T.nilable(Wizard))
 T.assert_type!(Wizard.last!, Wizard)
 T.assert_type!(Wizard.last, T.nilable(Wizard))
 T.assert_type!(Wizard.first_n(5), T::Array[Wizard])
@@ -61,12 +70,40 @@ T.assert_type!(Wizard.find_by(name: 'Harry Potter'), T.nilable(Wizard))
 T.assert_type!(Wizard.find_by!(name: 'Harry Potter'), Wizard)
 T.assert_type!(Wizard.find_by_id(wizard.id), T.nilable(Wizard))
 T.assert_type!(Wizard.find_by_id!(wizard.id), Wizard)
+T.assert_type!(Wizard.find_or_initialize_by(name: 'Harry Potter') { |w| T.assert_type!(w, Wizard) }, Wizard)
+T.assert_type!(Wizard.find_or_create_by(name: 'Harry Potter') { |w| T.assert_type!(w, Wizard) }, Wizard)
+T.assert_type!(Wizard.find_or_create_by!(name: 'Harry Potter') { |w| T.assert_type!(w, Wizard) }, Wizard)
+T.assert_type!(Wizard.new { |w| T.assert_type!(w, Wizard) }, Wizard)
+T.assert_type!(Wizard.create(name: 'Harry Potter') { |w| T.assert_type!(w, Wizard) }, Wizard)
+T.assert_type!(Wizard.create!(name: 'Harry Potter') { |w| T.assert_type!(w, Wizard) }, Wizard)
+T.assert_type!(Wizard.first_or_create(name: 'Harry Potter') { |w| T.assert_type!(w, Wizard) }, Wizard)
+T.assert_type!(Wizard.first_or_create!(name: 'Harry Potter') { |w| T.assert_type!(w, Wizard) }, Wizard)
+T.assert_type!(Wizard.first_or_initialize { |w| T.assert_type!(w, Wizard) }, Wizard)
+Wizard.find_each { |w| T.assert_type!(w, Wizard) }
+T.assert_type!(Wizard.find_each, T::Enumerator[Wizard])
+Wizard.find_in_batches { |w| T.assert_type!(w, T::Array[Wizard]) }
+T.assert_type!(Wizard.find_in_batches, T::Enumerator[T::Array[Wizard]])
+# T.assert_type!(Wizard.destroy_all, T::Array[Wizard]) # Ignored until we add support
+T.assert_type!(Wizard.any?, T::Boolean)
+T.assert_type!(Wizard.many?, T::Boolean)
+T.assert_type!(Wizard.none?, T::Boolean)
+T.assert_type!(Wizard.one?, T::Boolean)
+# T.assert_type!(Wizard.update_all(name: 'Harry Potter'), Integer) # Ignored until we add support
+# T.assert_type!(Wizard.delete_all, Integer) # Ignored until we add support
 
 # Finder methods -- ActiveRecord::Relation
 T.assert_type!(Wizard.all.exists?(name: 'Harry Potter'), T::Boolean)
 T.assert_type!(Wizard.all.find(wizard.id), Wizard)
 T.assert_type!(Wizard.all.first!, Wizard)
 T.assert_type!(Wizard.all.first, T.nilable(Wizard))
+T.assert_type!(Wizard.all.second!, Wizard)
+T.assert_type!(Wizard.all.second, T.nilable(Wizard))
+T.assert_type!(Wizard.all.third!, Wizard)
+T.assert_type!(Wizard.all.third, T.nilable(Wizard))
+T.assert_type!(Wizard.all.third_to_last!, Wizard)
+T.assert_type!(Wizard.all.third_to_last, T.nilable(Wizard))
+T.assert_type!(Wizard.all.second_to_last!, Wizard)
+T.assert_type!(Wizard.all.second_to_last, T.nilable(Wizard))
 T.assert_type!(Wizard.all.last!, Wizard)
 T.assert_type!(Wizard.all.last, T.nilable(Wizard))
 T.assert_type!(Wizard.all.first_n(5), T::Array[Wizard])
@@ -75,6 +112,32 @@ T.assert_type!(Wizard.all.find_by(name: 'Harry Potter'), T.nilable(Wizard))
 T.assert_type!(Wizard.all.find_by!(name: 'Harry Potter'), Wizard)
 T.assert_type!(Wizard.all.find_by_id(wizard.id), T.nilable(Wizard))
 T.assert_type!(Wizard.all.find_by_id!(wizard.id), Wizard)
+T.assert_type!(Wizard.all.find_or_initialize_by(name: 'Harry Potter') { |w| T.assert_type!(w, Wizard) }, Wizard)
+T.assert_type!(Wizard.all.find_or_create_by(name: 'Harry Potter') { |w| T.assert_type!(w, Wizard) }, Wizard)
+T.assert_type!(Wizard.all.find_or_create_by!(name: 'Harry Potter') { |w| T.assert_type!(w, Wizard) }, Wizard)
+T.assert_type!(Wizard.all.new { |w| T.assert_type!(w, Wizard) }, Wizard)
+T.assert_type!(Wizard.all.build { |w| T.assert_type!(w, Wizard) }, Wizard)
+T.assert_type!(Wizard.all.create(name: 'Harry Potter') { |w| T.assert_type!(w, Wizard) }, Wizard)
+T.assert_type!(Wizard.all.create!(name: 'Harry Potter') { |w| T.assert_type!(w, Wizard) }, Wizard)
+T.assert_type!(Wizard.all.first_or_create(name: 'Harry Potter') { |w| T.assert_type!(w, Wizard) }, Wizard)
+T.assert_type!(Wizard.all.first_or_create!(name: 'Harry Potter') { |w| T.assert_type!(w, Wizard) }, Wizard)
+T.assert_type!(Wizard.all.first_or_initialize { |w| T.assert_type!(w, Wizard) }, Wizard)
+Wizard.all.find_each { |w| T.assert_type!(w, Wizard) }
+T.assert_type!(Wizard.all.find_each, T::Enumerator[Wizard])
+Wizard.all.find_in_batches { |w| T.assert_type!(w, T::Array[Wizard]) }
+T.assert_type!(Wizard.all.find_in_batches, T::Enumerator[T::Array[Wizard]])
+# T.assert_type!(Wizard.all.destroy_all, T::Array[Wizard]) # Ignored until we add support
+T.assert_type!(Wizard.all.any?, T::Boolean)
+T.assert_type!(Wizard.all.many?, T::Boolean)
+T.assert_type!(Wizard.all.none?, T::Boolean)
+T.assert_type!(Wizard.all.one?, T::Boolean)
+# T.assert_type!(Wizard.all.update_all(name: 'Harry Potter'), Integer) # Ignored until we add support
+# T.assert_type!(Wizard.all.delete_all, Integer) # Ignored until we add support
+# Enumerable methods
+Wizard.all.each { |w| T.assert_type!(w, Wizard) }
+Wizard.all.map { |w| T.assert_type!(w, Wizard) }
+T.assert_type!(Wizard.all.to_a, T::Array[Wizard])
+T.assert_type!(Wizard.all.empty?, T::Boolean)
 
 # Finder methods -- CollectionProxy
 spell_book = wizard.spell_books.first!
@@ -82,15 +145,44 @@ spell_books = wizard.spell_books
 T.assert_type!(spell_books.exists?(name: 'Fantastic Beasts'), T::Boolean)
 T.assert_type!(spell_books.find(spell_book.id), SpellBook)
 T.assert_type!(spell_books.first!, SpellBook)
-# T.assert_type!(spell_books.first, T.nilable(SpellBook)) # TODO fix sig for 5.0
+T.assert_type!(spell_books.first, T.nilable(SpellBook))
+T.assert_type!(spell_books.second!, SpellBook)
+T.assert_type!(spell_books.second, T.nilable(SpellBook))
+T.assert_type!(spell_books.third!, SpellBook)
+T.assert_type!(spell_books.third, T.nilable(SpellBook))
+T.assert_type!(spell_books.third_to_last!, SpellBook)
+T.assert_type!(spell_books.third_to_last, T.nilable(SpellBook))
+T.assert_type!(spell_books.second_to_last!, SpellBook)
+T.assert_type!(spell_books.second_to_last, T.nilable(SpellBook))
 T.assert_type!(spell_books.last!, SpellBook)
-# T.assert_type!(spell_books.last, T.nilable(SpellBook)) # TODO fix sig for 5.0
+T.assert_type!(spell_books.last, T.nilable(SpellBook))
 T.assert_type!(spell_books.first_n(5), T::Array[SpellBook])
 T.assert_type!(spell_books.last_n(5), T::Array[SpellBook])
 T.assert_type!(spell_books.find_by(name: 'Fantastic Beasts'), T.nilable(SpellBook))
 T.assert_type!(spell_books.find_by!(name: 'Fantastic Beasts'), SpellBook)
 T.assert_type!(spell_books.find_by_id(spell_book.id), T.nilable(SpellBook))
 T.assert_type!(spell_books.find_by_id!(spell_book.id), SpellBook)
+T.assert_type!(spell_books.find_or_initialize_by(name: 'Fantastic Beasts') { |s| T.assert_type!(s, SpellBook) }, SpellBook)
+T.assert_type!(spell_books.find_or_create_by(name: 'Fantastic Beasts') { |s| T.assert_type!(s, SpellBook) }, SpellBook)
+T.assert_type!(spell_books.find_or_create_by!(name: 'Fantastic Beasts') { |s| T.assert_type!(s, SpellBook) }, SpellBook)
+T.assert_type!(spell_books.new { |s| T.assert_type!(s, SpellBook) }, SpellBook)
+T.assert_type!(spell_books.build { |s| T.assert_type!(s, SpellBook) }, SpellBook)
+T.assert_type!(spell_books.create(name: 'Fantastic Beasts') { |s| T.assert_type!(s, SpellBook) }, SpellBook)
+T.assert_type!(spell_books.create!(name: 'Fantastic Beasts') { |s| T.assert_type!(s, SpellBook) }, SpellBook)
+T.assert_type!(spell_books.first_or_create(name: 'Fantastic Beasts') { |s| T.assert_type!(s, SpellBook) }, SpellBook)
+T.assert_type!(spell_books.first_or_create!(name: 'Fantastic Beasts') { |s| T.assert_type!(s, SpellBook) }, SpellBook)
+T.assert_type!(spell_books.first_or_initialize { |s| T.assert_type!(s, SpellBook) }, SpellBook)
+# spell_books.find_each { |s| T.assert_type!(s, SpellBook) } # TODO: Handle for Rails 6
+# T.assert_type!(spell_books.find_each, T::Enumerator[SpellBook]) # TODO: Handle for Rails 6
+# spell_books.find_in_batches { |s| T.assert_type!(s, T::Array[SpellBook]) } # TODO: Handle for Rails 6
+# T.assert_type!(spell_books.find_in_batches, T::Enumerator[T::Array[SpellBook]]) # TODO: Handle for Rails 6
+# T.assert_type!(spell_books.destroy_all, T::Array[SpellBook]) # Ignored until we add support
+T.assert_type!(spell_books.any?, T::Boolean)
+T.assert_type!(spell_books.many?, T::Boolean)
+T.assert_type!(spell_books.none?, T::Boolean)
+T.assert_type!(spell_books.one?, T::Boolean)
+# T.assert_type!(spell_books.update_all(name: 'Fantastic Beasts'), Integer) # Ignored until we add support
+# T.assert_type!(spell_books.delete_all, Integer) # Ignored until we add support
 # CollectionProxy query also typed correctly!
 T.assert_type!(spell_books.where(id: 1), SpellBook::ActiveRecord_AssociationRelation)
 T.assert_type!(spell_books.preload(:wizard), SpellBook::ActiveRecord_AssociationRelation)
@@ -98,63 +190,75 @@ T.assert_type!(spell_books.eager_load(:wizard), SpellBook::ActiveRecord_Associat
 T.assert_type!(spell_books.order(:id), SpellBook::ActiveRecord_AssociationRelation)
 T.assert_type!(spell_books.where.not(id: 1), SpellBook::ActiveRecord_AssociationRelation)
 T.assert_type!(spell_books.biology, SpellBook::ActiveRecord_AssociationRelation)
+# Enumerable methods
+spell_books.each { |s| T.assert_type!(s, SpellBook) }
+spell_books.map { |s| T.assert_type!(s, SpellBook) }
+T.assert_type!(spell_books.to_a, T::Array[SpellBook])
+T.assert_type!(spell_books.empty?, T::Boolean)
+# Push methods
+T.assert_type!(spell_books << spell_book, SpellBook::ActiveRecord_Associations_CollectionProxy)
+T.assert_type!(spell_books << [spell_book], SpellBook::ActiveRecord_Associations_CollectionProxy)
+T.assert_type!(spell_books.append(spell_book), SpellBook::ActiveRecord_Associations_CollectionProxy)
+T.assert_type!(spell_books.append([spell_book]), SpellBook::ActiveRecord_Associations_CollectionProxy)
+T.assert_type!(spell_books.push(spell_book), SpellBook::ActiveRecord_Associations_CollectionProxy)
+T.assert_type!(spell_books.push([spell_book]), SpellBook::ActiveRecord_Associations_CollectionProxy)
+# T.assert_type!(spell_books.concat(spell_book), SpellBook::ActiveRecord_Associations_CollectionProxy) # TODO: In Rails 5.0 and 5.1 this actually returns T::Array
+# T.assert_type!(spell_books.concat([spell_book]), SpellBook::ActiveRecord_Associations_CollectionProxy) # TODO: In Rails 5.0 and 5.1 this actually returns T::Array
 
 # finder methods -- AssociationRelation
-spell_books_query = spell_books.where(id: 1)
+spell_books_query = spell_books.where(wizard_id: wizard.id)
 T.assert_type!(spell_books_query.exists?(name: 'Fantastic Beasts'), T::Boolean)
 T.assert_type!(spell_books_query.find(spell_book.id), SpellBook)
 T.assert_type!(spell_books_query.first!, SpellBook)
-# T.assert_type!(spell_books_query.first, T.nilable(SpellBook)) # TODO fix sig for 5.0
+T.assert_type!(spell_books_query.first, T.nilable(SpellBook))
+T.assert_type!(spell_books_query.second!, SpellBook)
+T.assert_type!(spell_books_query.second, T.nilable(SpellBook))
+T.assert_type!(spell_books_query.third!, SpellBook)
+T.assert_type!(spell_books_query.third, T.nilable(SpellBook))
+T.assert_type!(spell_books_query.third_to_last!, SpellBook)
+T.assert_type!(spell_books_query.third_to_last, T.nilable(SpellBook))
+T.assert_type!(spell_books_query.second_to_last!, SpellBook)
+T.assert_type!(spell_books_query.second_to_last, T.nilable(SpellBook))
 T.assert_type!(spell_books_query.last!, SpellBook)
-# T.assert_type!(spell_books_query.last, T.nilable(SpellBook)) # TODO fix sig for 5.0
+T.assert_type!(spell_books_query.last, T.nilable(SpellBook))
 T.assert_type!(spell_books_query.first_n(5), T::Array[SpellBook])
 T.assert_type!(spell_books_query.last_n(5), T::Array[SpellBook])
 T.assert_type!(spell_books_query.find_by(name: 'Fantastic Beasts'), T.nilable(SpellBook))
 T.assert_type!(spell_books_query.find_by!(name: 'Fantastic Beasts'), SpellBook)
 T.assert_type!(spell_books_query.find_by_id(spell_book.id), T.nilable(SpellBook))
 T.assert_type!(spell_books_query.find_by_id!(spell_book.id), SpellBook)
+T.assert_type!(spell_books_query.find_or_initialize_by(name: 'Fantastic Beasts') { |s| T.assert_type!(s, SpellBook) }, SpellBook)
+T.assert_type!(spell_books_query.find_or_create_by(name: 'Fantastic Beasts') { |s| T.assert_type!(s, SpellBook) }, SpellBook)
+T.assert_type!(spell_books_query.find_or_create_by!(name: 'Fantastic Beasts') { |s| T.assert_type!(s, SpellBook) }, SpellBook)
+T.assert_type!(spell_books_query.new { |s| T.assert_type!(s, SpellBook) }, SpellBook) # Ignored until we add support
+T.assert_type!(spell_books_query.build { |s| T.assert_type!(s, SpellBook) }, SpellBook) # Ignored until we add support # Ignored until we add support
+T.assert_type!(spell_books_query.create(name: 'Fantastic Beasts') { |s| T.assert_type!(s, SpellBook) }, SpellBook) # Ignored until we add support
+T.assert_type!(spell_books_query.create!(name: 'Fantastic Beasts') { |s| T.assert_type!(s, SpellBook) }, SpellBook) # Ignored until we add support
+T.assert_type!(spell_books_query.first_or_create(name: 'Fantastic Beasts') { |s| T.assert_type!(s, SpellBook) }, SpellBook) # Ignored until we add support
+T.assert_type!(spell_books_query.first_or_create!(name: 'Fantastic Beasts') { |s| T.assert_type!(s, SpellBook) }, SpellBook) # Ignored until we add support
+T.assert_type!(spell_books_query.first_or_initialize { |s| T.assert_type!(s, SpellBook) }, SpellBook) # Ignored until we add support
+# spell_books_query.find_each { |s| T.assert_type!(s, SpellBook) } # TODO: Handle for Rails 6
+# T.assert_type!(spell_books_query.find_each, T::Enumerator[SpellBook]) # TODO: Handle for Rails 6
+# spell_books_query.find_in_batches { |s| T.assert_type!(s, T::Array[SpellBook]) } # TODO: Handle for Rails 6
+# T.assert_type!(spell_books_query.find_in_batches, T::Enumerator[T::Array[SpellBook]]) # TODO: Handle for Rails 6
+# T.assert_type!(spell_books_query.destroy_all, T::Array[SpellBook]) # Ignored until we add support
+T.assert_type!(spell_books_query.any?, T::Boolean)
+T.assert_type!(spell_books_query.many?, T::Boolean)
+T.assert_type!(spell_books_query.none?, T::Boolean)
+T.assert_type!(spell_books_query.one?, T::Boolean)
+# T.assert_type!(spell_books_query.update_all(name: 'Fantastic Beasts'), Integer) # Ignored until we add support
+# T.assert_type!(spell_books_query.delete_all, Integer) # Ignored until we add support
 # Query chaining
 T.assert_type!(spell_books_query.preload(:wizard), SpellBook::ActiveRecord_AssociationRelation)
 T.assert_type!(spell_books_query.eager_load(:wizard), SpellBook::ActiveRecord_AssociationRelation)
 T.assert_type!(spell_books_query.order(:id), SpellBook::ActiveRecord_AssociationRelation)
 T.assert_type!(spell_books_query.where.not(id: 1), SpellBook::ActiveRecord_AssociationRelation)
 T.assert_type!(spell_books_query.biology, SpellBook::ActiveRecord_AssociationRelation)
-
-# Enumerable on activerecord relation
-T.assert_type!(Wizard.all.to_a, T::Array[Wizard])
-Wizard.all.each do |w|
-  T.assert_type!(w, Wizard)
-end
-Wizard.all.map do |w|
-  T.assert_type!(w, Wizard)
-end
-Wizard.all.to_a.map do |w|
-  T.assert_type!(w, Wizard)
-end
-
-# enum on association collection proxy
-T.assert_type!(wizard.spell_books.to_a, T::Array[SpellBook])
-wizard.spell_books.each do |sp|
-  T.assert_type!(sp, SpellBook)
-end
-wizard.spell_books.map do |sp|
-  T.assert_type!(sp, SpellBook)
-end
-wizard.spell_books.to_a.map do |sp|
-  T.assert_type!(sp, SpellBook)
-end
-
-# enum on association relation
-T.assert_type!(wizard.spell_books.where(id: 1).to_a, T::Array[SpellBook])
-wizard.spell_books.where(id: 1).each do |sp|
-  T.assert_type!(sp, SpellBook)
-end
-wizard.spell_books.where(id: 1).map do |sp|
-  T.assert_type!(sp, SpellBook)
-end
-wizard.spell_books.where(id: 1).to_a.map do |sp|
-  T.assert_type!(sp, SpellBook)
-end
+# Enumerable methods
+spell_books_query.each { |s| T.assert_type!(s, SpellBook) }
+spell_books_query.map { |s| T.assert_type!(s, SpellBook) }
+T.assert_type!(spell_books_query.to_a, T::Array[SpellBook])
+T.assert_type!(spell_books_query.empty?, T::Boolean)
 
 # Model columns
 T.assert_type!(wizard.id, Integer)

data/spec/model_rbi_formatter_spec.rb

@@ -15,7 +15,7 @@ RSpec.describe SorbetRails::ModelRbiFormatter do
   end
 
   it 'generates correct rbi file for Wizard' do
-    class_set = Set.new(['Wizard', 'Wand', 'SpellBook', 'School'])
+    class_set = Set.new(['Wizard', 'Wand', 'SpellBook', 'School', 'Subject'])
     if Object.const_defined?('ActiveStorage::Attachment')
       class_set << 'ActiveStorage::Attachment'
     end

data/spec/rails_helper.rb

@@ -67,8 +67,21 @@ def expect_match_file(content, file_path)
   expect(content).to eql(expected_value)
 end
 
+# File uses File::SEPARATOR by default but will also use File::ALT_SEPARATOR if it's not nil
+FILE_SEPARATOR_RE = Regexp.union(*[File::SEPARATOR, File::ALT_SEPARATOR].compact).freeze
+
 def expect_files(base_dir:, files:)
-  rbi_files = Dir[File.join(base_dir, "*.rbi")]
+  dirs = Set.new([base_dir])
+  # if any files contain file separators then include those paths in our globbing as well
+  files.each do |f|
+    next unless f.match?(FILE_SEPARATOR_RE)
+    dirs << File.join(base_dir, File.dirname(f))
+  end
+
+  # glob all of our dirs
+  rbi_files = dirs.reduce([]) do |memo, dir|
+    memo += Dir[File.join(dir, "*.rbi")]
+  end
 
   # smoke test
   # expect(rbi_files.size).to eql(files.size)

data/spec/rake_rails_rbi_active_record_spec.rb

@@ -0,0 +1,21 @@
+require 'rails_helper'
+
+RSpec.describe 'rake rails_rbi:active_record', type: :task do
+  let!(:generated_dir_path) { Rails.root.join("sorbet", "rails-rbi") }
+
+  it "preloads the Rails environment" do
+    expect(task.prerequisites).to include("environment")
+  end
+
+  it "generates rbi correctly" do
+    task.invoke
+
+    expect_files(
+      base_dir: generated_dir_path,
+      files: [
+        "active_record_base.rbi",
+        "active_record_relation.rbi",
+      ],
+    )
+  end
+end

data/spec/rake_rails_rbi_models_spec.rb

@@ -12,13 +12,20 @@ RSpec.describe 'rake rails_rbi:models', type: :task do
     expect_files(
       base_dir: generated_dir_path,
       files: [
+        'headmaster.rbi',
         'potion.rbi',
         'robe.rbi',
         'school.rbi',
+        'spell.rbi',
+        'spell/habtm_spell_books.rbi',
         'spell_book.rbi',
+        'spell_book/habtm_spells.rbi',
         'squib.rbi',
+        'subject.rbi',
+        'subject/habtm_wizards.rbi',
         'wand.rbi',
         'wizard.rbi',
+        'wizard/habtm_subjects.rbi',
       ]
     )
     if Object.const_defined?('ActiveStorage')

data/spec/sorbet_spec.rb

@@ -10,6 +10,9 @@ RSpec.describe 'sorbet' do
       quidditch_position: :seeker,
     )
   end
+  # Needed for `second!` and `third!`
+  let!(:other_wizards) { 2.times { |i| Wizard.create!(name: "Wizard #{i}") } }
+
   let!(:book) do
     SpellBook.create!(
       name: 'Fantastic Beasts',
@@ -17,6 +20,9 @@ RSpec.describe 'sorbet' do
       book_type: :biology,
     )
   end
+  # Needed for `second!` and `third!`
+  let!(:other_books) { 2.times { |i| SpellBook.create!(name: "SpellBook #{i}", wizard: harry) } }
+
   let!(:wand) do
     Wand.create!(
       wizard: harry,
@@ -49,6 +55,11 @@ RSpec.describe 'sorbet' do
       puts "================================="
     end
 
+    # Ensure sorbet_test_cases.rb is set to `typed: true` since srb init may
+    # set it to false.
+    sorbet_test_cases_path = Rails.root.join('sorbet_test_cases.rb')
+    File.write(sorbet_test_cases_path, File.read(sorbet_test_cases_path).gsub(/^# typed: \w+$/, "# typed: true"))
+
     # run sorbet-rails rake tasks
     Rake::Task['rails_rbi:all'].invoke
 
@@ -68,7 +79,7 @@ RSpec.describe 'sorbet' do
 
   it 'returns expected sorbet tc result' do
     stdout, stderr, status = Open3.capture3(
-      'bundle', 'exec', 'srb', 'tc', '--typed-override=typed-override.yaml',
+      'bundle', 'exec', 'srb', 'tc',
       chdir: Rails.root.to_path,
     )
     expected_file_path = 'expected_srb_tc_output.txt'

data/spec/support/v5.0/Gemfile.lock

@@ -1,11 +1,11 @@
 PATH
   remote: ../../..
   specs:
-    sorbet-rails (0.6.2)
+    sorbet-rails (0.6.3)
       method_source (>= 0.9.2)
       parlour (~> 2.0)
       parser (>= 2.7)
-      sorbet-coerce (>= 0.2.4)
+      sorbet-coerce (>= 0.2.6)
       sorbet-runtime (>= 0.5)
 
 GEM
@@ -81,7 +81,7 @@ GEM
       parser
       rainbow (~> 3.0)
       sorbet-runtime (>= 0.5)
-    parser (2.7.0.5)
+    parser (2.7.1.1)
       ast (~> 2.4.0)
     polyfill (1.8.0)
     puma (3.12.4)
@@ -114,15 +114,15 @@ GEM
     rainbow (3.0.0)
     rake (13.0.1)
     safe_type (1.1.1)
-    sorbet (0.5.5472)
-      sorbet-static (= 0.5.5472)
-    sorbet-coerce (0.2.4)
+    sorbet (0.5.5480)
+      sorbet-static (= 0.5.5480)
+    sorbet-coerce (0.2.6)
       polyfill (~> 1.8)
       safe_type (~> 1.1, >= 1.1.1)
       sorbet (>= 0.4.4704)
       sorbet-runtime (>= 0.4.4704)
-    sorbet-runtime (0.5.5472)
-    sorbet-static (0.5.5472-universal-darwin-14)
+    sorbet-runtime (0.5.5480)
+    sorbet-static (0.5.5480-universal-darwin-14)
     sprockets (4.0.0)
       concurrent-ruby (~> 1.0)
       rack (> 1, < 3)

data/spec/support/v5.0/app/models/headmaster.rb

@@ -0,0 +1,8 @@
+# typed: strong
+class Headmaster < ApplicationRecord
+  belongs_to :school, required: false
+  belongs_to :wizard, optional: true
+
+  validates :school, presence: true
+  validates :wizard_id, presence: true
+end

data/spec/support/v5.0/app/models/school.rb

@@ -1,3 +1,5 @@
 # typed: strong
 class School < ApplicationRecord
+  has_one :headmaster
+  validates :headmaster, presence: true
 end

data/spec/support/v5.0/app/models/spell.rb

@@ -0,0 +1,5 @@
+# typed: strong
+class Spell < ApplicationRecord
+  # habtm enforced at the DB level
+  has_and_belongs_to_many :spell_books
+end

data/spec/support/v5.0/app/models/spell_book.rb

@@ -5,6 +5,9 @@ class SpellBook < ApplicationRecord
   # simulate when belongs_to is optional by default, but it is enforced at the DB level
   belongs_to :wizard, optional: true
 
+  # habtm enforced at the DB level
+  has_and_belongs_to_many :spells
+
   enum book_type: {
     unclassified: 0,
     biology: 1,