tapioca 0.16.9 → 0.17.7

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

@@ -148,33 +148,30 @@ 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 = T.let(
-          [
-            "String",
-            "Symbol",
-            "::ActiveSupport::Multibyte::Chars",
-            "T::Boolean",
-            "BigDecimal",
-            "Numeric",
-            "::ActiveRecord::Type::Binary::Data",
-            "::ActiveRecord::Type::Time::Value",
-            "Date",
-            "Time",
-            "::ActiveSupport::Duration",
-            "T::Class[T.anything]",
-          ].to_set.freeze,
-          T::Set[String],
-        )
-
-        sig { override.void }
+        ID_TYPES = [
+          "String",
+          "Symbol",
+          "::ActiveSupport::Multibyte::Chars",
+          "T::Boolean",
+          "BigDecimal",
+          "Numeric",
+          "::ActiveRecord::Type::Binary::Data",
+          "::ActiveRecord::Type::Time::Value",
+          "Date",
+          "Time",
+          "::ActiveSupport::Duration",
+          "T::Class[T.anything]",
+        ].to_set.freeze #: Set[String]
+
+        # @override
+        #: -> void
         def decorate
           create_classes_and_includes
           create_common_methods
@@ -185,104 +182,97 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             ActiveRecord::Base.descendants.reject(&:abstract_class?)
           end
         end
 
-        ASSOCIATION_METHODS = T.let(
-          ::ActiveRecord::AssociationRelation.instance_methods -
-            ::ActiveRecord::Relation.instance_methods,
-          T::Array[Symbol],
-        )
-        COLLECTION_PROXY_METHODS = T.let(
-          ::ActiveRecord::Associations::CollectionProxy.instance_methods -
-            ::ActiveRecord::AssociationRelation.instance_methods,
-          T::Array[Symbol],
-        )
-
-        QUERY_METHODS = T.let(
-          begin
-            # Grab all Query methods
-            query_methods = ActiveRecord::QueryMethods.instance_methods(false)
-            # Grab all Spawn methods
-            query_methods |= ActiveRecord::SpawnMethods.instance_methods(false)
-            # Remove the ones we know are private API
-            query_methods -= [:all, :arel, :build_subquery, :construct_join_dependency, :extensions, :spawn]
-            # Remove the methods that ...
-            query_methods
-              .grep_v(/_clause$/) # end with "_clause"
-              .grep_v(/_values?$/) # end with "_value" or "_values"
-              .grep_v(/=$/) # end with "=""
-              .grep_v(/(?<!uniq)!$/) # end with "!" except for "uniq!"
-          end,
-          T::Array[Symbol],
-        )
-        WHERE_CHAIN_QUERY_METHODS = T.let(
-          ActiveRecord::QueryMethods::WhereChain.instance_methods(false),
-          T::Array[Symbol],
-        )
-        FINDER_METHODS = T.let(ActiveRecord::FinderMethods.instance_methods(false), T::Array[Symbol])
-        SIGNED_FINDER_METHODS = T.let(
-          defined?(ActiveRecord::SignedId) ? ActiveRecord::SignedId::ClassMethods.instance_methods(false) : [],
-          T::Array[Symbol],
-        )
-        BATCHES_METHODS = T.let(ActiveRecord::Batches.instance_methods(false), T::Array[Symbol])
-        CALCULATION_METHODS = T.let(ActiveRecord::Calculations.instance_methods(false), T::Array[Symbol])
-        ENUMERABLE_QUERY_METHODS = T.let([:any?, :many?, :none?, :one?], T::Array[Symbol])
-        FIND_OR_CREATE_METHODS = T.let(
-          [:find_or_create_by, :find_or_create_by!, :find_or_initialize_by, :create_or_find_by, :create_or_find_by!],
-          T::Array[Symbol],
-        )
-        BUILDER_METHODS = T.let([:new, :create, :create!, :build], T::Array[Symbol])
-        TO_ARRAY_METHODS = T.let([:to_ary, :to_a], T::Array[Symbol])
+        ASSOCIATION_METHODS = ::ActiveRecord::AssociationRelation.instance_methods -
+          ::ActiveRecord::Relation.instance_methods #: Array[Symbol]
+        COLLECTION_PROXY_METHODS = ::ActiveRecord::Associations::CollectionProxy.instance_methods -
+          ::ActiveRecord::AssociationRelation.instance_methods #: Array[Symbol]
+
+        QUERY_METHODS = begin
+          # Grab all Query methods
+          query_methods = ActiveRecord::QueryMethods.instance_methods(false)
+          # Grab all Spawn methods
+          query_methods |= ActiveRecord::SpawnMethods.instance_methods(false)
+          # Remove the ones we know are private API
+          query_methods -= [:all, :arel, :build_subquery, :construct_join_dependency, :extensions, :spawn]
+          # Remove the methods that ...
+          query_methods
+            .grep_v(/_clause$/) # end with "_clause"
+            .grep_v(/_values?$/) # end with "_value" or "_values"
+            .grep_v(/=$/) # end with "=""
+            .grep_v(/(?<!uniq)!$/) # end with "!" except for "uniq!"
+        end #: Array[Symbol]
+        WHERE_CHAIN_QUERY_METHODS = ActiveRecord::QueryMethods::WhereChain.instance_methods(false) #: Array[Symbol]
+        FINDER_METHODS = ActiveRecord::FinderMethods.instance_methods(false) #: Array[Symbol]
+        SIGNED_FINDER_METHODS = if defined?(ActiveRecord::SignedId)
+          ActiveRecord::SignedId::ClassMethods.instance_methods(false)
+        else
+          []
+        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 = [
+          :find_or_create_by,
+          :find_or_create_by!,
+          :find_or_initialize_by,
+          :create_or_find_by,
+          :create_or_find_by!,
+        ] #: Array[Symbol]
+        BUILDER_METHODS = [:new, :create, :create!, :build] #: Array[Symbol]
+        TO_ARRAY_METHODS = [:to_ary, :to_a] #: Array[Symbol]
 
         private
 
