sorbet-rails 0.6.2 → 0.7.0

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

@@ -1,11 +1,11 @@
 PATH
   remote: ../../..
   specs:
-    sorbet-rails (0.6.2)
+    sorbet-rails (0.7.0)
       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
@@ -82,7 +82,7 @@ GEM
       parser
       rainbow (~> 3.0)
       sorbet-runtime (>= 0.5)
-    parser (2.7.0.5)
+    parser (2.7.1.2)
       ast (~> 2.4.0)
     polyfill (1.8.0)
     puma (3.12.4)
@@ -115,15 +115,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.7)
       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.1/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.1/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.1/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.1/app/models/spell_book.rb

@@ -5,9 +5,14 @@ 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,
     dark_art: 999,
   }
+
+  scope :recent, -> { where('created_at > ?', 1.month.ago) }
 end

data/spec/support/v5.1/app/models/subject.rb

@@ -0,0 +1,5 @@
+# typed: strong
+class Subject < ApplicationRecord
+  # habtm which is optional at the db level
+  has_and_belongs_to_many :wizards
+end

data/spec/support/v5.1/app/models/wizard.rb

@@ -1,6 +1,8 @@
 # typed: strict
 class Wizard < ApplicationRecord
   validates :name, length: { minimum: 5 }, presence: true
