tapioca 0.17.3 → 0.17.7

data/lib/tapioca/dsl/compilers/active_record_relations.rb

@@ -148,13 +148,12 @@ module Tapioca
       #   end
       # end
       # ~~~
+      #: [ConstantType = singleton(::ActiveRecord::Base)]
       class ActiveRecordRelations < Compiler
         extend T::Sig
         include Helpers::ActiveRecordConstantsHelper
         include SorbetHelper
 
-        ConstantType = type_member { { fixed: T.class_of(::ActiveRecord::Base) } }
-
         # From ActiveRecord::ConnectionAdapter::Quoting#quote, minus nil
         ID_TYPES = [
           "String",
@@ -217,6 +216,17 @@ module Tapioca
           []
         end #: Array[Symbol]
         BATCHES_METHODS = ActiveRecord::Batches.instance_methods(false) #: Array[Symbol]
+        BATCHES_METHODS_PARAMETERS = {
+          start: ["T.untyped", "nil"],
+          finish: ["T.untyped", "nil"],
+          load: ["T.untyped", "false"],
+          batch_size: ["Integer", "1000"],
+          of: ["Integer", "1000"],
+          error_on_ignore: ["T.untyped", "nil"],
+          order: ["Symbol", ":asc"],
+          cursor: ["T.untyped", "primary_key"],
+          use_ranges: ["T.untyped", "nil"],
+        } #: Hash[Symbol, [String, String]]
         CALCULATION_METHODS = ActiveRecord::Calculations.instance_methods(false) #: Array[Symbol]
         ENUMERABLE_QUERY_METHODS = [:any?, :many?, :none?, :one?] #: Array[Symbol]
         FIND_OR_CREATE_METHODS = [
@@ -826,7 +836,15 @@ module Tapioca
                 end
               end
             when :ids
-              create_common_method("ids", return_type: "Array")
+              if constant.table_exists?
+                primary_key_type = constant.type_for_attribute(constant.primary_key)
+                type = Tapioca::Dsl::Helpers::ActiveModelTypeHelper.type_for(primary_key_type)
+                type = RBIHelper.as_non_nilable_type(type)
+                create_common_method("ids", return_type: "T::Array[#{type}]")
+              else
+                create_common_method("ids", return_type: "Array")
+              end
+
             when :pick, :pluck
               create_common_method(
                 method_name,
@@ -855,102 +873,31 @@ module Tapioca
           end
 
           BATCHES_METHODS.each do |method_name|
-            case method_name
-            when :find_each
-              order = ActiveRecord::Batches.instance_method(:find_each).parameters.include?([:key, :order])
-
-              common_relation_methods_module.create_method("find_each") do |method|
-                method.add_kw_opt_param("start", "nil")
-                method.add_kw_opt_param("finish", "nil")
-                method.add_kw_opt_param("batch_size", "1000")
-                method.add_kw_opt_param("error_on_ignore", "nil")
-                method.add_kw_opt_param("order", ":asc") if order
-                method.add_block_param("block")
+            block_param, return_type, parameters = batch_method_configs(method_name)
+            next if block_param.nil? || return_type.nil? || parameters.nil?
 
-                method.add_sig do |sig|
-                  sig.add_param("start", "T.untyped")
-                  sig.add_param("finish", "T.untyped")
-                  sig.add_param("batch_size", "Integer")
-                  sig.add_param("error_on_ignore", "T.untyped")
-                  sig.add_param("order", "Symbol") if order
-                  sig.add_param("block", "T.proc.params(object: #{constant_name}).void")
-                  sig.return_type = "void"
-                end
+            common_relation_methods_module.create_method(method_name.to_s) do |method|
+              parameters.each do |name, (style, _type, default)|
+                # The style is always "key", but this is a safeguard to prevent confusing errors in the future.
+                raise "Unexpected style #{style} for #{name}" unless style == :key
 
-                method.add_sig do |sig|
-                  sig.add_param("start", "T.untyped")
-                  sig.add_param("finish", "T.untyped")
-                  sig.add_param("batch_size", "Integer")
-                  sig.add_param("error_on_ignore", "T.untyped")
-                  sig.add_param("order", "Symbol") if order
-                  sig.return_type = "T::Enumerator[#{constant_name}]"
-                end
+                method.add_kw_opt_param(name, T.must(default))
               end
-            when :find_in_batches
-              order = ActiveRecord::Batches.instance_method(:find_in_batches).parameters.include?([:key, :order])
-              common_relation_methods_module.create_method("find_in_batches") do |method|
-                method.add_kw_opt_param("start", "nil")
-                method.add_kw_opt_param("finish", "nil")
-                method.add_kw_opt_param("batch_size", "1000")
-                method.add_kw_opt_param("error_on_ignore", "nil")
-                method.add_kw_opt_param("order", ":asc") if order
-                method.add_block_param("block")
-
-                method.add_sig do |sig|
-                  sig.add_param("start", "T.untyped")
-                  sig.add_param("finish", "T.untyped")
-                  sig.add_param("batch_size", "Integer")
-                  sig.add_param("error_on_ignore", "T.untyped")
-                  sig.add_param("order", "Symbol") if order
-                  sig.add_param("block", "T.proc.params(object: T::Array[#{constant_name}]).void")
-                  sig.return_type = "void"
-                end
+              method.add_block_param("block")
 
-                method.add_sig do |sig|
-                  sig.add_param("start", "T.untyped")
-                  sig.add_param("finish", "T.untyped")
-                  sig.add_param("batch_size", "Integer")
-                  sig.add_param("error_on_ignore", "T.untyped")
-                  sig.add_param("order", "Symbol") if order
-                  sig.return_type = "T::Enumerator[T::Enumerator[#{constant_name}]]"
+              method.add_sig do |sig|
+                parameters.each do |name, (_style, type, _default)|
+                  sig.add_param(name, type)
                 end
+                sig.add_param("block", "T.proc.params(object: #{block_param}).void")
+                sig.return_type = "void"
               end
-            when :in_batches
-              order = ActiveRecord::Batches.instance_method(:in_batches).parameters.include?([:key, :order])
-              use_ranges = ActiveRecord::Batches.instance_method(:in_batches).parameters.include?([:key, :use_ranges])
-
-              common_relation_methods_module.create_method("in_batches") do |method|
-                method.add_kw_opt_param("of", "1000")
-                method.add_kw_opt_param("start", "nil")
-                method.add_kw_opt_param("finish", "nil")
-                method.add_kw_opt_param("load", "false")
-                method.add_kw_opt_param("error_on_ignore", "nil")
-                method.add_kw_opt_param("order", ":asc") if order
-                method.add_kw_opt_param("use_ranges", "nil") if use_ranges
-                method.add_block_param("block")
 
-                method.add_sig do |sig|
-                  sig.add_param("of", "Integer")
-                  sig.add_param("start", "T.untyped")
-                  sig.add_param("finish", "T.untyped")
-                  sig.add_param("load", "T.untyped")
-                  sig.add_param("error_on_ignore", "T.untyped")
-                  sig.add_param("order", "Symbol") if order
-                  sig.add_param("use_ranges", "T.untyped") if use_ranges
-                  sig.add_param("block", "T.proc.params(object: #{RelationClassName}).void")
-                  sig.return_type = "void"
-                end
-
-                method.add_sig do |sig|
-                  sig.add_param("of", "Integer")
-                  sig.add_param("start", "T.untyped")
-                  sig.add_param("finish", "T.untyped")
-                  sig.add_param("load", "T.untyped")
-                  sig.add_param("error_on_ignore", "T.untyped")
-                  sig.add_param("order", "Symbol") if order
-                  sig.add_param("use_ranges", "T.untyped") if use_ranges
-                  sig.return_type = "::ActiveRecord::Batches::BatchEnumerator"
+              method.add_sig do |sig|
+                parameters.each do |name, (_style, type, _default)|
+                  sig.add_param(name, type)
                 end
+                sig.return_type = return_type
               end
             end
           end
@@ -1029,6 +976,31 @@ module Tapioca
           end
         end
 
+        #: (Symbol) -> [String, String, Hash[String, [Symbol, String, String?]]]?
+        def batch_method_configs(method_name)
+          block_param, return_type = case method_name
+          when :find_each
+            [constant_name, "T::Enumerator[#{constant_name}]"]
+          when :find_in_batches
+            ["T::Array[#{constant_name}]", "T::Enumerator[T::Enumerator[#{constant_name}]]"]
+          when :in_batches
+            [RelationClassName, "::ActiveRecord::Batches::BatchEnumerator"]
+          else
+            return
+          end
+
+          parameters = {}
+
+          ActiveRecord::Batches.instance_method(method_name).parameters.each do |style, name|
+            type, default = BATCHES_METHODS_PARAMETERS[name]
+            next if type.nil?
+
+            parameters[name.to_s] = [style, type, default]
+          end
+
+          [block_param, return_type, parameters]
+        end
+
         #: ((Symbol | String) name, ?parameters: Array[RBI::TypedParam], ?return_type: String?) -> void
         def create_common_method(name, parameters: [], return_type: nil)
           common_relation_methods_module.create_method(

data/lib/tapioca/dsl/compilers/active_record_scope.rb

@@ -38,12 +38,11 @@ module Tapioca
       #   end
       # end
       # ~~~
+      #: [ConstantType = singleton(::ActiveRecord::Base)]
       class ActiveRecordScope < Compiler
         extend T::Sig
         include Helpers::ActiveRecordConstantsHelper
 
-        ConstantType = type_member { { fixed: T.class_of(::ActiveRecord::Base) } }
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/active_record_secure_token.rb

@@ -32,12 +32,11 @@ module Tapioca
       #   def regenerate_auth_token; end
       # end
       # ~~~
+      #: [ConstantType = (singleton(ActiveRecord::Base) & Extensions::ActiveRecord)]
       class ActiveRecordSecureToken < Compiler
         extend T::Sig
         include Helpers::ActiveRecordConstantsHelper
 
-        ConstantType = type_member { { fixed: T.all(T.class_of(ActiveRecord::Base), Extensions::ActiveRecord) } }
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/active_record_store.rb

@@ -78,12 +78,11 @@ module Tapioca
       #   end
       # end
       # ~~~
+      #: [ConstantType = (singleton(ActiveRecord::Base) & Extensions::ActiveRecord)]
       class ActiveRecordStore < Compiler
         extend T::Sig
         include Helpers::ActiveRecordConstantsHelper
 
-        ConstantType = type_member { { fixed: T.all(T.class_of(ActiveRecord::Base), Extensions::ActiveRecord) } }
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/active_record_typed_store.rb

@@ -81,11 +81,10 @@ module Tapioca
       #   end
       # end
       # ~~~
+      #: [ConstantType = singleton(::ActiveRecord::Base)]
       class ActiveRecordTypedStore < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.class_of(::ActiveRecord::Base) } }
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/active_resource.rb

@@ -54,11 +54,10 @@ module Tapioca
       #   def year?; end
       # end
       # ~~~
+      #: [ConstantType = singleton(::ActiveResource::Base)]
       class ActiveResource < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.class_of(::ActiveResource::Base) } }
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/active_storage.rb

