sorbet-rails 0.6.5 → 0.7.3

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

@@ -165,7 +165,7 @@ module ActiveRecord::InternalMetadata::QueryMethodsReturningRelation
       load: T.nilable(T::Boolean),
       error_on_ignore: T.nilable(T::Boolean),
       block: T.nilable(T.proc.params(e: ActiveRecord::InternalMetadata::ActiveRecord_Relation).void)
-    ).returns(T::Enumerable[ActiveRecord::InternalMetadata::ActiveRecord_Relation])
+    ).returns(ActiveRecord::Batches::BatchEnumerator)
   end
   def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, &block); end
 end
@@ -266,7 +266,7 @@ module ActiveRecord::InternalMetadata::QueryMethodsReturningAssociationRelation
       load: T.nilable(T::Boolean),
       error_on_ignore: T.nilable(T::Boolean),
       block: T.nilable(T.proc.params(e: ActiveRecord::InternalMetadata::ActiveRecord_AssociationRelation).void)
-    ).returns(T::Enumerable[ActiveRecord::InternalMetadata::ActiveRecord_AssociationRelation])
+    ).returns(ActiveRecord::Batches::BatchEnumerator)
   end
   def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, &block); end
 end

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

@@ -11,8 +11,20 @@ module Potion::GeneratedAssociationMethods
   sig { returns(T.nilable(::Wizard)) }
   def wizard; end
 
+  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Wizard).void)).returns(::Wizard) }
+  def build_wizard(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Wizard).void)).returns(::Wizard) }
+  def create_wizard(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Wizard).void)).returns(::Wizard) }
+  def create_wizard!(*args, &block); end
+
   sig { params(value: T.nilable(::Wizard)).void }
   def wizard=(value); end
+
+  sig { returns(T.nilable(::Wizard)) }
+  def reload_wizard; end
 end
 
 module Potion::CustomFinderMethods
@@ -135,7 +147,7 @@ module Potion::QueryMethodsReturningRelation
       load: T.nilable(T::Boolean),
       error_on_ignore: T.nilable(T::Boolean),
       block: T.nilable(T.proc.params(e: Potion::ActiveRecord_Relation).void)
-    ).returns(T::Enumerable[Potion::ActiveRecord_Relation])
+    ).returns(ActiveRecord::Batches::BatchEnumerator)
   end
   def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, &block); end
 end
@@ -236,7 +248,7 @@ module Potion::QueryMethodsReturningAssociationRelation
       load: T.nilable(T::Boolean),
       error_on_ignore: T.nilable(T::Boolean),
       block: T.nilable(T.proc.params(e: Potion::ActiveRecord_AssociationRelation).void)
-    ).returns(T::Enumerable[Potion::ActiveRecord_AssociationRelation])
+    ).returns(ActiveRecord::Batches::BatchEnumerator)
   end
   def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, &block); end
 end

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

@@ -31,8 +31,20 @@ module Robe::GeneratedAssociationMethods
   sig { returns(T.nilable(::Wizard)) }
   def wizard; end
 
+  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Wizard).void)).returns(::Wizard) }
+  def build_wizard(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Wizard).void)).returns(::Wizard) }
+  def create_wizard(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Wizard).void)).returns(::Wizard) }
+  def create_wizard!(*args, &block); end
+
   sig { params(value: T.nilable(::Wizard)).void }
   def wizard=(value); end
+
+  sig { returns(T.nilable(::Wizard)) }
+  def reload_wizard; end
 end
 
 module Robe::CustomFinderMethods
@@ -156,7 +168,7 @@ module Robe::QueryMethodsReturningRelation
       load: T.nilable(T::Boolean),
       error_on_ignore: T.nilable(T::Boolean),
       block: T.nilable(T.proc.params(e: Robe::ActiveRecord_Relation).void)
-    ).returns(T::Enumerable[Robe::ActiveRecord_Relation])
+    ).returns(ActiveRecord::Batches::BatchEnumerator)
   end
   def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, &block); end
 end
