sorbet-rails 0.7.19 → 0.7.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46916b2838ddb2a8dbbbc8e7ddbaa6a01daa7c7d6be081cb26661ac23f314ffc
-  data.tar.gz: 9dbc6e5beedbf770274f2a0ef21a422579f80d1c27d14dea882109167e05acc7
+  metadata.gz: '0558c5531553c522732f660d34e3c40595e6de551545ac1e841f706a95afe4c9'
+  data.tar.gz: b478f41bff9b1a4815536a3b6c80d895694587de7dfab985caf7eda779a98168
 SHA512:
-  metadata.gz: 44e3a47dd6a57252cb1df2db05fd7c7717e9409e8739f9e8e9040092a3f1400390ed9de1cfd142f7efa79272718c1726ea73948787d458e8b3b7daf581d6de5c
-  data.tar.gz: ef8f746a76f3cda2bf5e83a0e94c6927487ce45d8ca3e8adc2cba42c0811d06ffeef44f6a6c09806ca659381c4c4b4f0adcde01c42f4375a45700331a1dde66e
+  metadata.gz: bd7ab5eca8697b424c3087ec93a507fd1af4dffa6cb027c56b84f43457884e3166826de123ebd49de2158b9dc0ef6d67148972779b54d03eb8b256cd5e1000d0
+  data.tar.gz: a438116c58dce3f75ae5fc968249c4f3c6ebe3146a353b1a33e8738ad5d815dcca126df5fab01343306360a83159e89297c0ee275d05d6ef9b5deb015bbee8b3

data/README.md

@@ -411,8 +411,16 @@ Model.unscoped.scoping do … end
 
 ### `select` with a block
 
