sorbet-rails 0.6.3 → 0.6.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ade7fadcb2cc5890f8cd5716247f14d7d9b0324029fb13de4f8b902e205a516
-  data.tar.gz: 766dfdd66acea268fe696345ae871bf4b88cd67e2b845dffeb9f218d9a38586d
+  metadata.gz: 662c7c86f998ffbbdef82e035c7d827ef8f3f4192c4829e4e6ecfaaa0c72a131
+  data.tar.gz: 3eb66d37c008b8d8c3ae5b33fe8b645652dac7d2c047195e9773af743c2859c0
 SHA512:
-  metadata.gz: 91ce6f173680ed297198333b0780c4f4257a7b95d56f33d6f464f67f122c37a6483b87f00392792219ce51724ad5379fea9b7cbf91fc100d439396f828f210be
-  data.tar.gz: ba26ebc1b34724a1eee5cc667add0b843c3ef77994606938e31b2f3fc0a0a88d8a0b7ad39f65194350045166c1eb130cd94951f54c763d82a7efd19dd65ed7a0
+  metadata.gz: fd2212ba2d83e22a540540b71fd9c82e4ec67211c5577166bc99772b957ecb9d38fa2326dbeda9d2f03f399bdde73c542f148834cfe600d4f7b193f210427b74
+  data.tar.gz: c639bb6d3b6785f0b945354d4e034ab48515473d91267d20518a69fe829550611764ce0071d383474e0a2cb1f05db04092276d5b238c2b10a85c3e9113d8839a

data/README.md