+  # simulate conditional validation
+  validates :parent_email, presence: true, if: :Slytherin?
 
   typed_enum house: {
     Gryffindor: 0,
@@ -18,6 +20,7 @@ class Wizard < ApplicationRecord
     "Pomona Sprout": 2,
     "Filius Flitwick": 3,
     "Hagrid": 4,
+    "Alastor 'Mad-Eye' Moody": 5,
   }
 
   typed_enum broom: {
@@ -46,10 +49,12 @@ class Wizard < ApplicationRecord
 
   has_one :wand
   has_many :spell_books
+  # habtm which is optional at the db level
+  has_and_belongs_to_many :subjects
 
   # simulate when belongs_to is optional by default
   belongs_to :school, optional: true
 
   scope :recent, -> { where('created_at > ?', 1.month.ago) }
-  
+
 end

data/spec/support/v5.1/db/migrate/20190620000010_add_subject.rb

@@ -0,0 +1,8 @@
+# typed: false
+class AddSubject < ActiveRecord::Migration[5.1]
+  def change
+    create_table :subjects do |t|
+      t.string :name
+    end
+  end
+end

data/spec/support/v5.1/db/migrate/20190620000011_add_subjects_wizards.rb

@@ -0,0 +1,8 @@
+# typed: false
+class AddSubjectsWizards < ActiveRecord::Migration[5.1]
+  def change
+    create_join_table :subjects, :wizards, column_options: { null: true } do |t|
+      t.index [:subject_id, :wizard_id]
+    end
+  end
+end

data/spec/support/v5.1/db/migrate/20190620000012_add_spell.rb

@@ -0,0 +1,8 @@
+# typed: false
+class AddSpell < ActiveRecord::Migration[5.1]
+  def change
+    create_table :spells do |t|
+      t.string :name
+    end
+  end
+end

data/spec/support/v5.1/db/migrate/20190620000013_add_spells_spell_books.rb

@@ -0,0 +1,8 @@
+# typed: false
+class AddSpellsSpellBooks < ActiveRecord::Migration[5.1]
+  def change
+    create_join_table :spells, :spell_books do |t|
+      t.index [:spell_id, :spell_book_id]
+    end
+  end
+end

data/spec/support/v5.1/db/migrate/20190620000014_create_headmasters.rb

@@ -0,0 +1,9 @@
+# typed: false
+class CreateHeadmasters < ActiveRecord::Migration[5.1]
+  def change
+    create_table :headmasters do |t|
+      t.references :school
+      t.references :wizard
+    end
+  end
+end

data/spec/support/v5.1/db/schema.rb

@@ -11,7 +11,14 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema.define(version: 20190620000009) do
+ActiveRecord::Schema.define(version: 20190620000014) do
+
+  create_table "headmasters", force: :cascade do |t|
+    t.integer "school_id"
+    t.integer "wizard_id"
+    t.index ["school_id"], name: "index_headmasters_on_school_id"
+    t.index ["wizard_id"], name: "index_headmasters_on_wizard_id"
+  end
 
   create_table "robes", force: :cascade do |t|
     t.integer "wizard_id"
@@ -29,6 +36,26 @@ ActiveRecord::Schema.define(version: 20190620000009) do
     t.index ["wizard_id"], name: "index_spell_books_on_wizard_id"
   end
 
+  create_table "spell_books_spells", id: false, force: :cascade do |t|
+    t.integer "spell_id", null: false
+    t.integer "spell_book_id", null: false
+    t.index ["spell_id", "spell_book_id"], name: "index_spell_books_spells_on_spell_id_and_spell_book_id"
+  end
+
+  create_table "spells", force: :cascade do |t|
+    t.string "name"
+  end
+
+  create_table "subjects", force: :cascade do |t|
+    t.string "name"
+  end
+
+  create_table "subjects_wizards", id: false, force: :cascade do |t|
+    t.integer "subject_id"
+    t.integer "wizard_id"
+    t.index ["subject_id", "wizard_id"], name: "index_subjects_wizards_on_subject_id_and_wizard_id"
+  end
+
   create_table "wands", force: :cascade do |t|
     t.integer "wizard_id", null: false
     t.string "wood_type"

data/spec/support/v5.1/lib/mythical_rbi_plugin.rb

@@ -10,7 +10,7 @@ class MythicalRbiPlugin < SorbetRails::ModelPlugins::Base
     model_class_rbi.create_method(
       'mythicals',
       class_method: true,
-      return_type: "T::Array[#{@model_class.name}]",
+      return_type: "T::Array[#{model_class_name}]",
     )
   end
 end

data/spec/support/v5.1/sorbet_test_cases.rb

@@ -1,4 +1,4 @@
-# typed: false
+# typed: true
 require 'sorbet-runtime'
 
 wand = Wand.first!
@@ -27,32 +27,21 @@ 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)
-
-# -- model relation
-# default
-T.assert_type!(Wizard.all, Wizard::ActiveRecord_Relation)
-
-# custom scope
-T.assert_type!(Wizard.recent, Wizard::ActiveRecord_Relation)
-
-# enum scope
-T.assert_type!(Wizard.Gryffindor, Wizard::ActiveRecord_Relation)
-
-# ActiveRecord Querying
-T.assert_type!(Wizard.Gryffindor.recent, Wizard::ActiveRecord_Relation)
-T.assert_type!(Wizard.Gryffindor.recent.unscoped, Wizard::ActiveRecord_Relation)
-T.assert_type!(Wizard.where(id: 1), Wizard::ActiveRecord_Relation)
-T.assert_type!(Wizard.where(id: 1).recent, Wizard::ActiveRecord_Relation)
-T.assert_type!(Wizard.where.not(id: 1), Wizard::ActiveRecord_Relation)
-T.assert_type!(Wizard.preload(:spell_books), Wizard::ActiveRecord_Relation)
-T.assert_type!(Wizard.eager_load(:spell_books), Wizard::ActiveRecord_Relation)
-T.assert_type!(Wizard.order(:id), Wizard::ActiveRecord_Relation)
+T.assert_type!(wizard.spell_book_ids, T::Array[Integer])
 
 # Finder methods -- Model
 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 +50,54 @@ 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]])
