sorbet-rails 0.6.5 → 0.7.3

data/spec/test_data/v5.0/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
@@ -159,7 +183,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
@@ -257,7 +281,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.0/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
@@ -665,7 +728,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
@@ -763,7 +826,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

data/spec/test_data/v5.0/expected_subject.rbi

@@ -156,7 +156,7 @@ module Subject::QueryMethodsReturningRelation
       load: T.nilable(T::Boolean),
       error_on_ignore: T.nilable(T::Boolean),
       block: T.nilable(T.proc.params(e: Subject::ActiveRecord_Relation).void)
-    ).returns(T::Enumerable[Subject::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
@@ -254,7 +254,7 @@ module Subject::QueryMethodsReturningAssociationRelation
       load: T.nilable(T::Boolean),
       error_on_ignore: T.nilable(T::Boolean),
       block: T.nilable(T.proc.params(e: Subject::ActiveRecord_AssociationRelation).void)
-    ).returns(T::Enumerable[Subject::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.0/expected_subject/habtm_wizards.rbi

@@ -31,14 +31,38 @@ module Subject::HABTM_Wizards::GeneratedAssociationMethods
   sig { returns(T.nilable(::Subject)) }
   def left_side; end
 
+  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Subject).void)).returns(::Subject) }
+  def build_left_side(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Subject).void)).returns(::Subject) }
+  def create_left_side(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Subject).void)).returns(::Subject) }
+  def create_left_side!(*args, &block); end
+
   sig { params(value: T.nilable(::Subject)).void }
   def left_side=(value); end
 
+  sig { returns(T.nilable(::Subject)) }
+  def reload_left_side; end
+
   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 Subject::HABTM_Wizards::CustomFinderMethods
@@ -159,7 +183,7 @@ module Subject::HABTM_Wizards::QueryMethodsReturningRelation
       load: T.nilable(T::Boolean),
       error_on_ignore: T.nilable(T::Boolean),
       block: T.nilable(T.proc.params(e: Subject::HABTM_Wizards::ActiveRecord_Relation).void)