@@ -257,7 +269,7 @@ module Robe::QueryMethodsReturningAssociationRelation
       load: T.nilable(T::Boolean),
       error_on_ignore: T.nilable(T::Boolean),
       block: T.nilable(T.proc.params(e: Robe::ActiveRecord_AssociationRelation).void)
-    ).returns(T::Enumerable[Robe::ActiveRecord_AssociationRelation])
+    ).returns(ActiveRecord::Batches::BatchEnumerator)
   end
   def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, &block); end
 end

data/spec/test_data/v5.1/expected_routes.rbi

@@ -5,6 +5,10 @@ class ActionController::Base
   include GeneratedUrlHelpers
 end
 
+class ActionController::API
+  include GeneratedUrlHelpers
+end
+
 module ActionView::Helpers
   include GeneratedUrlHelpers
 end

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

@@ -138,7 +138,7 @@ module ActiveRecord::SchemaMigration::QueryMethodsReturningRelation
       load: T.nilable(T::Boolean),
       error_on_ignore: T.nilable(T::Boolean),
       block: T.nilable(T.proc.params(e: ActiveRecord::SchemaMigration::ActiveRecord_Relation).void)
-    ).returns(T::Enumerable[ActiveRecord::SchemaMigration::ActiveRecord_Relation])
+    ).returns(ActiveRecord::Batches::BatchEnumerator)
   end
   def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, &block); end
 end
@@ -239,7 +239,7 @@ module ActiveRecord::SchemaMigration::QueryMethodsReturningAssociationRelation
       load: T.nilable(T::Boolean),
       error_on_ignore: T.nilable(T::Boolean),
       block: T.nilable(T.proc.params(e: ActiveRecord::SchemaMigration::ActiveRecord_AssociationRelation).void)
-    ).returns(T::Enumerable[ActiveRecord::SchemaMigration::ActiveRecord_AssociationRelation])
+    ).returns(ActiveRecord::Batches::BatchEnumerator)
   end
   def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, &block); end
 end

data/spec/test_data/v5.1/expected_school.rbi

@@ -31,8 +31,20 @@ module School::GeneratedAssociationMethods
   sig { returns(::Headmaster) }
   def headmaster; end
 
+  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Headmaster).void)).returns(::Headmaster) }
+  def build_headmaster(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Headmaster).void)).returns(::Headmaster) }
+  def create_headmaster(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Headmaster).void)).returns(::Headmaster) }
+  def create_headmaster!(*args, &block); end
+
   sig { params(value: ::Headmaster).void }
   def headmaster=(value); end
+
+  sig { returns(::Headmaster) }
+  def reload_headmaster; end
 end
 
 module School::CustomFinderMethods
@@ -156,7 +168,7 @@ module School::QueryMethodsReturningRelation
       load: T.nilable(T::Boolean),
       error_on_ignore: T.nilable(T::Boolean),
       block: T.nilable(T.proc.params(e: School::ActiveRecord_Relation).void)
-    ).returns(T::Enumerable[School::ActiveRecord_Relation])
+    ).returns(ActiveRecord::Batches::BatchEnumerator)
   end
   def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, &block); end
 end
@@ -257,7 +269,7 @@ module School::QueryMethodsReturningAssociationRelation
       load: T.nilable(T::Boolean),
       error_on_ignore: T.nilable(T::Boolean),
       block: T.nilable(T.proc.params(e: School::ActiveRecord_AssociationRelation).void)
-    ).returns(T::Enumerable[School::ActiveRecord_AssociationRelation])
+    ).returns(ActiveRecord::Batches::BatchEnumerator)
   end
   def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, &block); end
 end

data/spec/test_data/v5.1/expected_spell.rbi

@@ -159,7 +159,7 @@ module Spell::QueryMethodsReturningRelation
       load: T.nilable(T::Boolean),
       error_on_ignore: T.nilable(T::Boolean),
       block: T.nilable(T.proc.params(e: Spell::ActiveRecord_Relation).void)
-    ).returns(T::Enumerable[Spell::ActiveRecord_Relation])
+    ).returns(ActiveRecord::Batches::BatchEnumerator)
   end
   def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, &block); end
 end