+Wizard.in_batches { |w| T.assert_type!(w, Wizard::ActiveRecord_Relation) }
+T.assert_type!(Wizard.in_batches, ActiveRecord::Batches::BatchEnumerator)
+# 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
+# Query methods
+T.assert_type!(Wizard.all, Wizard::ActiveRecord_Relation)
+T.assert_type!(Wizard.recent, Wizard::ActiveRecord_Relation) # Named scope
+T.assert_type!(Wizard.Gryffindor, Wizard::ActiveRecord_Relation) # Enum scope
+T.assert_type!(Wizard.Gryffindor.recent, Wizard::ActiveRecord_Relation)
+T.assert_type!(Wizard.Gryffindor.recent.unscoped, Wizard::ActiveRecord_Relation)
+T.assert_type!(Wizard.where(id: 1), Wizard::ActiveRecord_Relation)
+T.assert_type!(Wizard.where(id: 1).recent, Wizard::ActiveRecord_Relation)
+T.assert_type!(Wizard.where.not(id: 1), Wizard::ActiveRecord_Relation)
+T.assert_type!(Wizard.preload(:spell_books), Wizard::ActiveRecord_Relation)
+T.assert_type!(Wizard.eager_load(:spell_books), Wizard::ActiveRecord_Relation)
+T.assert_type!(Wizard.order(:id), Wizard::ActiveRecord_Relation)
 
 # 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 +106,46 @@ 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]])
+Wizard.all.in_batches { |w| T.assert_type!(w, Wizard::ActiveRecord_Relation) }
+T.assert_type!(Wizard.all.in_batches, T::Enumerable[Wizard::ActiveRecord_Relation])
+# 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
+# Query methods
+T.assert_type!(Wizard.all.all, Wizard::ActiveRecord_Relation)
+T.assert_type!(Wizard.all.recent, Wizard::ActiveRecord_Relation) # Named scope
+T.assert_type!(Wizard.all.Gryffindor, Wizard::ActiveRecord_Relation) # Enum scope
+T.assert_type!(Wizard.all.Gryffindor.recent, Wizard::ActiveRecord_Relation)
+T.assert_type!(Wizard.all.Gryffindor.recent.unscoped, Wizard::ActiveRecord_Relation)
+T.assert_type!(Wizard.all.where(id: 1), Wizard::ActiveRecord_Relation)
+T.assert_type!(Wizard.all.where(id: 1).recent, Wizard::ActiveRecord_Relation)
+T.assert_type!(Wizard.all.where.not(id: 1), Wizard::ActiveRecord_Relation)
+T.assert_type!(Wizard.all.preload(:spell_books), Wizard::ActiveRecord_Relation)
+T.assert_type!(Wizard.all.eager_load(:spell_books), Wizard::ActiveRecord_Relation)
+T.assert_type!(Wizard.all.order(:id), Wizard::ActiveRecord_Relation)
+# 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,79 +153,135 @@ 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)
-# CollectionProxy query also typed correctly!
+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) }
+T.assert_type!(spell_books.find_each, T::Enumerator[SpellBook])
+spell_books.find_in_batches { |s| T.assert_type!(s, T::Array[SpellBook]) }
+T.assert_type!(spell_books.find_in_batches, T::Enumerator[T::Array[SpellBook]])
+spell_books.in_batches { |s| T.assert_type!(s, SpellBook::ActiveRecord_AssociationRelation) }
+T.assert_type!(spell_books.in_batches, T::Enumerable[SpellBook::ActiveRecord_AssociationRelation])
+# 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
+# Query methods
+T.assert_type!(spell_books.all, SpellBook::ActiveRecord_AssociationRelation)
+T.assert_type!(spell_books.recent, SpellBook::ActiveRecord_AssociationRelation) # Named scope
+T.assert_type!(spell_books.unclassified, SpellBook::ActiveRecord_AssociationRelation) # Enum scope
+T.assert_type!(spell_books.unclassified.recent, SpellBook::ActiveRecord_AssociationRelation)
+T.assert_type!(spell_books.unclassified.recent.unscoped, SpellBook::ActiveRecord_Relation) # Turns back into relation
 T.assert_type!(spell_books.where(id: 1), SpellBook::ActiveRecord_AssociationRelation)
+T.assert_type!(spell_books.where(id: 1).recent, SpellBook::ActiveRecord_AssociationRelation)
+T.assert_type!(spell_books.where.not(id: 1), SpellBook::ActiveRecord_AssociationRelation)
 T.assert_type!(spell_books.preload(:wizard), SpellBook::ActiveRecord_AssociationRelation)
 T.assert_type!(spell_books.eager_load(:wizard), SpellBook::ActiveRecord_AssociationRelation)
 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)