@@ -73,7 +73,7 @@ It is possible to add custom RBI generation logic for your custom module or gems
 We also add following methods to make type-checking more easily:
 - [`find_n`, `first_n`, `last_n`](https://github.com/chanzuckerberg/sorbet-rails#find-first-and-last)
 - [`pluck_to_tstruct`](#pluck_to_tstruct-instead-of-pluck)
-- [`typed_enum`](#enums)
+- [`typed_enum`](#typed_enum-instead-of-enum)
 - [`Model::RelationType`](#relationtype-alias)
 
 #### `pluck_to_tstruct` instead of `pluck`
@@ -96,7 +96,7 @@ Wizard.all.pluck_to_tstruct(TA[WizardStruct].new)  # T::Array[WizardStruct]
 
 This method is based on [pluck_to_hash](https://github.com/girishso/pluck_to_hash) gem.
 
-#### Enums
+#### `typed_enum` instead of `enum`
 
 If you use [Rails `enum`](https://guides.rubyonrails.org/active_record_querying.html#enums), `sorbet-rails` will generate a corresponding `T::Enum`. It will also include getters, setters, and scope methods in the rbi file it generates.
 
@@ -203,7 +203,7 @@ end
 If it fails to coerce the params into the right type, an `ActionController::BadRequest` exception will be raised with the coercion context for debugging.
 
 Note: The API `TypedParams[...].new.extract!` may seem verbose, but necessary to support this feature. Ideally, the API can be simply `TypedParams.extract!(...)`. However, `sorbet` [doesn't support](http://github.com/sorbet/sorbet/issues/62) defining a method that accept a type and return an instance of the type. If this feature is supported by `sorbet` in the future, it will be easy to codemod to be `TypedParams.extract(...)!` part from your code.
-Note: [`require_typed` and `fetch_typed`](https://github.com/chanzuckerberg/sorbet-rails/blob/v0.5.9.1/README.md) are deprecated in favor of `TypedParams`.
+Note: [`require_typed` and `fetch_typed`](https://github.com/chanzuckerberg/sorbet-rails/blob/v0.5.9.1/README.md) are deprecated in favor of `TypedParams`. They will be removed in v0.7.
 
 ### Routes
 

data/lib/sorbet-rails/gem_plugins/active_flag_plugin.rb

@@ -7,7 +7,6 @@ class ActiveFlagPlugin < SorbetRails::ModelPlugins::Base
 
     module_name = self.model_module_name("GeneratedActiveFlagMethods")
     module_rbi = root.create_module(module_name)
-    module_rbi.create_extend("T::Sig")
 
     model_class_rbi = root.create_class(self.model_class_name)
     model_class_rbi.create_include(module_name)

data/lib/sorbet-rails/gem_plugins/paperclip_plugin.rb

@@ -8,7 +8,6 @@ class PaperclipPlugin < SorbetRails::ModelPlugins::Base
 
     module_name = self.model_module_name("GeneratedPaperclipMethods")
     module_rbi = root.create_module(module_name)
-    module_rbi.create_extend("T::Sig")
 
     model_class_rbi = root.create_class(self.model_class_name)
     model_class_rbi.create_include(module_name)

data/lib/sorbet-rails/model_plugins/active_record_assoc.rb

@@ -13,7 +13,6 @@ class SorbetRails::ModelPlugins::ActiveRecordAssoc < SorbetRails::ModelPlugins::
 
     assoc_module_name = self.model_module_name("GeneratedAssociationMethods")
     assoc_module_rbi = root.create_module(assoc_module_name)
-    assoc_module_rbi.create_extend("T::Sig")
 
     model_class_rbi = root.create_class(self.model_class_name)
     model_class_rbi.create_include(assoc_module_name)
@@ -131,7 +130,15 @@ class SorbetRails::ModelPlugins::ActiveRecordAssoc < SorbetRails::ModelPlugins::
 
   sig { params(reflection: T.untyped).returns(T.nilable(T::Boolean)) }
   def assoc_should_be_untyped?(reflection)
-    polymorphic_assoc?(reflection) || !@available_classes.include?(reflection.klass.name)
+    # For some polymorphic associations (e.g. a has-many-through where the `source`
+    # is polymorphic) we can figure out the type from the class_name or source_type.
+    polymorpic_with_unknowable_klass = (
+      polymorphic_assoc?(reflection) &&
+      !reflection.options.key?(:class_name) &&
+      !reflection.options.key?(:source_type)
+    )
+
+    polymorpic_with_unknowable_klass || !@available_classes.include?(reflection.klass.name)
   end
 
   sig { params(reflection: T.untyped).returns(T.nilable(T::Boolean)) }

data/lib/sorbet-rails/model_plugins/active_record_attribute.rb

@@ -26,7 +26,6 @@ class SorbetRails::ModelPlugins::ActiveRecordAttribute < SorbetRails::ModelPlugi
 
     attribute_module_name = self.model_module_name("GeneratedAttributeMethods")
     attribute_module_rbi = root.create_module(attribute_module_name)
-    attribute_module_rbi.create_extend("T::Sig")
 
     model_class_rbi = root.create_class(self.model_class_name)
     model_class_rbi.create_include(attribute_module_name)

data/lib/sorbet-rails/model_plugins/active_record_enum.rb

@@ -9,7 +9,6 @@ class SorbetRails::ModelPlugins::ActiveRecordEnum < SorbetRails::ModelPlugins::B
 
     enum_module_name = model_module_name("EnumInstanceMethods")
     enum_module_rbi = root.create_module(enum_module_name)
-    enum_module_rbi.create_extend("T::Sig")
 
     model_class_rbi = root.create_class(self.model_class_name)
     model_class_rbi.create_include(enum_module_name)

data/lib/sorbet-rails/model_plugins/active_record_named_scope.rb

@@ -7,15 +7,24 @@ class SorbetRails::ModelPlugins::ActiveRecordNamedScope < SorbetRails::ModelPlug
   def generate(root)
     model_class_rbi = root.create_class(self.model_class_name)
 
-    @model_class.methods.sort.each do |method_name|
+    # Named scope methods are dynamically defined by the `scope` method so their
+    # source_location is `lib/active_record/scoping/named.rb`. So we find scopes
+    # by two criteria:
+    # - they are defined in 'activerecord/lib/active_record/scoping/named.rb'
+    # - they are not one of the methods actually defined in that file's source.
+    # See: https://github.com/rails/rails/blob/master/activerecord/lib/active_record/scoping/named.rb
+    non_dynamic_methods = (
+      ActiveRecord::Scoping::Named::ClassMethods.instance_methods +
+      ActiveRecord::Scoping::Named::ClassMethods.protected_instance_methods +
+      ActiveRecord::Scoping::Named::ClassMethods.private_instance_methods
+    )
+
+    (@model_class.methods - non_dynamic_methods).sort.each do |method_name|
       next unless SorbetRails::Utils.valid_method_name?(method_name.to_s)
+
       method_obj = @model_class.method(method_name)
       next unless method_obj.present? && method_obj.source_location.present?
-      # we detect sscopes defined in a model by 2 criteria:
-      # - they don't have an owner name
-      # - they are defined in 'activerecord/lib/active_record/scoping/named.rb'
-      # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/scoping/named.rb
-      next unless method_obj.owner.name == nil
+
       source_file = method_obj.source_location[0]
       next unless source_file.include?("lib/active_record/scoping/named.rb")
 

data/lib/sorbet-rails/model_plugins/active_record_querying.rb

@@ -9,6 +9,7 @@ class SorbetRails::ModelPlugins::ActiveRecordQuerying < SorbetRails::ModelPlugin
     add_relation_query_method(
       root,
       "all",
+      builtin_query_method: true,
     )
     add_relation_query_method(
       root,
@@ -16,6 +17,7 @@ class SorbetRails::ModelPlugins::ActiveRecordQuerying < SorbetRails::ModelPlugin
       parameters: [
         Parameter.new("&block", type: "T.nilable(T.proc.void)"),
       ],
+      builtin_query_method: true,
     )
 
     # It's not possible to typedef all methods in ActiveRecord::Querying module to have the
@@ -34,6 +36,7 @@ class SorbetRails::ModelPlugins::ActiveRecordQuerying < SorbetRails::ModelPlugin
         parameters: [
           Parameter.new("*args", type: "T.untyped"),
         ],
+        builtin_query_method: true,
       ) if exists_class_method?(method_name)
     end
 
@@ -43,7 +46,8 @@ class SorbetRails::ModelPlugins::ActiveRecordQuerying < SorbetRails::ModelPlugin
       parameters: [
         Parameter.new("*args", type: "T.untyped"),
         Parameter.new("&block", type: "T.nilable(T.proc.void)"),
-      ]
+      ],
+      builtin_query_method: true,
     )
   end
 end

data/lib/sorbet-rails/model_plugins/base.rb

@@ -35,7 +35,8 @@ module SorbetRails::ModelPlugins
       model_class.validators_on(attribute).any? do |validator|
         validator.is_a?(ActiveModel::Validations::PresenceValidator) &&
           !validator.options.key?(:if) &&
-          !validator.options.key?(:unless)
+          !validator.options.key?(:unless) &&
+          !validator.options.key?(:on)
       end
     end
   end

data/lib/sorbet-rails/model_rbi_formatter.rb

@@ -74,8 +74,7 @@ class SorbetRails::ModelRbiFormatter
       self.model_relation_class_name,
       superclass: "ActiveRecord::Relation",
     )
-    model_relation_rbi.create_extend("T::Sig")
-    model_relation_rbi.create_extend("T::Generic")
+    model_relation_rbi.create_include(self.model_query_methods_returning_relation_module_name)
     model_relation_rbi.create_constant(
       "Elem",
       value: "type_member(fixed: #{model_class_name})",
@@ -85,8 +84,7 @@ class SorbetRails::ModelRbiFormatter
       self.model_assoc_relation_class_name,
       superclass: "ActiveRecord::AssociationRelation",
     )
-    model_assoc_relation_rbi.create_extend("T::Sig")
-    model_assoc_relation_rbi.create_extend("T::Generic")
+    model_assoc_relation_rbi.create_include(self.model_query_methods_returning_assoc_relation_module_name)
     model_assoc_relation_rbi.create_constant(
       "Elem",
       value: "type_member(fixed: #{model_class_name})",
@@ -96,8 +94,7 @@ class SorbetRails::ModelRbiFormatter
       self.model_assoc_proxy_class_name,
       superclass: "ActiveRecord::Associations::CollectionProxy",
     )
-    collection_proxy_rbi.create_extend("T::Sig")
-    collection_proxy_rbi.create_extend("T::Generic")
+    collection_proxy_rbi.create_include(self.model_query_methods_returning_assoc_relation_module_name)
     collection_proxy_rbi.create_constant(
       "Elem",
       value: "type_member(fixed: #{self.model_class_name})",
@@ -107,8 +104,7 @@ class SorbetRails::ModelRbiFormatter
       self.model_class_name,
       superclass: T.must(@model_class.superclass).name,
     )
-    model_rbi.create_extend("T::Sig")
-    model_rbi.create_extend("T::Generic")
+    model_rbi.create_extend(self.model_query_methods_returning_relation_module_name)
     model_rbi.create_type_alias(
       self.model_relation_type_class_name,
       type: self.model_relation_type_alias

data/lib/sorbet-rails/model_utils.rb

@@ -37,6 +37,16 @@ module SorbetRails::ModelUtils
     "#{model_class_name}::ActiveRecord_AssociationRelation"
   end
 
+  sig { returns(String) }
+  def model_query_methods_returning_relation_module_name
+    "#{model_class_name}::QueryMethodsReturningRelation"
+  end
+
+  sig { returns(String) }
+  def model_query_methods_returning_assoc_relation_module_name
+    "#{model_class_name}::QueryMethodsReturningAssociationRelation"
+  end
+
   sig { returns(String) }
   def model_relation_type_alias
     types = [
@@ -73,9 +83,13 @@ module SorbetRails::ModelUtils
       root: Parlour::RbiGenerator::Namespace,
       method_name: String,
       parameters: T.nilable(T::Array[::Parlour::RbiGenerator::Parameter]),
+      # This is meant to indicate the method is a rails-provided query method like
+      # where, limit, etc and not something like a named scope. It should likely
+      # only be set to `true` when called from the ActiveRecordQuerying plugin.
+      builtin_query_method: T::Boolean,
     ).void
   }
-  def add_relation_query_method(root, method_name, parameters: nil)
+  def add_relation_query_method(root, method_name, parameters: nil, builtin_query_method: false)
     # a relation querying method will be available on
     # - model (as a class method)
     # - activerecord relation
@@ -84,34 +98,58 @@ module SorbetRails::ModelUtils
     # in case (1) and (2), it returns a Model::ActiveRecord_Relation
     # in case (3) and (4), it returns a Model::ActiveRecord_AssociationRelation
 
-    # force generating these methods because sorbet's hidden-definitions generate & override them
-    model_class_rbi = root.create_class(self.model_class_name)
-    model_class_rbi.create_method(
-      method_name,
-      parameters: parameters,
-      return_type: self.model_relation_class_name,
-      class_method: true,
-    )
-
-    model_relation_rbi = root.create_class(self.model_relation_class_name)
-    model_relation_rbi.create_method(
-      method_name,
-      parameters: parameters,
-      return_type: self.model_relation_class_name,
-    )
-
-    model_assoc_relation_rbi = root.create_class(self.model_assoc_relation_class_name)
-    model_assoc_relation_rbi.create_method(
-      method_name,
-      parameters: parameters,
-      return_type: self.model_assoc_relation_class_name,
-    )
-
-    collection_proxy_rbi = root.create_class(self.model_assoc_proxy_class_name)
-    collection_proxy_rbi.create_method(
-      method_name,
-      parameters: parameters,
-      return_type: self.model_assoc_relation_class_name,
-    )
+    # 'unscoped' is a special case where it always returns a ActiveRecord_Relation
+    assoc_return_value = method_name == 'unscoped' ? self.model_relation_class_name : self.model_assoc_relation_class_name
+
+    # We can put methods onto modules which are extended/included by the model
+    # and relation classes which reduces the RBI footprint for an individual
+    # model. However, in Rails 5 query methods that come from scopes or enums
+    # get overridden in hidden-definitions so we need to explicitly define them
+    # on the model and relation classes.
+    if builtin_query_method || Rails.version =~ /^6\./
+      relation_module_rbi = root.create_module(self.model_query_methods_returning_relation_module_name)
+      relation_module_rbi.create_method(
+        method_name,
+        parameters: parameters,
+        return_type: self.model_relation_class_name,
+      )
+
+      assoc_relation_module_rbi = root.create_module(self.model_query_methods_returning_assoc_relation_module_name)
+      assoc_relation_module_rbi.create_method(
+        method_name,
+        parameters: parameters,
+        return_type: assoc_return_value,
+      )
+    else
+      # force generating these methods because sorbet's hidden-definitions generate & override them
+      model_class_rbi = root.create_class(self.model_class_name)
+      model_class_rbi.create_method(
+        method_name,
+        parameters: parameters,
+        return_type: self.model_relation_class_name,
+        class_method: true,
+      )
+
+      model_relation_rbi = root.create_class(self.model_relation_class_name)
+      model_relation_rbi.create_method(
+        method_name,
+        parameters: parameters,
+        return_type: self.model_relation_class_name,
+      )
+
+      model_assoc_relation_rbi = root.create_class(self.model_assoc_relation_class_name)
+      model_assoc_relation_rbi.create_method(
+        method_name,
+        parameters: parameters,
+        return_type: assoc_return_value,
+      )
+
+      collection_proxy_rbi = root.create_class(self.model_assoc_proxy_class_name)
+      collection_proxy_rbi.create_method(
+        method_name,
+        parameters: parameters,
+        return_type: assoc_return_value,
+      )
+    end
   end
 end

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

@@ -77,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
 
@@ -145,22 +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|
-      model_class_name = model_class.to_s
-      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.3"
+  s.version       = "0.6.4"
   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/generators/rails-template.rb

@@ -91,6 +91,8 @@ def create_models
         biology: 1,
         dark_art: 999,
       }
+
+      scope :recent, -> { where('created_at > ?', 1.month.ago) }
     end
   RUBY
 
@@ -133,7 +135,7 @@ def create_models
     class Wizard < ApplicationRecord
       validates :name, length: { minimum: 5 }, presence: true
       # simulate conditional validation
-      validates :parent_email, presence: true, if: -> { false }
+      validates :parent_email, presence: true, if: :Slytherin?
 
       typed_enum house: {
         Gryffindor: 0,
@@ -478,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

@@ -29,26 +29,6 @@ T.assert_type!(T.must(wizard.wand).wizard, Wizard)
 T.assert_type!(wizard.spell_books, SpellBook::ActiveRecord_Associations_CollectionProxy)
 T.assert_type!(wizard.spell_book_ids, T::Array[Integer])
 
-# -- 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)
-
 # Finder methods -- Model
 T.assert_type!(Wizard.exists?(name: 'Test'), T::Boolean)
 T.assert_type!(Wizard.find(wizard.id), Wizard)
@@ -90,6 +70,18 @@ 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)
@@ -133,6 +125,18 @@ 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) }
@@ -183,13 +187,18 @@ 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!
+# 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) }
@@ -248,12 +257,18 @@ 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
+# 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 methods
 spell_books_query.each { |s| T.assert_type!(s, SpellBook) }
 spell_books_query.map { |s| T.assert_type!(s, SpellBook) }