-The [`select` method](https://apidock.com/rails/v4.0.2/ActiveRecord/QueryMethods/select) in Rails has two modes: it can be given a list of symbols, in which case rails will only return the given columns from the database, or it can be given a block, in which case it acts like [`Enumerable.select`](https://ruby-doc.org/core-2.6.4/Enumerable.html) and returns an array. We have chosen to support the first use case. If you want to pass a block to `select`, you can simply call `to_a` before you do. Note that this would be done within the `select` call anyway, so the performance penalty will be minimal.
+The [`select` method](https://apidock.com/rails/v4.0.2/ActiveRecord/QueryMethods/select) in Rails has two modes: it can be given a list of symbols, in which case rails will only return the given columns from the database, or it can be given a block, in which case it acts like [`Enumerable.select`](https://ruby-doc.org/core-2.6.4/Enumerable.html) and returns an array.
 
+We have chosen to support `select` with a block as the primary use case, since it is a more prevalent use of this method. We provide `select_columns` as an alternative if you want to select a list of columns.
+
+```
+Model.select { |record| record.id > 1} # valid, returns an array
+Model.select_columns(:id, :name) # valid, returns an association
+
+Model.select(:id, :name) # sorbet error, use `select_column` instead
+```
 ### `flatten` an array of relation
 
 When you call `flatten` on an array of ActiveRecord::Relation, sorbet [doesn't recognize](https://github.com/sorbet/sorbet/issues/2767) that it will flatten the relation and return an array of model. The work around is to call `to_a` on the relation first.

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

@@ -25,7 +25,8 @@ class SorbetRails::ModelPlugins::ActiveRecordQuerying < SorbetRails::ModelPlugin
     # <Model>::Relation class.
     # rails/activerecord/lib/active_record/querying.rb
     model_query_relation_methods = [
-      :select, :reselect, :order, :reorder, :group, :limit, :offset, :joins, :left_joins, :left_outer_joins,
+      # :select,
+      :reselect, :order, :reorder, :group, :limit, :offset, :joins, :left_joins, :left_outer_joins,
       :where, :rewhere, :preload, :extract_associated, :eager_load, :includes, :from, :lock, :readonly, :or,
       :having, :create_with, :distinct, :references, :none, :unscope, :optimizer_hints, :merge, :except, :only,
     ]
@@ -39,6 +40,29 @@ class SorbetRails::ModelPlugins::ActiveRecordQuerying < SorbetRails::ModelPlugin
         builtin_query_method: true,
       ) if exists_class_method?(method_name)
     end
+    if exists_class_method?("select")
+      # `select` can be used with a block to return an array, or with a list of column name
+      # to return a relation object that can be chained.
+      # I've seen usage of `select` with a block more often than with a list of column name.
+      # here we define select as taking a block, and add a `select_column` method for the other usage
+      add_relation_query_method(
+        root,
+        "select",
+        parameters: [
+          Parameter.new("&block", type: "T.proc.params(e: #{self.model_class_name}).returns(T::Boolean)"),
+        ],
+        builtin_query_method: true,
+        custom_return_value: "T::Array[#{self.model_class_name}]",
+      )
+      add_relation_query_method(
+        root,
+        "select_columns", # select_column is injected by sorbet-rails
+        parameters: [
+          Parameter.new("*args", type: "T.any(String, Symbol)"),
+        ],
+        builtin_query_method: true,
+      )
+    end
 
     add_relation_query_method(
       root,

data/lib/sorbet-rails/model_utils.rb

@@ -90,9 +90,16 @@ module SorbetRails::ModelUtils
       # 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,
+      custom_return_value: String,
     ).void
   }
-  def add_relation_query_method(root, method_name, parameters: nil, builtin_query_method: false)
+  def add_relation_query_method(
+    root,
+    method_name,
+    parameters: nil,
+    builtin_query_method: false,
+    custom_return_value: nil
+  )
     # a relation querying method will be available on
     # - model (as a class method)
     # - activerecord relation
@@ -114,14 +121,14 @@ module SorbetRails::ModelUtils
       relation_module_rbi.create_method(
         method_name,
         parameters: parameters,
-        return_type: self.model_relation_class_name,
+        return_type: custom_return_value || 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,
+        return_type: custom_return_value || assoc_return_value,
       )
     else
       # force generating these methods because sorbet's hidden-definitions generate & override them
@@ -129,7 +136,7 @@ module SorbetRails::ModelUtils
       model_class_rbi.create_method(
         method_name,
         parameters: parameters,
-        return_type: self.model_relation_class_name,
+        return_type: custom_return_value || self.model_relation_class_name,
         class_method: true,
       )
 
@@ -137,21 +144,21 @@ module SorbetRails::ModelUtils
       model_relation_rbi.create_method(
         method_name,
         parameters: parameters,
-        return_type: self.model_relation_class_name,
+        return_type: custom_return_value || 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,
+        return_type: custom_return_value || 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,
+        return_type: custom_return_value || assoc_return_value,
       )
     end
   end

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

@@ -13,6 +13,10 @@ module SorbetRails
       last(n)
     end
 
+    def select_columns(*args)
+      select(*args)
+    end
+
     # Redeclare these dynamic methods here otherwise they will be generated by
     # `srb rbi hidden-definitions`
     def find_by_id(id)

data/sorbet-rails.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name          = %q{sorbet-rails}
-  s.version       = "0.7.#{ENV['GITHUB_RUN_NUMBER']}".strip
+  s.version       = "0.7.#{ENV['GITHUB_RUN_NUMBER'] || 100}".strip
   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/sorbet_test_cases.rb

@@ -84,6 +84,8 @@ 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.select { |r| r.id == 1 }, T::Array[Wizard])
+T.assert_type!(Wizard.select_columns(:id, :name), Wizard::ActiveRecord_Relation)
 
 # Finder methods -- ActiveRecord::Relation
 T.assert_type!(Wizard.all.exists?(name: 'Harry Potter'), T::Boolean)
@@ -146,6 +148,8 @@ 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)
+T.assert_type!(Wizard.all.select { |r| r.id == 1 }, T::Array[Wizard])
+T.assert_type!(Wizard.all.select_columns(:id, :name), Wizard::ActiveRecord_Relation)
 # Enumerable methods
 Wizard.all.each { |w| T.assert_type!(w, Wizard) }
 Wizard.all.map { |w| T.assert_type!(w, Wizard) }
@@ -214,6 +218,9 @@ T.assert_type!(spell_books.where.not(id: 1), SpellBook::ActiveRecord_Association
 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.select { |r| r.id == 1 }, T::Array[SpellBook])