-        sig { returns(RBI::Scope) }
+        #: -> RBI::Scope
         def model
-          @model ||= T.let(
-            root.create_path(constant),
-            T.nilable(RBI::Scope),
-          )
+          @model ||= root.create_path(constant) #: RBI::Scope?
         end
 
-        sig { returns(RBI::Scope) }
+        #: -> RBI::Scope
         def relation_methods_module
-          @relation_methods_module ||= T.let(
-            model.create_module(RelationMethodsModuleName),
-            T.nilable(RBI::Scope),
-          )
+          @relation_methods_module ||= model.create_module(RelationMethodsModuleName) #: RBI::Scope?
         end
 
-        sig { returns(RBI::Scope) }
+        #: -> RBI::Scope
         def association_relation_methods_module
-          @association_relation_methods_module ||= T.let(
-            model.create_module(AssociationRelationMethodsModuleName),
-            T.nilable(RBI::Scope),
-          )
+          @association_relation_methods_module ||=
+            model.create_module(AssociationRelationMethodsModuleName) #: RBI::Scope?
         end
 
-        sig { returns(RBI::Scope) }
+        #: -> RBI::Scope
         def common_relation_methods_module
-          @common_relation_methods_module ||= T.let(
-            model.create_module(CommonRelationMethodsModuleName),
-            T.nilable(RBI::Scope),
-          )
+          @common_relation_methods_module ||= model.create_module(CommonRelationMethodsModuleName) #: RBI::Scope?
         end
 
-        sig { returns(String) }
+        #: -> String
         def constant_name
-          @constant_name ||= T.let(T.must(qualified_name_of(constant)), T.nilable(String))
+          @constant_name ||= T.must(qualified_name_of(constant)) #: String?
         end
 
-        sig { params(method_name: Symbol).returns(T::Boolean) }
+        #: (Symbol method_name) -> bool
         def bang_method?(method_name)
           method_name.to_s.end_with?("!")
         end
 
-        sig { void }
+        #: -> void
         def create_classes_and_includes
           model.create_extend(CommonRelationMethodsModuleName)
           # The model always extends the generated relation module
@@ -297,7 +287,7 @@ module Tapioca
           create_collection_proxy_class
         end
 
-        sig { void }
+        #: -> void
         def create_relation_class
           superclass = "::ActiveRecord::Relation"
 
@@ -316,7 +306,7 @@ module Tapioca
           create_relation_where_chain_class
         end
 
-        sig { void }
+        #: -> void
         def create_association_relation_class
           superclass = "::ActiveRecord::AssociationRelation"
 
@@ -335,7 +325,7 @@ module Tapioca
           create_association_relation_where_chain_class
         end
 
-        sig { void }
+        #: -> void
         def create_relation_group_chain_class
           model.create_class(RelationGroupChainClassName, superclass_name: RelationClassName) do |klass|
             create_group_chain_methods(klass)
@@ -343,7 +333,7 @@ module Tapioca
           end
         end
 