-    ).returns(T::Enumerable[Subject::HABTM_Wizards::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 +281,7 @@ module Subject::HABTM_Wizards::QueryMethodsReturningAssociationRelation
       load: T.nilable(T::Boolean),
       error_on_ignore: T.nilable(T::Boolean),
       block: T.nilable(T.proc.params(e: Subject::HABTM_Wizards::ActiveRecord_AssociationRelation).void)
-    ).returns(T::Enumerable[Subject::HABTM_Wizards::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.0/expected_wand.rbi

@@ -152,22 +152,24 @@ module Wand::GeneratedAttributeMethods
   def wood_type?; end
 end
 
-class Wand::CoreType < T::Enum
-  enums do
-    PhoenixFeather = new(%q{phoenix_feather})
-    DragonHeartstring = new(%q{dragon_heartstring})
-    UnicornTailHair = new(%q{unicorn_tail_hair})
-    BasiliskHorn = new(%q{basilisk_horn})
-  end
-
-end
-
 module Wand::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 Wand::CustomFinderMethods
@@ -216,6 +218,16 @@ class Wand < ApplicationRecord
   sig { params(value: T.nilable(Wand::CoreType)).void }
   def typed_core_type=(value); end
 
+  class CoreType < T::Enum
+    enums do
+      PhoenixFeather = new(%q{phoenix_feather})
+      DragonHeartstring = new(%q{dragon_heartstring})
+      UnicornTailHair = new(%q{unicorn_tail_hair})
+      BasiliskHorn = new(%q{basilisk_horn})
+    end
+
+  end
+
   sig { returns(T::Array[Wand]) }
   def self.mythicals; end
 end
@@ -381,7 +393,7 @@ module Wand::QueryMethodsReturningRelation
       load: T.nilable(T::Boolean),
       error_on_ignore: T.nilable(T::Boolean),
       block: T.nilable(T.proc.params(e: Wand::ActiveRecord_Relation).void)
-    ).returns(T::Enumerable[Wand::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
@@ -479,7 +491,7 @@ module Wand::QueryMethodsReturningAssociationRelation
       load: T.nilable(T::Boolean),
       error_on_ignore: T.nilable(T::Boolean),
       block: T.nilable(T.proc.params(e: Wand::ActiveRecord_AssociationRelation).void)
-    ).returns(T::Enumerable[Wand::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.0/expected_wizard.rbi

@@ -111,6 +111,44 @@ module Wizard::ActiveRelation_WhereNot
   def not(opts, *rest); end
 end
 
+module Wizard::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 Wizard::GeneratedAttributeMethods
   sig { returns(T::Boolean) }
   def broom?; end
@@ -230,71 +268,25 @@ module Wizard::GeneratedAttributeMethods
   def updated_at?; end
 end
 
-class Wizard::Broom < T::Enum
-  enums do
-    Nimbus = new(%q{nimbus})
-    Firebolt = new(%q{firebolt})
-  end
-
-end
-
-class Wizard::EyeColor < T::Enum
-  enums do
-    Brown = new(%q{brown})
-    Green = new(%q{green})
-    Blue = new(%q{blue})
-  end
-
-end
-
-class Wizard::HairColor < T::Enum
-  enums do
-    Brown = new(%q{brown})
-    Black = new(%q{black})
-    Blonde = new(%q{blonde})
-  end
-
-end
-
-class Wizard::House < T::Enum
-  enums do
-    Gryffindor = new(%q{Gryffindor})
-    Hufflepuff = new(%q{Hufflepuff})
-    Ravenclaw = new(%q{Ravenclaw})
-    Slytherin = new(%q{Slytherin})
-  end
-
-end
-
-class Wizard::ProfessorEnum < T::Enum
-  enums do
-    SeverusSnape = new(%q{Severus Snape})
-    MinervaMcGonagall = new(%q{Minerva McGonagall})
-    PomonaSprout = new(%q{Pomona Sprout})
-    FiliusFlitwick = new(%q{Filius Flitwick})
-    Hagrid = new(%q{Hagrid})
-    AlastorMadEyeMoody = new(%q{Alastor 'Mad-Eye' Moody})
-  end
-
-end
-
-class Wizard::QuidditchPosition < T::Enum
-  enums do
-    Keeper = new(%q{keeper})
-    Seeker = new(%q{seeker})
-    Beater = new(%q{beater})
-    Chaser = new(%q{chaser})
-  end
-
-end
-
 module Wizard::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
 
@@ -316,8 +308,20 @@ module Wizard::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 Wizard::CustomFinderMethods
@@ -339,6 +343,7 @@ end
 
 class Wizard < ApplicationRecord
   include Wizard::EnumInstanceMethods
+  include Wizard::GeneratedSerializedAttributeMethods
   include Wizard::GeneratedAttributeMethods
   include Wizard::GeneratedAssociationMethods
   extend Wizard::CustomFinderMethods
@@ -452,6 +457,64 @@ class Wizard < ApplicationRecord
 
   sig { params(value: T.nilable(Wizard::QuidditchPosition)).void }
   def typed_quidditch_position=(value); end
+
+  class Broom < T::Enum
+    enums do
+      Nimbus = new(%q{nimbus})
+      Firebolt = new(%q{firebolt})
+    end
+
+  end
+
+  class EyeColor < T::Enum
+    enums do
+      Brown = new(%q{brown})
+      Green = new(%q{green})
+      Blue = new(%q{blue})
+    end
+
+  end
+
+  class HairColor < T::Enum
+    enums do
+      Brown = new(%q{brown})
+      Black = new(%q{black})
+      Blonde = new(%q{blonde})
+    end
+
+  end
+
+  class House < T::Enum
+    enums do
+      Gryffindor = new(%q{Gryffindor})
+      Hufflepuff = new(%q{Hufflepuff})
+      Ravenclaw = new(%q{Ravenclaw})
+      Slytherin = new(%q{Slytherin})
+    end
+
+  end
+
+  class ProfessorEnum < T::Enum
+    enums do
+      SeverusSnape = new(%q{Severus Snape})
+      MinervaMcGonagall = new(%q{Minerva McGonagall})
+      PomonaSprout = new(%q{Pomona Sprout})
+      FiliusFlitwick = new(%q{Filius Flitwick})
+      Hagrid = new(%q{Hagrid})
+      AlastorMadEyeMoody = new(%q{Alastor 'Mad-Eye' Moody})
+    end
+
+  end
+
+  class QuidditchPosition < T::Enum
+    enums do
+      Keeper = new(%q{keeper})
+      Seeker = new(%q{seeker})
+      Beater = new(%q{beater})
+      Chaser = new(%q{chaser})
+    end
+
+  end
 end
 
 class Wizard::ActiveRecord_Relation < ActiveRecord::Relation
@@ -741,7 +804,7 @@ module Wizard::QueryMethodsReturningRelation
       load: T.nilable(T::Boolean),
       error_on_ignore: T.nilable(T::Boolean),
       block: T.nilable(T.proc.params(e: Wizard::ActiveRecord_Relation).void)
-    ).returns(T::Enumerable[Wizard::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
@@ -839,7 +902,7 @@ module Wizard::QueryMethodsReturningAssociationRelation
       load: T.nilable(T::Boolean),
       error_on_ignore: T.nilable(T::Boolean),
       block: T.nilable(T.proc.params(e: Wizard::ActiveRecord_AssociationRelation).void)
-    ).returns(T::Enumerable[Wizard::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