+T.assert_type!(spell_books.select_columns(:id, :name), SpellBook::ActiveRecord_AssociationRelation)
+
 # Enumerable methods
 spell_books.each { |s| T.assert_type!(s, SpellBook) }
 spell_books.map { |s| T.assert_type!(s, SpellBook) }
@@ -290,6 +297,8 @@ T.assert_type!(spell_books_query.where.not(id: 1), SpellBook::ActiveRecord_Assoc
 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.select { |r| r.id == 1 }, T::Array[SpellBook])
+T.assert_type!(spell_books.select_columns(:id, :name), 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) }

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

@@ -1,7 +1,7 @@
 PATH
   remote: ../../..
   specs:
-    sorbet-rails (0.7.5)
+    sorbet-rails (0.7.100)
       method_source (>= 0.9.2)
       parlour (>= 4.0.1)
       parser (>= 2.7)

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

@@ -84,6 +84,8 @@ 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.select { |r| r.id == 1 }, T::Array[Wizard])
+T.assert_type!(Wizard.select_columns(:id, :name), Wizard::ActiveRecord_Relation)
 
 # Finder methods -- ActiveRecord::Relation
 T.assert_type!(Wizard.all.exists?(name: 'Harry Potter'), T::Boolean)
@@ -146,6 +148,8 @@ 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)
+T.assert_type!(Wizard.all.select { |r| r.id == 1 }, T::Array[Wizard])
+T.assert_type!(Wizard.all.select_columns(:id, :name), Wizard::ActiveRecord_Relation)
 # Enumerable methods
 Wizard.all.each { |w| T.assert_type!(w, Wizard) }
 Wizard.all.map { |w| T.assert_type!(w, Wizard) }
@@ -214,6 +218,9 @@ T.assert_type!(spell_books.where.not(id: 1), SpellBook::ActiveRecord_Association
 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.select { |r| r.id == 1 }, T::Array[SpellBook])
+T.assert_type!(spell_books.select_columns(:id, :name), SpellBook::ActiveRecord_AssociationRelation)
+
 # Enumerable methods
 spell_books.each { |s| T.assert_type!(s, SpellBook) }
 spell_books.map { |s| T.assert_type!(s, SpellBook) }
@@ -290,6 +297,8 @@ T.assert_type!(spell_books_query.where.not(id: 1), SpellBook::ActiveRecord_Assoc
 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.select { |r| r.id == 1 }, T::Array[SpellBook])
+T.assert_type!(spell_books.select_columns(:id, :name), 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) }

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

@@ -1,7 +1,7 @@
 PATH
   remote: ../../..
   specs:
-    sorbet-rails (0.7.5)
+    sorbet-rails (0.7.100)
       method_source (>= 0.9.2)
       parlour (>= 4.0.1)
       parser (>= 2.7)

data/spec/support/v6.0/sorbet_test_cases.rb

@@ -84,6 +84,8 @@ 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.select { |r| r.id == 1 }, T::Array[Wizard])
+T.assert_type!(Wizard.select_columns(:id, :name), Wizard::ActiveRecord_Relation)
 
 # Finder methods -- ActiveRecord::Relation
 T.assert_type!(Wizard.all.exists?(name: 'Harry Potter'), T::Boolean)
@@ -146,6 +148,8 @@ 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)
+T.assert_type!(Wizard.all.select { |r| r.id == 1 }, T::Array[Wizard])
+T.assert_type!(Wizard.all.select_columns(:id, :name), Wizard::ActiveRecord_Relation)
 # Enumerable methods
 Wizard.all.each { |w| T.assert_type!(w, Wizard) }
 Wizard.all.map { |w| T.assert_type!(w, Wizard) }
@@ -214,6 +218,9 @@ T.assert_type!(spell_books.where.not(id: 1), SpellBook::ActiveRecord_Association
 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.select { |r| r.id == 1 }, T::Array[SpellBook])
+T.assert_type!(spell_books.select_columns(:id, :name), SpellBook::ActiveRecord_AssociationRelation)
+
 # Enumerable methods
 spell_books.each { |s| T.assert_type!(s, SpellBook) }
 spell_books.map { |s| T.assert_type!(s, SpellBook) }
