sorbet-rails 0.6.2 → 0.7.0

data/lib/sorbet-rails/rails_mixins/generated_url_helpers.rb

@@ -11,6 +11,5 @@
 # + include GeneratedUrlHelpers
 # end
 #
-module GeneratedUrlHelpers
-  include Rails.application.routes.url_helpers
-end
+# Reference: https://github.com/rails/rails/blob/master/actionpack/lib/action_dispatch/routing/route_set.rb
+GeneratedUrlHelpers = Rails.application.routes.url_helpers

data/lib/sorbet-rails/railtie.rb

@@ -50,9 +50,7 @@ class SorbetRails::Railtie < Rails::Railtie
     end
 
     ActiveSupport.on_load(:action_controller) do
-      require "sorbet-rails/rails_mixins/custom_params_methods"
       require "sorbet-rails/rails_mixins/generated_url_helpers"
-      ActionController::Parameters.include SorbetRails::CustomParamsMethods
     end
 
     SorbetRails.register_configured_plugins

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

@@ -1,3 +1,4 @@
+require("sorbet-rails/active_record_rbi_formatter")
 require("sorbet-rails/model_rbi_formatter")
 require("sorbet-rails/routes_rbi_formatter")
 require("sorbet-rails/helper_rbi_formatter")
@@ -34,14 +35,28 @@ namespace :rails_rbi do
     File.write(file_path, inspector.format(SorbetRails::RoutesRbiFormatter.new))
   end
 
-  desc "Copy custom rbis for ActionController::Parameters, pluck_to_struct, etc."
+  desc "Copy custom rbis for typed_params, pluck_to_struct, etc."
   task custom: :environment do
     copy_bundled_rbi('type_assert.rbi')
-    copy_bundled_rbi('parameters.rbi')
     copy_bundled_rbi('pluck_to_tstruct.rbi')
-    copy_bundled_rbi('active_record_relation.rbi')
-    copy_bundled_rbi('active_record_base.rbi')
     copy_bundled_rbi('typed_params.rbi')
+    copy_bundled_rbi('typed_enum.rbi')
+
+    # These files were previously bundled_rbi but are now generated so this
+    # is needed for backwards compatibility with anyone using `rails_rbi:custom`
+    Rake::Task['rails_rbi:active_record'].invoke
+  end
+
+  desc "Generate rbis for rails mailers"
+  task :active_record, [:root_dir] => :environment do |t, args|
+    formatter = SorbetRails::ActiveRecordRbiFormatter.new
+    FileUtils.mkdir_p(Rails.root.join("sorbet", "rails-rbi"))
+
+    file_path = Rails.root.join("sorbet", "rails-rbi", "active_record_base.rbi")
+    File.write(file_path, formatter.generate_active_record_base_rbi)
+
+    file_path = Rails.root.join("sorbet", "rails-rbi", "active_record_relation.rbi")
+    File.write(file_path, formatter.generate_active_record_relation_rbi)
   end
 
   desc "Generate rbis for rails models. Pass models name to regenerate rbi for only the given models."
@@ -62,11 +77,19 @@ namespace :rails_rbi do
       models_to_generate = models_to_generate - blacklisted_models
     end
 
-    generated_rbis = generate_rbis_for_models(models_to_generate, all_models)
-    generated_rbis.each do |model_name, contents|
-      file_path = Rails.root.join("sorbet", "rails-rbi", "models", "#{model_name.underscore}.rbi")
-      FileUtils.mkdir_p(File.dirname(file_path))
-      File.write(file_path, contents)
+    available_class_names = Set.new(all_models.map { |c| c.name })
+    models_to_generate.each do |model_class|
+      model_class_name = model_class.to_s
+      begin
+        formatter = SorbetRails::ModelRbiFormatter.new(model_class, available_class_names)
+        file_path = Rails.root.join("sorbet", "rails-rbi", "models", "#{model_class_name.underscore}.rbi")
+        FileUtils.mkdir_p(File.dirname(file_path))
+        File.write(file_path, formatter.generate_rbi)
+      rescue StandardError, NotImplementedError => ex
+        puts "---"
+        puts "Error when handling model #{model_class_name}: #{ex}"
+        nil
+      end
     end
   end
 
@@ -130,21 +153,6 @@ namespace :rails_rbi do
     end
   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|
-      begin
-        formatter = SorbetRails::ModelRbiFormatter.new(model_class, available_class_names)
-        [model_class.name, formatter.generate_rbi]
-      rescue StandardError, NotImplementedError => ex
-        puts "---"
-        puts "Error when handling model #{model_class.name}: #{ex}"
-        nil
-      end
-    end
-    Hash[formatted.compact] # remove models with errors
-  end
-
   def blacklisted_models
     blacklisted_models = []
     blacklisted_models << ApplicationRecord if defined?(ApplicationRecord)