@@ -38,18 +38,10 @@ module Tapioca
       #   def photo=(attachable); end
       # end
       # ~~~
+      #: [ConstantType = (Module & ::ActiveStorage::Reflection::ActiveRecordExtensions::ClassMethods)]
       class ActiveStorage < Compiler
         extend T::Sig
 
-        ConstantType = type_member do
-          {
-            fixed: T.all(
-              Module,
-              ::ActiveStorage::Reflection::ActiveRecordExtensions::ClassMethods,
-            ),
-          }
-        end
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/active_support_concern.rb

@@ -37,11 +37,10 @@ module Tapioca
       #   mixes_in_class_methods(::Foo::ClassMethods)
       # end
       # ~~~
+      #: [ConstantType = Module]
       class ActiveSupportConcern < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: Module } }
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/active_support_current_attributes.rb

@@ -59,11 +59,10 @@ module Tapioca
       #   end
       # end
       # ~~~
+      #: [ConstantType = singleton(::ActiveSupport::CurrentAttributes)]
       class ActiveSupportCurrentAttributes < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.class_of(::ActiveSupport::CurrentAttributes) } }
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/active_support_time_ext.rb

@@ -34,11 +34,10 @@ module Tapioca
       #   end
       # end
       # ```
+      #: [ConstantType = singleton(::Time)]
       class ActiveSupportTimeExt < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.class_of(::Time) } }
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/config.rb

