sorbet-rails 0.5.8.1 → 0.5.9

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

@@ -315,83 +315,6 @@ class ActiveRecord::InternalMetadata::ActiveRecord_Relation < ActiveRecord::Rela
 
   sig { params(args: T.untyped, block: T.nilable(T.proc.void)).returns(ActiveRecord::InternalMetadata::ActiveRecord_Relation) }
   def extending(*args, &block); end
-
-  sig { params(args: T.untyped).returns(ActiveRecord::InternalMetadata) }
-  def find(*args); end
-
-  sig { params(args: T.untyped).returns(T.nilable(ActiveRecord::InternalMetadata)) }
-  def find_by(*args); end
-
-  sig { params(args: T.untyped).returns(ActiveRecord::InternalMetadata) }
-  def find_by!(*args); end
-
-  sig { returns(T.nilable(ActiveRecord::InternalMetadata)) }
-  def first; end
-
-  sig { returns(ActiveRecord::InternalMetadata) }
-  def first!; end
-
-  sig { returns(T.nilable(ActiveRecord::InternalMetadata)) }
-  def second; end
-
-  sig { returns(ActiveRecord::InternalMetadata) }
-  def second!; end
-
-  sig { returns(T.nilable(ActiveRecord::InternalMetadata)) }
-  def third; end
-
-  sig { returns(ActiveRecord::InternalMetadata) }
-  def third!; end
-
-  sig { returns(T.nilable(ActiveRecord::InternalMetadata)) }
-  def third_to_last; end
-
-  sig { returns(ActiveRecord::InternalMetadata) }
-  def third_to_last!; end
-
-  sig { returns(T.nilable(ActiveRecord::InternalMetadata)) }
-  def second_to_last; end
-
-  sig { returns(ActiveRecord::InternalMetadata) }
-  def second_to_last!; end
-
-  sig { returns(T.nilable(ActiveRecord::InternalMetadata)) }
-  def last; end
-
-  sig { returns(ActiveRecord::InternalMetadata) }
-  def last!; end
-
-  sig { params(conditions: T.untyped).returns(T::Boolean) }
-  def exists?(conditions = nil); end
-
-  sig { params(args: T.untyped).returns(T::Boolean) }
-  def any?(*args); end
-
-  sig { params(args: T.untyped).returns(T::Boolean) }
-  def many?(*args); end
-
-  sig { params(args: T.untyped).returns(T::Boolean) }
-  def none?(*args); end
-
-  sig { params(args: T.untyped).returns(T::Boolean) }
-  def one?(*args); end
-
-  sig { override.params(block: T.proc.params(e: ActiveRecord::InternalMetadata).void).returns(T::Array[ActiveRecord::InternalMetadata]) }
-  def each(&block); end
-
-  sig { params(level: T.nilable(Integer)).returns(T::Array[ActiveRecord::InternalMetadata]) }
-  def flatten(level); end
-
-  sig { returns(T::Array[ActiveRecord::InternalMetadata]) }
-  def to_a; end
-
-  sig do
-    type_parameters(:U).params(
-        blk: T.proc.params(arg0: Elem).returns(T.type_parameter(:U)),
-    )
-    .returns(T::Array[T.type_parameter(:U)])
-  end
-  def map(&blk); end
 end
 
 class ActiveRecord::InternalMetadata::ActiveRecord_AssociationRelation < ActiveRecord::AssociationRelation

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

@@ -274,83 +274,6 @@ class Potion::ActiveRecord_Relation < ActiveRecord::Relation
 
   sig { params(args: T.untyped, block: T.nilable(T.proc.void)).returns(Potion::ActiveRecord_Relation) }
   def extending(*args, &block); end