-# Query chaining
+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) }
+T.assert_type!(spell_books_query.find_each, T::Enumerator[SpellBook])
+spell_books_query.find_in_batches { |s| T.assert_type!(s, T::Array[SpellBook]) }
+T.assert_type!(spell_books_query.find_in_batches, T::Enumerator[T::Array[SpellBook]])
+spell_books_query.in_batches { |s| T.assert_type!(s, SpellBook::ActiveRecord_AssociationRelation) }
+T.assert_type!(spell_books_query.in_batches, T::Enumerable[SpellBook::ActiveRecord_AssociationRelation])
+# 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 methods
+T.assert_type!(spell_books_query.all, SpellBook::ActiveRecord_AssociationRelation)
+T.assert_type!(spell_books_query.recent, SpellBook::ActiveRecord_AssociationRelation) # Named scope
+T.assert_type!(spell_books_query.unclassified, SpellBook::ActiveRecord_AssociationRelation) # Enum scope
+T.assert_type!(spell_books_query.unclassified.recent, SpellBook::ActiveRecord_AssociationRelation)
+T.assert_type!(spell_books_query.unclassified.recent.unscoped, SpellBook::ActiveRecord_Relation) # Turns back into relation
+T.assert_type!(spell_books_query.where(id: 1), SpellBook::ActiveRecord_AssociationRelation)
+T.assert_type!(spell_books_query.where(id: 1).recent, SpellBook::ActiveRecord_AssociationRelation)
+T.assert_type!(spell_books_query.where.not(id: 1), SpellBook::ActiveRecord_AssociationRelation)
 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)
@@ -234,44 +361,6 @@ params = ActionController::Parameters.new({
 typed_params = TypedParams[MyActionParams].new.extract!(params)
 T.assert_type!(typed_params, MyActionParams)
 
-# -- require_typed
-T.assert_type!(
-  params.require_typed(:age, TA[Integer].new),
-  Integer,
-)
-T.assert_type!(
-  params.require_typed(:name, TA[String].new),
-  String,
-)
-info = params.require_typed(:info, TA[ActionController::Parameters].new)
-T.assert_type!(info, ActionController::Parameters)
-T.assert_type!(
-  info.require_typed(:friends, TA[T::Array[String]].new),
-  T::Array[String],
-)
-# -- fetch_typed
-T.assert_type!(
-  params.fetch_typed(:age, TA[Integer].new),
-  Integer,
-)
-T.assert_type!(
-  params.fetch_typed(:name, TA[String].new),
-  String,
-)
-T.assert_type!(
-  params.fetch_typed(:nonexistence, TA[String].new, ''),
-  String,
-)
-T.assert_type!(
-  params.fetch_typed(:nonexistence, TA[T.nilable(String)].new, nil),
-  T.nilable(String),
-)
-T.assert_type!(
-  params.fetch_typed(:nonexistence, TA[T::Array[Integer]].new, []),
-  T::Array[Integer],
-)
-
-
 # -- pluck to tstruct
 class WizardStruct < T::Struct
   const :name, String
@@ -288,23 +377,16 @@ Wizard.all.pluck_to_tstruct(TA[WizardStruct].new).each do |row|
   T.assert_type!(row, WizardStruct)
 end
 
-
 # -- GeneratedUrlHelpers
 class TestHelper
   include GeneratedUrlHelpers
-
-  # need to implement this for the url
-  def default_url_options
-    {
-      protocol: 'http',
-      host: 'localhost',
-      port: 3000,
-    }
-  end
-
-  def test_url_helper
-    T.assert_type!(test_index_path, String)
-    T.assert_type!(test_index_url, String)
-  end
 end
-TestHelper.new.test_url_helper
+
+T.assert_type!(TestHelper.new.test_index_path, String)
+# need to set this config for _url methods
+Rails.application.routes.default_url_options = {
+  protocol: 'http',
+  host: 'localhost',
+  port: 3000,
+}
+T.assert_type!(TestHelper.new.test_index_url, String)