sorbet-rails 0.7.19 → 0.7.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46916b2838ddb2a8dbbbc8e7ddbaa6a01daa7c7d6be081cb26661ac23f314ffc
-  data.tar.gz: 9dbc6e5beedbf770274f2a0ef21a422579f80d1c27d14dea882109167e05acc7
+  metadata.gz: ea9995d332dc919678919021f657e1b0e6c97030b951c046ec3c5679d67259ef
+  data.tar.gz: 4ee98435162b3514c091e0e4f2e716b90a350f5b9ec5e4c01aa2237e3df62c21
 SHA512:
-  metadata.gz: 44e3a47dd6a57252cb1df2db05fd7c7717e9409e8739f9e8e9040092a3f1400390ed9de1cfd142f7efa79272718c1726ea73948787d458e8b3b7daf581d6de5c
-  data.tar.gz: ef8f746a76f3cda2bf5e83a0e94c6927487ce45d8ca3e8adc2cba42c0811d06ffeef44f6a6c09806ca659381c4c4b4f0adcde01c42f4375a45700331a1dde66e
+  metadata.gz: '009ecc5a48c03bdf2169355907c43c92baaf570eaed5b8770d4afe8fe2bff377c4204a78dc4ed27a151854606bba464152f74ac3ed49a640ee55ae9e37afeebf'
+  data.tar.gz: c317f146ba948570d989aad38f9d11e1fff5dcae666284513f574be1630177c6be668f341731244b4b6803b0a154cba6d45c23c6c4f2194190c632c54a534a1b

data/.github/workflows/ci.yml

@@ -15,7 +15,6 @@ jobs:
 
     env:
       RAILS_VERSION: ${{ matrix.rails }}
-      CI: true
 
     steps:
     - uses: actions/checkout@v2
@@ -24,3 +23,4 @@ jobs:
         ruby-version: ${{ matrix.ruby }}
         # bundler-cache: true -- this messes up some dynamic constants
     - run: "./spec/bin/run_spec.sh"
+    - run: bundle exec srb tc

data/.github/workflows/publish-gem.yml

@@ -10,8 +10,17 @@ jobs:
   build:
     runs-on: ubuntu-latest
 
+    env:
+      RAILS_VERSION: 6.0
+
     steps:
     - uses: actions/checkout@v2
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: 2.7
+        # bundler-cache: true -- this messes up some dynamic constants
+    - run: "./spec/bin/run_spec.sh"
+    - run: bundle exec srb tc
     - name: Release Gem
       uses: dawidd6/action-publish-gem@v1
       with:

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, T::Array[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: T.nilable(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, T::Array[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, T::Array[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, T::Array[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, T::Array[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, T::Array[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, T::Array[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, T::Array[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, T::Array[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, T::Array[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, T::Array[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, T::Array[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, T::Array[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