@@ -290,6 +297,8 @@ T.assert_type!(spell_books_query.where.not(id: 1), SpellBook::ActiveRecord_Assoc
 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.select { |r| r.id == 1 }, T::Array[SpellBook])
+T.assert_type!(spell_books.select_columns(:id, :name), 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) }

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

@@ -84,6 +84,8 @@ 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.select { |r| r.id == 1 }, T::Array[Wizard])
+T.assert_type!(Wizard.select_columns(:id, :name), Wizard::ActiveRecord_Relation)
 
 # Finder methods -- ActiveRecord::Relation
 T.assert_type!(Wizard.all.exists?(name: 'Harry Potter'), T::Boolean)
@@ -146,6 +148,8 @@ 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)
+T.assert_type!(Wizard.all.select { |r| r.id == 1 }, T::Array[Wizard])
+T.assert_type!(Wizard.all.select_columns(:id, :name), Wizard::ActiveRecord_Relation)
 # Enumerable methods
 Wizard.all.each { |w| T.assert_type!(w, Wizard) }
 Wizard.all.map { |w| T.assert_type!(w, Wizard) }
@@ -214,6 +218,9 @@ T.assert_type!(spell_books.where.not(id: 1), SpellBook::ActiveRecord_Association
 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.select { |r| r.id == 1 }, T::Array[SpellBook])
+T.assert_type!(spell_books.select_columns(:id, :name), SpellBook::ActiveRecord_AssociationRelation)
+
 # Enumerable methods
 spell_books.each { |s| T.assert_type!(s, SpellBook) }
 spell_books.map { |s| T.assert_type!(s, SpellBook) }
@@ -290,6 +297,8 @@ T.assert_type!(spell_books_query.where.not(id: 1), SpellBook::ActiveRecord_Assoc
 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.select { |r| r.id == 1 }, T::Array[SpellBook])
+T.assert_type!(spell_books.select_columns(:id, :name), 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) }

data/spec/test_data/v5.2/expected_attachment.rbi

@@ -76,9 +76,6 @@ module ActiveStorage::Attachment::QueryMethodsReturningRelation
   sig { params(block: T.nilable(T.proc.void)).returns(ActiveStorage::Attachment::ActiveRecord_Relation) }
   def unscoped(&block); end
 
-  sig { params(args: T.untyped).returns(ActiveStorage::Attachment::ActiveRecord_Relation) }
-  def select(*args); end
-
   sig { params(args: T.untyped).returns(ActiveStorage::Attachment::ActiveRecord_Relation) }
   def order(*args); end
 
@@ -154,6 +151,12 @@ module ActiveStorage::Attachment::QueryMethodsReturningRelation
   sig { params(args: T.untyped).returns(ActiveStorage::Attachment::ActiveRecord_Relation) }
   def except(*args); end
 
+  sig { params(block: T.proc.params(e: ActiveStorage::Attachment).returns(T::Boolean)).returns(T::Array[ActiveStorage::Attachment]) }
+  def select(&block); end
+
+  sig { params(args: T.any(String, Symbol)).returns(ActiveStorage::Attachment::ActiveRecord_Relation) }
+  def select_columns(*args); end
+
   sig { params(args: T.untyped, block: T.nilable(T.proc.void)).returns(ActiveStorage::Attachment::ActiveRecord_Relation) }
   def extending(*args, &block); end
 
@@ -177,9 +180,6 @@ module ActiveStorage::Attachment::QueryMethodsReturningAssociationRelation
   sig { params(block: T.nilable(T.proc.void)).returns(ActiveStorage::Attachment::ActiveRecord_Relation) }
   def unscoped(&block); end
 
-  sig { params(args: T.untyped).returns(ActiveStorage::Attachment::ActiveRecord_AssociationRelation) }
-  def select(*args); end
-
   sig { params(args: T.untyped).returns(ActiveStorage::Attachment::ActiveRecord_AssociationRelation) }
   def order(*args); end
 
@@ -255,6 +255,12 @@ module ActiveStorage::Attachment::QueryMethodsReturningAssociationRelation
   sig { params(args: T.untyped).returns(ActiveStorage::Attachment::ActiveRecord_AssociationRelation) }
   def except(*args); end
 