@@ -260,7 +260,7 @@ module Spell::QueryMethodsReturningAssociationRelation
       load: T.nilable(T::Boolean),
       error_on_ignore: T.nilable(T::Boolean),
       block: T.nilable(T.proc.params(e: Spell::ActiveRecord_AssociationRelation).void)
-    ).returns(T::Enumerable[Spell::ActiveRecord_AssociationRelation])
+    ).returns(ActiveRecord::Batches::BatchEnumerator)
   end
   def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, &block); end
 end

data/spec/test_data/v5.1/expected_spell/habtm_spell_books.rbi

@@ -31,14 +31,38 @@ module Spell::HABTM_SpellBooks::GeneratedAssociationMethods
   sig { returns(T.nilable(::Spell)) }
   def left_side; end
 
+  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Spell).void)).returns(::Spell) }
+  def build_left_side(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Spell).void)).returns(::Spell) }
+  def create_left_side(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Spell).void)).returns(::Spell) }
+  def create_left_side!(*args, &block); end
+
   sig { params(value: T.nilable(::Spell)).void }
   def left_side=(value); end
 
+  sig { returns(T.nilable(::Spell)) }
+  def reload_left_side; end
+
   sig { returns(::SpellBook) }
   def spell_book; end
 
+  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::SpellBook).void)).returns(::SpellBook) }
+  def build_spell_book(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::SpellBook).void)).returns(::SpellBook) }
+  def create_spell_book(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::SpellBook).void)).returns(::SpellBook) }
+  def create_spell_book!(*args, &block); end
+
   sig { params(value: ::SpellBook).void }
   def spell_book=(value); end
+
+  sig { returns(::SpellBook) }
+  def reload_spell_book; end
 end
 
 module Spell::HABTM_SpellBooks::CustomFinderMethods
@@ -162,7 +186,7 @@ module Spell::HABTM_SpellBooks::QueryMethodsReturningRelation
       load: T.nilable(T::Boolean),
       error_on_ignore: T.nilable(T::Boolean),
       block: T.nilable(T.proc.params(e: Spell::HABTM_SpellBooks::ActiveRecord_Relation).void)
-    ).returns(T::Enumerable[Spell::HABTM_SpellBooks::ActiveRecord_Relation])
+    ).returns(ActiveRecord::Batches::BatchEnumerator)
   end
   def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, &block); end
 end
@@ -263,7 +287,7 @@ module Spell::HABTM_SpellBooks::QueryMethodsReturningAssociationRelation
       load: T.nilable(T::Boolean),
       error_on_ignore: T.nilable(T::Boolean),
       block: T.nilable(T.proc.params(e: Spell::HABTM_SpellBooks::ActiveRecord_AssociationRelation).void)
-    ).returns(T::Enumerable[Spell::HABTM_SpellBooks::ActiveRecord_AssociationRelation])
+    ).returns(ActiveRecord::Batches::BatchEnumerator)
   end
   def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, &block); end
 end

data/spec/test_data/v5.1/expected_spell_book.rbi

@@ -65,15 +65,6 @@ module SpellBook::GeneratedAttributeMethods
   def wizard_id?; end
 end
 
-class SpellBook::BookType < T::Enum
-  enums do
-    Unclassified = new(%q{unclassified})
-    Biology = new(%q{biology})
-    DarkArt = new(%q{dark_art})
-  end
-
-end
-
 module SpellBook::GeneratedAssociationMethods
   sig { returns(::Spell::ActiveRecord_Associations_CollectionProxy) }
   def spells; end
@@ -87,8 +78,20 @@ module SpellBook::GeneratedAssociationMethods
   sig { returns(::Wizard) }
   def wizard; end
 
+  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Wizard).void)).returns(::Wizard) }
+  def build_wizard(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Wizard).void)).returns(::Wizard) }
+  def create_wizard(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Wizard).void)).returns(::Wizard) }
+  def create_wizard!(*args, &block); end
+
   sig { params(value: ::Wizard).void }
   def wizard=(value); end
+
+  sig { returns(::Wizard) }
+  def reload_wizard; end
 end
 
 module SpellBook::CustomFinderMethods
@@ -136,6 +139,15 @@ class SpellBook < ApplicationRecord
 
   sig { params(value: SpellBook::BookType).void }
   def typed_book_type=(value); end