-
-  sig { params(args: T.untyped).returns(Potion) }
-  def find(*args); end
-
-  sig { params(args: T.untyped).returns(T.nilable(Potion)) }
-  def find_by(*args); end
-
-  sig { params(args: T.untyped).returns(Potion) }
-  def find_by!(*args); end
-
-  sig { returns(T.nilable(Potion)) }
-  def first; end
-
-  sig { returns(Potion) }
-  def first!; end
-
-  sig { returns(T.nilable(Potion)) }
-  def second; end
-
-  sig { returns(Potion) }
-  def second!; end
-
-  sig { returns(T.nilable(Potion)) }
-  def third; end
-
-  sig { returns(Potion) }
-  def third!; end
-
-  sig { returns(T.nilable(Potion)) }
-  def third_to_last; end
-
-  sig { returns(Potion) }
-  def third_to_last!; end
-
-  sig { returns(T.nilable(Potion)) }
-  def second_to_last; end
-
-  sig { returns(Potion) }
-  def second_to_last!; end
-
-  sig { returns(T.nilable(Potion)) }
-  def last; end
-
-  sig { returns(Potion) }
-  def last!; end
-
-  sig { params(conditions: T.untyped).returns(T::Boolean) }
-  def exists?(conditions = nil); end
-
-  sig { params(args: T.untyped).returns(T::Boolean) }
-  def any?(*args); end
-
-  sig { params(args: T.untyped).returns(T::Boolean) }
-  def many?(*args); end
-
-  sig { params(args: T.untyped).returns(T::Boolean) }
-  def none?(*args); end
-
-  sig { params(args: T.untyped).returns(T::Boolean) }
-  def one?(*args); end
-
-  sig { override.params(block: T.proc.params(e: Potion).void).returns(T::Array[Potion]) }
-  def each(&block); end
-
-  sig { params(level: T.nilable(Integer)).returns(T::Array[Potion]) }
-  def flatten(level); end
-
-  sig { returns(T::Array[Potion]) }
-  def to_a; end
-
-  sig do
-    type_parameters(:U).params(
-        blk: T.proc.params(arg0: Elem).returns(T.type_parameter(:U)),
-    )
-    .returns(T::Array[T.type_parameter(:U)])
-  end
-  def map(&blk); end
 end
 
 class Potion::ActiveRecord_AssociationRelation < ActiveRecord::AssociationRelation

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

@@ -7,6 +7,28 @@ module Robe::ActiveRelation_WhereNot
   def not(opts, *rest); end
 end
 
+module Robe::GeneratedAttributeMethods
+  extend T::Sig
+
+  sig { returns(Integer) }
+  def id; end
+
+  sig { params(value: T.any(Integer, Float, ActiveSupport::Duration)).void }
+  def id=(value); end
+
+  sig { returns(T::Boolean) }
+  def id?; end
+
+  sig { returns(T.nilable(Integer)) }
+  def wizard_id; end
+
+  sig { params(value: T.nilable(T.any(Integer, Float, ActiveSupport::Duration))).void }
+  def wizard_id=(value); end
+
+  sig { returns(T::Boolean) }
+  def wizard_id?; end
+end
+
 module Robe::GeneratedAssociationMethods
   extend T::Sig
 
@@ -35,6 +57,7 @@ module Robe::CustomFinderMethods
 end
 
 class Robe < ApplicationRecord
+  include Robe::GeneratedAttributeMethods
   include Robe::GeneratedAssociationMethods
   extend Robe::CustomFinderMethods
   extend T::Sig
@@ -285,83 +308,6 @@ class Robe::ActiveRecord_Relation < ActiveRecord::Relation
 
   sig { params(args: T.untyped, block: T.nilable(T.proc.void)).returns(Robe::ActiveRecord_Relation) }
   def extending(*args, &block); end
-
-  sig { params(args: T.untyped).returns(Robe) }
-  def find(*args); end
-
-  sig { params(args: T.untyped).returns(T.nilable(Robe)) }
-  def find_by(*args); end
-
-  sig { params(args: T.untyped).returns(Robe) }
-  def find_by!(*args); end
-
-  sig { returns(T.nilable(Robe)) }
-  def first; end
-
-  sig { returns(Robe) }
-  def first!; end
-
-  sig { returns(T.nilable(Robe)) }
-  def second; end
-
-  sig { returns(Robe) }
-  def second!; end
-
-  sig { returns(T.nilable(Robe)) }
-  def third; end
-
-  sig { returns(Robe) }
-  def third!; end
-
-  sig { returns(T.nilable(Robe)) }
-  def third_to_last; end
-
-  sig { returns(Robe) }
-  def third_to_last!; end
-
-  sig { returns(T.nilable(Robe)) }
-  def second_to_last; end
-
-  sig { returns(Robe) }
-  def second_to_last!; end
-
-  sig { returns(T.nilable(Robe)) }
-  def last; end
-
-  sig { returns(Robe) }
-  def last!; end
-
-  sig { params(conditions: T.untyped).returns(T::Boolean) }
-  def exists?(conditions = nil); end
-
-  sig { params(args: T.untyped).returns(T::Boolean) }
-  def any?(*args); end
-
-  sig { params(args: T.untyped).returns(T::Boolean) }
-  def many?(*args); end
-
-  sig { params(args: T.untyped).returns(T::Boolean) }
-  def none?(*args); end
-
-  sig { params(args: T.untyped).returns(T::Boolean) }
-  def one?(*args); end
-
-  sig { override.params(block: T.proc.params(e: Robe).void).returns(T::Array[Robe]) }
-  def each(&block); end
-
-  sig { params(level: T.nilable(Integer)).returns(T::Array[Robe]) }
-  def flatten(level); end
-
-  sig { returns(T::Array[Robe]) }
-  def to_a; end
-
-  sig do
-    type_parameters(:U).params(
-        blk: T.proc.params(arg0: Elem).returns(T.type_parameter(:U)),
-    )
-    .returns(T::Array[T.type_parameter(:U)])
-  end
-  def map(&blk); end
 end
 
 class Robe::ActiveRecord_AssociationRelation < ActiveRecord::AssociationRelation

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