+  sig { params(block: T.proc.params(e: ActiveStorage::Attachment).returns(T::Boolean)).returns(T::Array[ActiveStorage::Attachment]) }
+  def select(&block); end
+
+  sig { params(args: T.any(String, Symbol)).returns(ActiveStorage::Attachment::ActiveRecord_AssociationRelation) }
+  def select_columns(*args); end
+
   sig { params(args: T.untyped, block: T.nilable(T.proc.void)).returns(ActiveStorage::Attachment::ActiveRecord_AssociationRelation) }
   def extending(*args, &block); end
 

data/spec/test_data/v5.2/expected_blob.rbi

@@ -141,9 +141,6 @@ module ActiveStorage::Blob::QueryMethodsReturningRelation
   sig { params(block: T.nilable(T.proc.void)).returns(ActiveStorage::Blob::ActiveRecord_Relation) }
   def unscoped(&block); end
 
-  sig { params(args: T.untyped).returns(ActiveStorage::Blob::ActiveRecord_Relation) }
-  def select(*args); end
-
   sig { params(args: T.untyped).returns(ActiveStorage::Blob::ActiveRecord_Relation) }
   def order(*args); end
 
@@ -219,6 +216,12 @@ module ActiveStorage::Blob::QueryMethodsReturningRelation
   sig { params(args: T.untyped).returns(ActiveStorage::Blob::ActiveRecord_Relation) }
   def except(*args); end
 
+  sig { params(block: T.proc.params(e: ActiveStorage::Blob).returns(T::Boolean)).returns(T::Array[ActiveStorage::Blob]) }
+  def select(&block); end
+
+  sig { params(args: T.any(String, Symbol)).returns(ActiveStorage::Blob::ActiveRecord_Relation) }
+  def select_columns(*args); end
+
   sig { params(args: T.untyped, block: T.nilable(T.proc.void)).returns(ActiveStorage::Blob::ActiveRecord_Relation) }
   def extending(*args, &block); end
 
@@ -242,9 +245,6 @@ module ActiveStorage::Blob::QueryMethodsReturningAssociationRelation
   sig { params(block: T.nilable(T.proc.void)).returns(ActiveStorage::Blob::ActiveRecord_Relation) }
   def unscoped(&block); end
 
-  sig { params(args: T.untyped).returns(ActiveStorage::Blob::ActiveRecord_AssociationRelation) }
-  def select(*args); end
-
   sig { params(args: T.untyped).returns(ActiveStorage::Blob::ActiveRecord_AssociationRelation) }
   def order(*args); end
 
@@ -320,6 +320,12 @@ module ActiveStorage::Blob::QueryMethodsReturningAssociationRelation
   sig { params(args: T.untyped).returns(ActiveStorage::Blob::ActiveRecord_AssociationRelation) }
   def except(*args); end
 
+  sig { params(block: T.proc.params(e: ActiveStorage::Blob).returns(T::Boolean)).returns(T::Array[ActiveStorage::Blob]) }
+  def select(&block); end
+
+  sig { params(args: T.any(String, Symbol)).returns(ActiveStorage::Blob::ActiveRecord_AssociationRelation) }
+  def select_columns(*args); end
+
   sig { params(args: T.untyped, block: T.nilable(T.proc.void)).returns(ActiveStorage::Blob::ActiveRecord_AssociationRelation) }
   def extending(*args, &block); end
 

data/spec/test_data/v5.2/expected_headmaster.rbi

@@ -106,9 +106,6 @@ module Headmaster::QueryMethodsReturningRelation
   sig { params(block: T.nilable(T.proc.void)).returns(Headmaster::ActiveRecord_Relation) }
   def unscoped(&block); end
 
-  sig { params(args: T.untyped).returns(Headmaster::ActiveRecord_Relation) }
-  def select(*args); end
-
   sig { params(args: T.untyped).returns(Headmaster::ActiveRecord_Relation) }
   def order(*args); end
 
@@ -184,6 +181,12 @@ module Headmaster::QueryMethodsReturningRelation
   sig { params(args: T.untyped).returns(Headmaster::ActiveRecord_Relation) }
   def except(*args); end
 