@@ -40,13 +40,12 @@ module Tapioca
       #   def github=(value); end
       # end
       # ```
+      #: [ConstantType = Module]
       class Config < Compiler
         extend T::Sig
 
         CONFIG_OPTIONS_SUFFIX = "ConfigOptions"
 
-        ConstantType = type_member { { fixed: Module } }
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/frozen_record.rb

@@ -58,11 +58,10 @@ module Tapioca
       #   end
       # end
       # ~~~
+      #: [ConstantType = (singleton(::FrozenRecord::Base) & Extensions::FrozenRecord)]
       class FrozenRecord < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.all(T.class_of(::FrozenRecord::Base), Extensions::FrozenRecord) } }
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/graphql_input_object.rb

@@ -34,11 +34,10 @@ module Tapioca
       #   def post_id; end
       # end
       # ~~~
+      #: [ConstantType = singleton(GraphQL::Schema::InputObject)]
       class GraphqlInputObject < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.class_of(GraphQL::Schema::InputObject) } }
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/graphql_mutation.rb

@@ -35,11 +35,10 @@ module Tapioca
       #   def resolve(body:, post_id:); end
       # end
       # ~~~
+      #: [ConstantType = singleton(GraphQL::Schema::Mutation)]
       class GraphqlMutation < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.class_of(GraphQL::Schema::Mutation) } }
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/identity_cache.rb