-        sig { void }
+        #: -> void
         def create_association_relation_group_chain_class
           model.create_class(
             AssociationRelationGroupChainClassName,
@@ -354,7 +344,7 @@ module Tapioca
           end
         end
 
-        sig { params(klass: RBI::Scope).void }
+        #: (RBI::Scope klass) -> void
         def create_group_chain_methods(klass)
           # Calculation methods used with `group` return a hash where the keys cannot be typed
           # but the values can. Technically a `group` anywhere in the query chain produces
@@ -418,7 +408,7 @@ module Tapioca
           end
         end
 
-        sig { void }
+        #: -> void
         def create_relation_where_chain_class
           model.create_class(RelationWhereChainClassName) do |klass|
             create_where_chain_methods(klass, RelationClassName)
@@ -426,7 +416,7 @@ module Tapioca
           end
         end
 
-        sig { void }
+        #: -> void
         def create_association_relation_where_chain_class
           model.create_class(AssociationRelationWhereChainClassName) do |klass|
             create_where_chain_methods(klass, AssociationRelationClassName)
@@ -434,7 +424,7 @@ module Tapioca
           end
         end
 
-        sig { params(klass: RBI::Scope, return_type: String).void }
+        #: (RBI::Scope klass, String return_type) -> void
         def create_where_chain_methods(klass, return_type)
           WHERE_CHAIN_QUERY_METHODS.each do |method_name|
             case method_name
@@ -459,7 +449,7 @@ module Tapioca
           end
         end
 
-        sig { void }
+        #: -> void
         def create_collection_proxy_class
           superclass = "::ActiveRecord::Associations::CollectionProxy"
 
@@ -476,7 +466,7 @@ module Tapioca
           end
         end
 
-        sig { params(klass: RBI::Scope).void }
+        #: (RBI::Scope klass) -> void
         def create_collection_proxy_methods(klass)
           # For these cases, it is valid to pass:
           # - a model instance, thus `Model`
@@ -555,7 +545,7 @@ module Tapioca
           end
         end
 
-        sig { void }
+        #: -> void
         def create_relation_methods
           create_relation_method("all")
 
@@ -619,7 +609,7 @@ module Tapioca
           end
         end
 
-        sig { void }
+        #: -> void
         def create_association_relation_methods
           returning_type = "T.nilable(T.any(T::Array[Symbol], FalseClass))"
           unique_by_type = "T.nilable(T.any(T::Array[Symbol], Symbol))"
@@ -664,7 +654,7 @@ module Tapioca
           end
         end
 
-        sig { void }
+        #: -> void
         def create_common_methods
           create_common_method(
             "destroy_all",
@@ -846,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,
@@ -875,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
@@ -1049,13 +976,32 @@ module Tapioca
           end
         end
 
-        sig do
-          params(
-            name: T.any(Symbol, String),
-            parameters: T::Array[RBI::TypedParam],
-            return_type: T.nilable(String),
-          ).void
+        #: (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(
             name.to_s,
@@ -1064,7 +1010,7 @@ module Tapioca
           )
         end
 
-        sig { void }
+        #: -> void
         def create_where_relation_method
           relation_methods_module.create_method("where") do |method|
             method.add_rest_param("args")
@@ -1093,14 +1039,7 @@ module Tapioca
           end
         end
 
-        sig do
-          params(
-            name: T.any(Symbol, String),
-            parameters: T::Array[RBI::TypedParam],
-            relation_return_type: String,
-            association_return_type: String,
-          ).void
-        end
+        #: ((Symbol | String) name, ?parameters: Array[RBI::TypedParam], ?relation_return_type: String, ?association_return_type: String) -> void
         def create_relation_method(
           name,
           parameters: [],

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

@@ -38,13 +38,13 @@ 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) } }
-
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           method_names = scope_method_names
 
@@ -77,7 +77,8 @@ module Tapioca
         end
 
         class << self
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             descendants_of(::ActiveRecord::Base).reject(&:abstract_class?)
           end
@@ -85,9 +86,9 @@ module Tapioca
 
         private
 
-        sig { returns(T::Array[Symbol]) }
+        #: -> Array[Symbol]
         def scope_method_names
-          scope_methods = T.let([], T::Array[Symbol])
+          scope_methods = [] #: Array[Symbol]
           constant = self.constant
 
           # Keep gathering scope methods until we hit "ActiveRecord::Base"
@@ -104,13 +105,7 @@ module Tapioca
           scope_methods.uniq
         end
 
-        sig do
-          params(
-            mod: RBI::Scope,
-            scope_method: String,
-            return_type: String,
-          ).void
-        end
+        #: (RBI::Scope mod, String scope_method, String return_type) -> void
         def generate_scope_method(mod, scope_method, return_type)
           mod.create_method(
             scope_method,

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

@@ -32,13 +32,13 @@ 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) } }
-
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           return if constant.__tapioca_secure_tokens.nil?
 
@@ -59,7 +59,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             descendants_of(::ActiveRecord::Base).reject(&:abstract_class?)
           end

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

@@ -78,13 +78,13 @@ 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) } }
-
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           return if constant.__tapioca_stored_attributes.nil?
 
@@ -134,7 +134,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             descendants_of(::ActiveRecord::Base).reject(&:abstract_class?)
           end