+  sig { params(block: T.proc.params(e: Headmaster).returns(T::Boolean)).returns(T::Array[Headmaster]) }
+  def select(&block); end
+
+  sig { params(args: T.any(String, Symbol)).returns(Headmaster::ActiveRecord_Relation) }
+  def select_columns(*args); end
+
   sig { params(args: T.untyped, block: T.nilable(T.proc.void)).returns(Headmaster::ActiveRecord_Relation) }
   def extending(*args, &block); end
 
@@ -207,9 +210,6 @@ module Headmaster::QueryMethodsReturningAssociationRelation
   sig { params(block: T.nilable(T.proc.void)).returns(Headmaster::ActiveRecord_Relation) }
   def unscoped(&block); end
 
-  sig { params(args: T.untyped).returns(Headmaster::ActiveRecord_AssociationRelation) }
-  def select(*args); end
-
   sig { params(args: T.untyped).returns(Headmaster::ActiveRecord_AssociationRelation) }
   def order(*args); end
 
@@ -285,6 +285,12 @@ module Headmaster::QueryMethodsReturningAssociationRelation
   sig { params(args: T.untyped).returns(Headmaster::ActiveRecord_AssociationRelation) }
   def except(*args); end
 
+  sig { params(block: T.proc.params(e: Headmaster).returns(T::Boolean)).returns(T::Array[Headmaster]) }
+  def select(&block); end
+
+  sig { params(args: T.any(String, Symbol)).returns(Headmaster::ActiveRecord_AssociationRelation) }
+  def select_columns(*args); end
+
   sig { params(args: T.untyped, block: T.nilable(T.proc.void)).returns(Headmaster::ActiveRecord_AssociationRelation) }
   def extending(*args, &block); end
 

data/spec/test_data/v5.2/expected_internal_metadata.rbi

@@ -76,9 +76,6 @@ module ActiveRecord::InternalMetadata::QueryMethodsReturningRelation
   sig { params(block: T.nilable(T.proc.void)).returns(ActiveRecord::InternalMetadata::ActiveRecord_Relation) }
   def unscoped(&block); end
 
-  sig { params(args: T.untyped).returns(ActiveRecord::InternalMetadata::ActiveRecord_Relation) }
-  def select(*args); end
-
   sig { params(args: T.untyped).returns(ActiveRecord::InternalMetadata::ActiveRecord_Relation) }
   def order(*args); end
 
@@ -154,6 +151,12 @@ module ActiveRecord::InternalMetadata::QueryMethodsReturningRelation
   sig { params(args: T.untyped).returns(ActiveRecord::InternalMetadata::ActiveRecord_Relation) }
   def except(*args); end
 
+  sig { params(block: T.proc.params(e: ActiveRecord::InternalMetadata).returns(T::Boolean)).returns(T::Array[ActiveRecord::InternalMetadata]) }
+  def select(&block); end
+
+  sig { params(args: T.any(String, Symbol)).returns(ActiveRecord::InternalMetadata::ActiveRecord_Relation) }
+  def select_columns(*args); end
+
   sig { params(args: T.untyped, block: T.nilable(T.proc.void)).returns(ActiveRecord::InternalMetadata::ActiveRecord_Relation) }
   def extending(*args, &block); end
 
@@ -177,9 +180,6 @@ module ActiveRecord::InternalMetadata::QueryMethodsReturningAssociationRelation
   sig { params(block: T.nilable(T.proc.void)).returns(ActiveRecord::InternalMetadata::ActiveRecord_Relation) }
   def unscoped(&block); end
 
-  sig { params(args: T.untyped).returns(ActiveRecord::InternalMetadata::ActiveRecord_AssociationRelation) }
-  def select(*args); end
-
   sig { params(args: T.untyped).returns(ActiveRecord::InternalMetadata::ActiveRecord_AssociationRelation) }
   def order(*args); end
 
@@ -255,6 +255,12 @@ module ActiveRecord::InternalMetadata::QueryMethodsReturningAssociationRelation
   sig { params(args: T.untyped).returns(ActiveRecord::InternalMetadata::ActiveRecord_AssociationRelation) }
   def except(*args); end
 