@@ -55,13 +55,12 @@ module Tapioca
       #   def fetch_by_title_and_review_date(title, review_date, includes: nil); end
       # end
       # ~~~
+      #: [ConstantType = singleton(::ActiveRecord::Base)]
       class IdentityCache < Compiler
         extend T::Sig
 
         COLLECTION_TYPE = ->(type) { "T::Array[::#{type}]" } #: ^((Module | String) type) -> String
 
-        ConstantType = type_member { { fixed: T.class_of(::ActiveRecord::Base) } }
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/json_api_client_resource.rb

@@ -79,11 +79,10 @@ module Tapioca
       #   end
       # end
       # ~~~
+      #: [ConstantType = singleton(::JsonApiClient::Resource)]
       class JsonApiClientResource < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.class_of(::JsonApiClient::Resource) } }
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/kredis.rb

@@ -63,13 +63,10 @@ module Tapioca
       #   end
       # end
       # ~~~
+      #: [ConstantType = (Class[::Kredis::Attributes] & ::Kredis::Attributes::ClassMethods & Extensions::Kredis)]
       class Kredis < Compiler
         extend T::Sig
 
-        ConstantType = type_member do
-          { fixed: T.all(T::Class[::Kredis::Attributes], ::Kredis::Attributes::ClassMethods, Extensions::Kredis) }
-        end
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/mixed_in_class_attributes.rb

@@ -44,11 +44,10 @@ module Tapioca
       #   end
       # end
       # ~~~
+      #: [ConstantType = Module]
       class MixedInClassAttributes < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: Module } }
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/protobuf.rb

@@ -64,6 +64,7 @@ module Tapioca
       # ~~~
       # --ignore=/path/to/proto/cart_pb.rb
       # ~~~
+      #: [ConstantType = Class[top]]
       class Protobuf < Compiler
         class Field < T::Struct
           prop :name, String
@@ -74,8 +75,6 @@ module Tapioca
 
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T::Class[T.anything] } }
-
         FIELD_RE = /^[a-z_][a-zA-Z0-9_]*$/
 
         # @override

data/lib/tapioca/dsl/compilers/rails_generators.rb

@@ -33,13 +33,12 @@ module Tapioca
       #   def skip_comments; end
       # end
       # ~~~
+      #: [ConstantType = singleton(::Rails::Generators::Base)]
       class RailsGenerators < Compiler
         extend T::Sig
 
         BUILT_IN_MATCHER = /::(ActionMailbox|ActionText|ActiveRecord|Rails)::Generators/
 
-        ConstantType = type_member { { fixed: T.class_of(::Rails::Generators::Base) } }
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/sidekiq_worker.rb

@@ -41,11 +41,10 @@ module Tapioca
       # as accepted values for the `interval` parameter:
       # * `self.perform_at` will also accept a `ActiveSupport::TimeWithZone` value
       # * `self.perform_in` will also accept a `ActiveSupport::Duration` value
+      #: [ConstantType = singleton(::Sidekiq::Worker)]
       class SidekiqWorker < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.class_of(::Sidekiq::Worker) } }
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/smart_properties.rb