data/sorbet-rails.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name          = %q{sorbet-rails}
-  s.version       = "0.6.2"
+  s.version       = "0.7.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"]
@@ -17,7 +17,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'parlour', '~> 2.0'
   s.add_dependency 'sorbet-runtime', '>= 0.5'
-  s.add_dependency 'sorbet-coerce', '>= 0.2.4'
+  s.add_dependency 'sorbet-coerce', '>= 0.2.6'
   s.add_dependency 'method_source', '>= 0.9.2'
   s.add_dependency 'parser', '>= 2.7'
 

data/spec/active_record_rbi_formatter_spec.rb

@@ -0,0 +1,24 @@
+require 'rails_helper'
+require 'sorbet-rails/active_record_rbi_formatter'
+
+RSpec.describe SorbetRails::ActiveRecordRbiFormatter do
+  describe 'generate_active_record_base_rbi' do
+    it 'returns the expected rbi' do
+      formatter = SorbetRails::ActiveRecordRbiFormatter.new
+      expect_match_file(
+        formatter.generate_active_record_base_rbi,
+        'expected_active_record_base.rbi'
+      )
+    end
+  end
+
+  describe 'generate_active_record_relation_rbi' do
+    it 'returns the expected rbi' do
+      formatter = SorbetRails::ActiveRecordRbiFormatter.new
+      expect_match_file(
+        formatter.generate_active_record_relation_rbi,
+        'expected_active_record_relation.rbi'
+      )
+    end
+  end
+end

data/spec/generators/rails-template.rb

@@ -51,7 +51,7 @@ def create_lib
         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
@@ -83,11 +83,16 @@ def create_models
       # 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
   RUBY
 
@@ -129,6 +134,8 @@ def create_models
   file "app/models/wizard.rb", <<~RUBY
     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,
@@ -146,6 +153,7 @@ def create_models
         "Pomona Sprout": 2,
         "Filius Flitwick": 3,
         "Hagrid": 4,
+        "Alastor 'Mad-Eye' Moody": 5,
       }
 
       typed_enum broom: {
@@ -174,6 +182,8 @@ def create_models
 
       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
@@ -212,8 +222,35 @@ def create_models
 
   file "app/models/school.rb", <<~RUBY
     class School < ApplicationRecord
+      has_one :headmaster
+      validates :headmaster, presence: true
     end
   RUBY
+
+  file "app/models/subject.rb", <<~RUBY
+    class Subject < ApplicationRecord
+      # habtm which is optional at the db level
+      has_and_belongs_to_many :wizards
+    end
+  RUBY
+
+  file "app/models/spell.rb", <<~RUBY
+    class Spell < ApplicationRecord
+      # habtm enforced at the DB level
+      has_and_belongs_to_many :spell_books
+    end
+  RUBY
+
+  file "app/models/headmaster.rb", <<~RUBY
+    class Headmaster < ApplicationRecord
+      belongs_to :school, required: false
+      belongs_to :wizard, optional: true
+
+      validates :school, presence: true
+      validates :wizard_id, presence: true
+    end
+  RUBY
+
 end
 
 def create_migrations
@@ -328,6 +365,58 @@ def create_migrations
       end
     end
   RUBY
+
+  file "db/migrate/20190620000010_add_subject.rb", <<~RUBY
+    class AddSubject < #{migration_superclass}
+      def change
+        create_table :subjects do |t|
+          t.string :name
+        end
+      end
+    end
+  RUBY
+
+  file "db/migrate/20190620000011_add_subjects_wizards.rb", <<~RUBY
+    class AddSubjectsWizards < #{migration_superclass}
+      def change
+        create_join_table :subjects, :wizards, column_options: { null: true } do |t|
+          t.index [:subject_id, :wizard_id]
+        end
+      end
+    end
+  RUBY
+
+  file "db/migrate/20190620000012_add_spell.rb", <<~RUBY
+    class AddSpell < #{migration_superclass}
+      def change
+        create_table :spells do |t|
+          t.string :name
+        end
+      end
+    end
+  RUBY
+
+  file "db/migrate/20190620000013_add_spells_spell_books.rb", <<~RUBY
+    class AddSpellsSpellBooks < #{migration_superclass}
+      def change
+        create_join_table :spells, :spell_books do |t|
+          t.index [:spell_id, :spell_book_id]
+        end
+      end
+    end
+  RUBY
+
+  file "db/migrate/20190620000014_create_headmasters.rb", <<~RUBY
+    class CreateHeadmasters < #{migration_superclass}
+      def change
+        create_table :headmasters do |t|
+          t.references :school
+          t.references :wizard
+        end
+      end
+    end
+  RUBY
+
 end
 
 def create_mailers
@@ -391,11 +480,6 @@ def create_jobs
 end
 
 def add_sorbet_test_files
-  file "typed-override.yaml", <<~YAML
-    true:
-    - ./sorbet_test_cases.rb
-  YAML
-
   copy_file "./sorbet_test_cases.rb", "sorbet_test_cases.rb"
 end
 

data/spec/generators/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)