+  sig { params(block: T.proc.params(e: ActiveRecord::InternalMetadata).returns(T::Boolean)).returns(T::Array[ActiveRecord::InternalMetadata]) }
+  def select(&block); end
+
+  sig { params(args: T.any(String, Symbol)).returns(ActiveRecord::InternalMetadata::ActiveRecord_AssociationRelation) }
+  def select_columns(*args); end
+
   sig { params(args: T.untyped, block: T.nilable(T.proc.void)).returns(ActiveRecord::InternalMetadata::ActiveRecord_AssociationRelation) }
   def extending(*args, &block); end
 

data/spec/test_data/v5.2/expected_potion.rbi

@@ -58,9 +58,6 @@ module Potion::QueryMethodsReturningRelation
   sig { params(block: T.nilable(T.proc.void)).returns(Potion::ActiveRecord_Relation) }
   def unscoped(&block); end
 
-  sig { params(args: T.untyped).returns(Potion::ActiveRecord_Relation) }
-  def select(*args); end
-
   sig { params(args: T.untyped).returns(Potion::ActiveRecord_Relation) }
   def order(*args); end
 
@@ -136,6 +133,12 @@ module Potion::QueryMethodsReturningRelation
   sig { params(args: T.untyped).returns(Potion::ActiveRecord_Relation) }
   def except(*args); end
 
+  sig { params(block: T.proc.params(e: Potion).returns(T::Boolean)).returns(T::Array[Potion]) }
+  def select(&block); end
+
+  sig { params(args: T.any(String, Symbol)).returns(Potion::ActiveRecord_Relation) }
+  def select_columns(*args); end
+
   sig { params(args: T.untyped, block: T.nilable(T.proc.void)).returns(Potion::ActiveRecord_Relation) }
   def extending(*args, &block); end
 
@@ -159,9 +162,6 @@ module Potion::QueryMethodsReturningAssociationRelation
   sig { params(block: T.nilable(T.proc.void)).returns(Potion::ActiveRecord_Relation) }
   def unscoped(&block); end
 
-  sig { params(args: T.untyped).returns(Potion::ActiveRecord_AssociationRelation) }
-  def select(*args); end
-
   sig { params(args: T.untyped).returns(Potion::ActiveRecord_AssociationRelation) }
   def order(*args); end
 
@@ -237,6 +237,12 @@ module Potion::QueryMethodsReturningAssociationRelation
   sig { params(args: T.untyped).returns(Potion::ActiveRecord_AssociationRelation) }
   def except(*args); end
 
+  sig { params(block: T.proc.params(e: Potion).returns(T::Boolean)).returns(T::Array[Potion]) }
+  def select(&block); end
+
+  sig { params(args: T.any(String, Symbol)).returns(Potion::ActiveRecord_AssociationRelation) }
+  def select_columns(*args); end
+
   sig { params(args: T.untyped, block: T.nilable(T.proc.void)).returns(Potion::ActiveRecord_AssociationRelation) }
   def extending(*args, &block); end
 

data/spec/test_data/v5.2/expected_robe.rbi

@@ -79,9 +79,6 @@ module Robe::QueryMethodsReturningRelation
   sig { params(block: T.nilable(T.proc.void)).returns(Robe::ActiveRecord_Relation) }
   def unscoped(&block); end
 
-  sig { params(args: T.untyped).returns(Robe::ActiveRecord_Relation) }
-  def select(*args); end
-
   sig { params(args: T.untyped).returns(Robe::ActiveRecord_Relation) }
   def order(*args); end
 
@@ -157,6 +154,12 @@ module Robe::QueryMethodsReturningRelation
   sig { params(args: T.untyped).returns(Robe::ActiveRecord_Relation) }
   def except(*args); end
 
+  sig { params(block: T.proc.params(e: Robe).returns(T::Boolean)).returns(T::Array[Robe]) }
+  def select(&block); end
+
+  sig { params(args: T.any(String, Symbol)).returns(Robe::ActiveRecord_Relation) }
+  def select_columns(*args); end
+
   sig { params(args: T.untyped, block: T.nilable(T.proc.void)).returns(Robe::ActiveRecord_Relation) }
   def extending(*args, &block); end
 