+
+  class BookType < T::Enum
+    enums do
+      Unclassified = new(%q{unclassified})
+      Biology = new(%q{biology})
+      DarkArt = new(%q{dark_art})
+    end
+
+  end
 end
 
 class SpellBook::ActiveRecord_Relation < ActiveRecord::Relation
@@ -302,7 +314,7 @@ module SpellBook::QueryMethodsReturningRelation
       load: T.nilable(T::Boolean),
       error_on_ignore: T.nilable(T::Boolean),
       block: T.nilable(T.proc.params(e: SpellBook::ActiveRecord_Relation).void)
-    ).returns(T::Enumerable[SpellBook::ActiveRecord_Relation])
+    ).returns(ActiveRecord::Batches::BatchEnumerator)
   end
   def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, &block); end
 end
@@ -403,7 +415,7 @@ module SpellBook::QueryMethodsReturningAssociationRelation
       load: T.nilable(T::Boolean),
       error_on_ignore: T.nilable(T::Boolean),
       block: T.nilable(T.proc.params(e: SpellBook::ActiveRecord_AssociationRelation).void)
-    ).returns(T::Enumerable[SpellBook::ActiveRecord_AssociationRelation])
+    ).returns(ActiveRecord::Batches::BatchEnumerator)
   end
   def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, &block); end
 end

data/spec/test_data/v5.1/expected_spell_book/habtm_spells.rbi

@@ -31,14 +31,38 @@ module SpellBook::HABTM_Spells::GeneratedAssociationMethods
   sig { returns(T.nilable(::SpellBook)) }
   def left_side; end
 
+  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::SpellBook).void)).returns(::SpellBook) }
+  def build_left_side(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::SpellBook).void)).returns(::SpellBook) }
+  def create_left_side(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::SpellBook).void)).returns(::SpellBook) }
+  def create_left_side!(*args, &block); end
+
   sig { params(value: T.nilable(::SpellBook)).void }
   def left_side=(value); end
 
+  sig { returns(T.nilable(::SpellBook)) }
+  def reload_left_side; end
+
   sig { returns(::Spell) }
   def spell; end
 
+  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Spell).void)).returns(::Spell) }
+  def build_spell(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Spell).void)).returns(::Spell) }
+  def create_spell(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Spell).void)).returns(::Spell) }
+  def create_spell!(*args, &block); end
+
   sig { params(value: ::Spell).void }
   def spell=(value); end
+
+  sig { returns(::Spell) }
+  def reload_spell; end
 end
 
 module SpellBook::HABTM_Spells::CustomFinderMethods
@@ -162,7 +186,7 @@ module SpellBook::HABTM_Spells::QueryMethodsReturningRelation
       load: T.nilable(T::Boolean),
       error_on_ignore: T.nilable(T::Boolean),
       block: T.nilable(T.proc.params(e: SpellBook::HABTM_Spells::ActiveRecord_Relation).void)
-    ).returns(T::Enumerable[SpellBook::HABTM_Spells::ActiveRecord_Relation])
+    ).returns(ActiveRecord::Batches::BatchEnumerator)
   end
   def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, &block); end
 end
@@ -263,7 +287,7 @@ module SpellBook::HABTM_Spells::QueryMethodsReturningAssociationRelation
       load: T.nilable(T::Boolean),
       error_on_ignore: T.nilable(T::Boolean),
       block: T.nilable(T.proc.params(e: SpellBook::HABTM_Spells::ActiveRecord_AssociationRelation).void)
-    ).returns(T::Enumerable[SpellBook::HABTM_Spells::ActiveRecord_AssociationRelation])
+    ).returns(ActiveRecord::Batches::BatchEnumerator)
   end
   def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, &block); end
 end

data/spec/test_data/v5.1/expected_squib.rbi

@@ -111,6 +111,44 @@ module Squib::ActiveRelation_WhereNot
   def not(opts, *rest); end
 end
 