@@ -9,6 +9,10 @@ module ActionView::Helpers
   include GeneratedUrlHelpers
 end
 
+class ActionMailer::Base
+  include GeneratedUrlHelpers
+end
+
 module GeneratedUrlHelpers
   # Sigs for route /test/index(.:format)
   sig { params(args: T.untyped, kwargs: T.untyped).returns(String) }

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

@@ -288,83 +288,6 @@ class ActiveRecord::SchemaMigration::ActiveRecord_Relation < ActiveRecord::Relat
 
   sig { params(args: T.untyped, block: T.nilable(T.proc.void)).returns(ActiveRecord::SchemaMigration::ActiveRecord_Relation) }
   def extending(*args, &block); end
-
-  sig { params(args: T.untyped).returns(ActiveRecord::SchemaMigration) }
-  def find(*args); end
-
-  sig { params(args: T.untyped).returns(T.nilable(ActiveRecord::SchemaMigration)) }
-  def find_by(*args); end
-
-  sig { params(args: T.untyped).returns(ActiveRecord::SchemaMigration) }
-  def find_by!(*args); end
-
-  sig { returns(T.nilable(ActiveRecord::SchemaMigration)) }
-  def first; end
-
-  sig { returns(ActiveRecord::SchemaMigration) }
-  def first!; end
-
-  sig { returns(T.nilable(ActiveRecord::SchemaMigration)) }
-  def second; end
-
-  sig { returns(ActiveRecord::SchemaMigration) }
-  def second!; end
-
-  sig { returns(T.nilable(ActiveRecord::SchemaMigration)) }
-  def third; end
-
-  sig { returns(ActiveRecord::SchemaMigration) }
-  def third!; end
-
-  sig { returns(T.nilable(ActiveRecord::SchemaMigration)) }
-  def third_to_last; end
-
-  sig { returns(ActiveRecord::SchemaMigration) }
-  def third_to_last!; end
-
-  sig { returns(T.nilable(ActiveRecord::SchemaMigration)) }
-  def second_to_last; end
-
-  sig { returns(ActiveRecord::SchemaMigration) }
-  def second_to_last!; end
-
-  sig { returns(T.nilable(ActiveRecord::SchemaMigration)) }
-  def last; end
-
-  sig { returns(ActiveRecord::SchemaMigration) }
-  def last!; end
-
-  sig { params(conditions: T.untyped).returns(T::Boolean) }
-  def exists?(conditions = nil); end
-
-  sig { params(args: T.untyped).returns(T::Boolean) }
-  def any?(*args); end
-
-  sig { params(args: T.untyped).returns(T::Boolean) }
-  def many?(*args); end
-
-  sig { params(args: T.untyped).returns(T::Boolean) }
-  def none?(*args); end
-
-  sig { params(args: T.untyped).returns(T::Boolean) }
-  def one?(*args); end
-
-  sig { override.params(block: T.proc.params(e: ActiveRecord::SchemaMigration).void).returns(T::Array[ActiveRecord::SchemaMigration]) }
-  def each(&block); end
-
-  sig { params(level: T.nilable(Integer)).returns(T::Array[ActiveRecord::SchemaMigration]) }
-  def flatten(level); end
-
-  sig { returns(T::Array[ActiveRecord::SchemaMigration]) }
-  def to_a; end
-
-  sig do
-    type_parameters(:U).params(
-        blk: T.proc.params(arg0: Elem).returns(T.type_parameter(:U)),
-    )
-    .returns(T::Array[T.type_parameter(:U)])
-  end
-  def map(&blk); end
 end
 
 class ActiveRecord::SchemaMigration::ActiveRecord_AssociationRelation < ActiveRecord::AssociationRelation