@@ -180,9 +183,6 @@ module Robe::QueryMethodsReturningAssociationRelation
   sig { params(block: T.nilable(T.proc.void)).returns(Robe::ActiveRecord_Relation) }
   def unscoped(&block); end
 
-  sig { params(args: T.untyped).returns(Robe::ActiveRecord_AssociationRelation) }
-  def select(*args); end
-
   sig { params(args: T.untyped).returns(Robe::ActiveRecord_AssociationRelation) }
   def order(*args); end
 
@@ -258,6 +258,12 @@ module Robe::QueryMethodsReturningAssociationRelation
   sig { params(args: T.untyped).returns(Robe::ActiveRecord_AssociationRelation) }
   def except(*args); end
 
+  sig { params(block: T.proc.params(e: Robe).returns(T::Boolean)).returns(T::Array[Robe]) }
+  def select(&block); end
+
+  sig { params(args: T.any(String, Symbol)).returns(Robe::ActiveRecord_AssociationRelation) }
+  def select_columns(*args); end
+
   sig { params(args: T.untyped, block: T.nilable(T.proc.void)).returns(Robe::ActiveRecord_AssociationRelation) }
   def extending(*args, &block); end
 

data/spec/test_data/v5.2/expected_schema_migration.rbi

@@ -49,9 +49,6 @@ module ActiveRecord::SchemaMigration::QueryMethodsReturningRelation
   sig { params(block: T.nilable(T.proc.void)).returns(ActiveRecord::SchemaMigration::ActiveRecord_Relation) }
   def unscoped(&block); end
 
-  sig { params(args: T.untyped).returns(ActiveRecord::SchemaMigration::ActiveRecord_Relation) }
-  def select(*args); end
-
   sig { params(args: T.untyped).returns(ActiveRecord::SchemaMigration::ActiveRecord_Relation) }
   def order(*args); end
 
@@ -127,6 +124,12 @@ module ActiveRecord::SchemaMigration::QueryMethodsReturningRelation
   sig { params(args: T.untyped).returns(ActiveRecord::SchemaMigration::ActiveRecord_Relation) }
   def except(*args); end
 
+  sig { params(block: T.proc.params(e: ActiveRecord::SchemaMigration).returns(T::Boolean)).returns(T::Array[ActiveRecord::SchemaMigration]) }
+  def select(&block); end
+
+  sig { params(args: T.any(String, Symbol)).returns(ActiveRecord::SchemaMigration::ActiveRecord_Relation) }
+  def select_columns(*args); end
+
   sig { params(args: T.untyped, block: T.nilable(T.proc.void)).returns(ActiveRecord::SchemaMigration::ActiveRecord_Relation) }
   def extending(*args, &block); end
 
@@ -150,9 +153,6 @@ module ActiveRecord::SchemaMigration::QueryMethodsReturningAssociationRelation
   sig { params(block: T.nilable(T.proc.void)).returns(ActiveRecord::SchemaMigration::ActiveRecord_Relation) }
   def unscoped(&block); end
 
-  sig { params(args: T.untyped).returns(ActiveRecord::SchemaMigration::ActiveRecord_AssociationRelation) }
-  def select(*args); end
-
   sig { params(args: T.untyped).returns(ActiveRecord::SchemaMigration::ActiveRecord_AssociationRelation) }
   def order(*args); end
 
@@ -228,6 +228,12 @@ module ActiveRecord::SchemaMigration::QueryMethodsReturningAssociationRelation
   sig { params(args: T.untyped).returns(ActiveRecord::SchemaMigration::ActiveRecord_AssociationRelation) }
   def except(*args); end
 
+  sig { params(block: T.proc.params(e: ActiveRecord::SchemaMigration).returns(T::Boolean)).returns(T::Array[ActiveRecord::SchemaMigration]) }
+  def select(&block); end
+
+  sig { params(args: T.any(String, Symbol)).returns(ActiveRecord::SchemaMigration::ActiveRecord_AssociationRelation) }
+  def select_columns(*args); end
+
   sig { params(args: T.untyped, block: T.nilable(T.proc.void)).returns(ActiveRecord::SchemaMigration::ActiveRecord_AssociationRelation) }
   def extending(*args, &block); end