+module Squib::GeneratedSerializedAttributeMethods
+  sig { returns(T.nilable(T.any(T::Array[T.untyped], T::Boolean, Float, T::Hash[T.untyped, T.untyped], Integer, String))) }
+  def newt_subjects; end
+
+  sig { params(value: T.nilable(T.any(T::Array[T.untyped], T::Boolean, Float, T::Hash[T.untyped, T.untyped], Integer, String))).void }
+  def newt_subjects=(value); end
+
+  sig { returns(T::Boolean) }
+  def newt_subjects?; end
+
+  sig { returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
+  def owl_results; end
+
+  sig { params(value: T.nilable(T::Hash[T.untyped, T.untyped])).void }
+  def owl_results=(value); end
+
+  sig { returns(T::Boolean) }
+  def owl_results?; end
+
+  sig { returns(T.nilable(T.any(T::Array[T.untyped], T::Boolean, Float, T::Hash[T.untyped, T.untyped], Integer, String))) }
+  def patronus_characteristics; end
+
+  sig { params(value: T.nilable(T.any(T::Array[T.untyped], T::Boolean, Float, T::Hash[T.untyped, T.untyped], Integer, String))).void }
+  def patronus_characteristics=(value); end
+
+  sig { returns(T::Boolean) }
+  def patronus_characteristics?; end
+
+  sig { returns(T.nilable(T::Array[T.untyped])) }
+  def pets; end
+
+  sig { params(value: T.nilable(T::Array[T.untyped])).void }
+  def pets=(value); end
+
+  sig { returns(T::Boolean) }
+  def pets?; end
+end
+
 module Squib::GeneratedAttributeMethods
   sig { returns(T.nilable(String)) }
   def broom; end
@@ -252,9 +290,21 @@ module Squib::GeneratedAssociationMethods
   sig { returns(T.nilable(::School)) }
   def school; end
 
+  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::School).void)).returns(::School) }
+  def build_school(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::School).void)).returns(::School) }
+  def create_school(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::School).void)).returns(::School) }
+  def create_school!(*args, &block); end
+
   sig { params(value: T.nilable(::School)).void }
   def school=(value); end
 
+  sig { returns(T.nilable(::School)) }
+  def reload_school; end
+
   sig { returns(::SpellBook::ActiveRecord_Associations_CollectionProxy) }
   def spell_books; end
 
@@ -276,8 +326,20 @@ module Squib::GeneratedAssociationMethods
   sig { returns(T.nilable(::Wand)) }
   def wand; end
 
+  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Wand).void)).returns(::Wand) }
+  def build_wand(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Wand).void)).returns(::Wand) }
+  def create_wand(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Wand).void)).returns(::Wand) }
+  def create_wand!(*args, &block); end
+
   sig { params(value: T.nilable(::Wand)).void }
   def wand=(value); end
+
+  sig { returns(T.nilable(::Wand)) }
+  def reload_wand; end
 end
 
 module Squib::CustomFinderMethods
@@ -299,6 +361,7 @@ end
 
 class Squib < Wizard
   include Squib::EnumInstanceMethods
+  include Squib::GeneratedSerializedAttributeMethods
   include Squib::GeneratedAttributeMethods
   include Squib::GeneratedAssociationMethods
   extend Squib::CustomFinderMethods
@@ -668,7 +731,7 @@ module Squib::QueryMethodsReturningRelation
       load: T.nilable(T::Boolean),
       error_on_ignore: T.nilable(T::Boolean),
       block: T.nilable(T.proc.params(e: Squib::ActiveRecord_Relation).void)
-    ).returns(T::Enumerable[Squib::ActiveRecord_Relation])
+    ).returns(ActiveRecord::Batches::BatchEnumerator)
   end
   def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, &block); end
 end
@@ -769,7 +832,7 @@ module Squib::QueryMethodsReturningAssociationRelation
       load: T.nilable(T::Boolean),
       error_on_ignore: T.nilable(T::Boolean),
       block: T.nilable(T.proc.params(e: Squib::ActiveRecord_AssociationRelation).void)
-    ).returns(T::Enumerable[Squib::ActiveRecord_AssociationRelation])
+    ).returns(ActiveRecord::Batches::BatchEnumerator)
   end
   def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, &block); end
 end