@@ -29,36 +29,39 @@ module Tapioca
       # # post.rbi
       # # typed: true
       # class Post
-      #   sig { returns(T.nilable(::String)) }
-      #   def title; end
+      #   include SmartPropertiesGeneratedMethods
       #
-      #   sig { params(title: T.nilable(::String)).returns(T.nilable(::String)) }
-      #   def title=(title); end
+      #   module SmartPropertiesGeneratedMethods
+      #     sig { returns(T.nilable(::String)) }
+      #     def title; end
       #
-      #   sig { returns(::String) }
-      #   def description; end
+      #     sig { params(title: T.nilable(::String)).returns(T.nilable(::String)) }
+      #     def title=(title); end
       #
-      #   sig { params(description: ::String).returns(::String) }
-      #   def description=(description); end
+      #     sig { returns(::String) }
+      #     def description; end
       #
-      #   sig { returns(T.nilable(T::Boolean)) }
-      #   def published?; end
+      #     sig { params(description: ::String).returns(::String) }
+      #     def description=(description); end
       #
-      #   sig { params(published: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
-      #   def published=(published); end
+      #     sig { returns(T.nilable(T::Boolean)) }
+      #     def published?; end
       #
-      #   sig { returns(T.nilable(T::Boolean)) }
-      #   def enabled; end
+      #     sig { params(published: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
+      #     def published=(published); end
       #
-      #   sig { params(enabled: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
-      #   def enabled=(enabled); end
+      #     sig { returns(T.nilable(T::Boolean)) }
+      #     def enabled; end
+      #
+      #     sig { params(enabled: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
+      #     def enabled=(enabled); end
+      #   end
       # end
       # ~~~
+      #: [ConstantType = singleton(::SmartProperties)]
       class SmartProperties < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.class_of(::SmartProperties) } }
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/state_machines.rb

@@ -109,11 +109,10 @@ module Tapioca
       #   end
       # end
       # ~~~
+      #: [ConstantType = (Module & ::StateMachines::ClassMethods)]
       class StateMachines < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.all(Module, ::StateMachines::ClassMethods) } }
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/url_helpers.rb

@@ -78,11 +78,10 @@ module Tapioca
       #   include GeneratedUrlHelpersModule
       # end
       # ~~~
+      #: [ConstantType = Module]
       class UrlHelpers < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: Module } }
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/pipeline.rb

@@ -60,7 +60,7 @@ module Tapioca
             No classes/modules can be matched for RBI generation.
             Please check that the requested classes/modules include processable DSL methods.
           ERROR
-          raise Thor::Error, ""
+          raise Tapioca::Error, ""
         end
 
         if defined?(::ActiveRecord::Base) && constants_to_process.any? { |c| ::ActiveRecord::Base > c }
@@ -82,7 +82,7 @@ module Tapioca
             report_error(msg)
           end
 
-          raise Thor::Error, ""
+          raise Tapioca::Error, ""
         end
 
         result.compact

data/lib/tapioca/gem/events.rb

@@ -3,11 +3,9 @@
 
 module Tapioca
   module Gem
+    # @abstract
     class Event
       extend T::Sig
-      extend T::Helpers
-
-      abstract!
     end
 
     class SymbolFound < Event
@@ -57,12 +55,10 @@ module Tapioca
       end
     end
 
+    # @abstract
     class NodeAdded < Event
-      extend T::Helpers
       extend T::Sig
 
-      abstract!
-
       #: String
       attr_reader :symbol
 

data/lib/tapioca/gem/listeners/base.rb

@@ -4,12 +4,9 @@
 module Tapioca
   module Gem
     module Listeners
+      # @abstract
       class Base
         extend T::Sig
-        extend T::Helpers
-
-        abstract!
-
         #: (Pipeline pipeline) -> void
         def initialize(pipeline)
           @pipeline = pipeline

data/lib/tapioca/helpers/cli_helper.rb

@@ -2,12 +2,9 @@
 # frozen_string_literal: true
 
 module Tapioca
+  # @requires_ancestor: Thor::Shell
   module CliHelper
     extend T::Sig
-    extend T::Helpers
-
-    requires_ancestor { Thor::Shell }
-
     #: (?String message, *(Symbol | Array[Symbol]) color) -> void
     def say_error(message = "", *color)
       # Thor has its own `say_error` now, but it has two problems: