tapioca 0.10.4 → 0.11.0

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

@@ -164,16 +164,10 @@ module Tapioca
 
         sig { override.void }
         def decorate
-          root.create_path(constant) do |model|
-            relation_methods_module = model.create_module(RelationMethodsModuleName)
-            association_relation_methods_module = model.create_module(AssociationRelationMethodsModuleName)
-            common_relation_methods_module = model.create_module(CommonRelationMethodsModuleName)
-
-            create_classes_and_includes(model)
-            create_common_methods(common_relation_methods_module)
-            create_relation_methods(relation_methods_module, association_relation_methods_module)
-            create_association_relation_methods(association_relation_methods_module)
-          end
+          create_classes_and_includes
+          create_common_methods
+          create_relation_methods
+          create_association_relation_methods
         end
 
         class << self
@@ -181,7 +175,7 @@ module Tapioca
 
           sig { override.returns(T::Enumerable[Module]) }
           def gather_constants
-            ActiveRecord::Base.descendants.reject(&:abstract_class?)
+            descendants_of(ActiveRecord::Base).reject(&:abstract_class?)
           end
         end
 
@@ -196,28 +190,35 @@ module Tapioca
           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 -= [:arel, :build_subquery, :construct_join_dependency, :extensions, :spawn]
-          # Remove "where" which needs a custom return type for WhereChains
-          query_methods -= [:where]
-          # 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])
+        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 -= [:arel, :build_subquery, :construct_join_dependency, :extensions, :spawn]
+            # Remove "where" which needs a custom return type for WhereChains
+            query_methods -= [:where]
+            # 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(ActiveRecord::SignedId::ClassMethods.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(
@@ -228,6 +229,38 @@ module Tapioca
 
         private
 
+        sig { returns(RBI::Scope) }
+        def model
+          @model ||= T.let(
+            root.create_path(constant),
+            T.nilable(RBI::Scope),
+          )
+        end
+
+        sig { returns(RBI::Scope) }
+        def relation_methods_module
+          @relation_methods_module ||= T.let(
+            model.create_module(RelationMethodsModuleName),
+            T.nilable(RBI::Scope),
+          )
+        end
+
+        sig { returns(RBI::Scope) }
+        def association_relation_methods_module
+          @association_relation_methods_module ||= T.let(
+            model.create_module(AssociationRelationMethodsModuleName),
+            T.nilable(RBI::Scope),
+          )
+        end
+
+        sig { returns(RBI::Scope) }
+        def common_relation_methods_module
+          @common_relation_methods_module ||= T.let(
+            model.create_module(CommonRelationMethodsModuleName),
+            T.nilable(RBI::Scope),
+          )
+        end
+
         sig { returns(String) }
         def constant_name
           @constant_name ||= T.let(T.must(qualified_name_of(constant)), T.nilable(String))
@@ -238,8 +271,8 @@ module Tapioca
           method_name.to_s.end_with?("!")
         end
 
-        sig { params(model: RBI::Scope).void }
-        def create_classes_and_includes(model)
+        sig { void }
+        def create_classes_and_includes
           model.create_extend(CommonRelationMethodsModuleName)
           # The model always extends the generated relation module
           model.create_extend(RelationMethodsModuleName)
@@ -248,13 +281,13 @@ module Tapioca
           # See https://github.com/sorbet/sorbet/pull/4706 for details
           model.create_method("to_ary", return_type: "NilClass", visibility: RBI::Private.new)
 
-          create_relation_class(model)
-          create_association_relation_class(model)
-          create_collection_proxy_class(model)
+          create_relation_class
+          create_association_relation_class
+          create_collection_proxy_class
         end
 
-        sig { params(model: RBI::Scope).void }
-        def create_relation_class(model)
+        sig { void }
+        def create_relation_class
           superclass = "::ActiveRecord::Relation"
 
           # The relation subclass includes the generated relation module
@@ -266,11 +299,11 @@ module Tapioca
             klass.create_method("to_ary", return_type: "T::Array[#{constant_name}]")
           end
 
-          create_relation_where_chain_class(model)
+          create_relation_where_chain_class
         end
 
-        sig { params(model: RBI::Scope).void }
-        def create_association_relation_class(model)
+        sig { void }
+        def create_association_relation_class
           superclass = "::ActiveRecord::AssociationRelation"
 
           # Association subclasses include the generated association relation module
@@ -282,19 +315,19 @@ module Tapioca
             klass.create_method("to_ary", return_type: "T::Array[#{constant_name}]")
           end
 
-          create_association_relation_where_chain_class(model)
+          create_association_relation_where_chain_class
         end
 
-        sig { params(model: RBI::Scope).void }
-        def create_relation_where_chain_class(model)
+        sig { void }
+        def create_relation_where_chain_class
           model.create_class(RelationWhereChainClassName, superclass_name: RelationClassName) do |klass|
             create_where_chain_methods(klass, RelationClassName)
             klass.create_type_variable("Elem", type: "type_member", fixed: constant_name)
           end
         end
 
-        sig { params(model: RBI::Scope).void }
-        def create_association_relation_where_chain_class(model)
+        sig { void }
+        def create_association_relation_where_chain_class
           model.create_class(
             AssociationRelationWhereChainClassName,
             superclass_name: AssociationRelationClassName,
@@ -329,8 +362,8 @@ module Tapioca
           end
         end
 
-        sig { params(model: RBI::Scope).void }
-        def create_collection_proxy_class(model)
+        sig { void }
+        def create_collection_proxy_class
           superclass = "::ActiveRecord::Associations::CollectionProxy"
 
           # The relation subclass includes the generated association relation module
@@ -423,13 +456,11 @@ module Tapioca
           end
         end
 
-        sig { params(relation_methods_module: RBI::Scope, association_relation_methods_module: RBI::Scope).void }
-        def create_relation_methods(relation_methods_module, association_relation_methods_module)
-          create_relation_method("all", relation_methods_module, association_relation_methods_module)
+        sig { void }
+        def create_relation_methods
+          create_relation_method("all")
           create_relation_method(
             "where",
-            relation_methods_module,
-            association_relation_methods_module,
             parameters: [
               create_rest_param("args", type: "T.untyped"),
               create_block_param("blk", type: "T.untyped"),
@@ -441,8 +472,6 @@ module Tapioca
           QUERY_METHODS.each do |method_name|
             create_relation_method(
               method_name,
-              relation_methods_module,
-              association_relation_methods_module,
               parameters: [
                 create_rest_param("args", type: "T.untyped"),
                 create_block_param("blk", type: "T.untyped"),
@@ -451,8 +480,8 @@ module Tapioca
           end
         end
 
-        sig { params(association_relation_methods_module: RBI::Scope).void }
-        def create_association_relation_methods(association_relation_methods_module)
+        sig { 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))"
 
@@ -496,11 +525,10 @@ module Tapioca
           end
         end
 
-        sig { params(common_relation_methods_module: RBI::Scope).void }
-        def create_common_methods(common_relation_methods_module)
+        sig { void }
+        def create_common_methods
           create_common_method(
             "destroy_all",
-            common_relation_methods_module,
             return_type: "T::Array[#{constant_name}]",
           )
 
@@ -509,7 +537,6 @@ module Tapioca
             when :exists?
               create_common_method(
                 "exists?",
-                common_relation_methods_module,
                 parameters: [
                   create_opt_param("conditions", type: "T.untyped", default: ":none"),
                 ],
@@ -518,7 +545,6 @@ module Tapioca
             when :include?, :member?
               create_common_method(
                 method_name,
-                common_relation_methods_module,
                 parameters: [
                   create_param("record", type: "T.untyped"),
                 ],
@@ -527,7 +553,6 @@ module Tapioca
             when :find
               create_common_method(
                 "find",
-                common_relation_methods_module,
                 parameters: [
                   create_rest_param("args", type: "T.untyped"),
                 ],
@@ -536,7 +561,6 @@ module Tapioca
             when :find_by
               create_common_method(
                 "find_by",
-                common_relation_methods_module,
                 parameters: [
                   create_rest_param("args", type: "T.untyped"),
                 ],
@@ -545,7 +569,6 @@ module Tapioca
             when :find_by!
               create_common_method(
                 "find_by!",
-                common_relation_methods_module,
                 parameters: [
                   create_rest_param("args", type: "T.untyped"),
                 ],
@@ -554,7 +577,6 @@ module Tapioca
             when :find_sole_by
               create_common_method(
                 "find_sole_by",
-                common_relation_methods_module,
                 parameters: [
                   create_param("arg", type: "T.untyped"),
                   create_rest_param("args", type: "T.untyped"),
@@ -564,14 +586,12 @@ module Tapioca
             when :sole
               create_common_method(
                 "sole",
-                common_relation_methods_module,
                 parameters: [],
                 return_type: constant_name,
               )
             when :first, :last, :take
               create_common_method(
                 method_name,
-                common_relation_methods_module,
                 parameters: [
                   create_opt_param("limit", type: "T.untyped", default: "nil"),
                 ],
@@ -588,7 +608,6 @@ module Tapioca
 
               create_common_method(
                 method_name,
-                common_relation_methods_module,
                 return_type: return_type,
               )
             end
@@ -599,7 +618,6 @@ module Tapioca
             when :find_signed
               create_common_method(
                 "find_signed",
-                common_relation_methods_module,
                 parameters: [
                   create_param("signed_id", type: "T.untyped"),
                   create_kw_opt_param("purpose", type: "T.untyped", default: "nil"),
@@ -609,7 +627,6 @@ module Tapioca
             when :find_signed!
               create_common_method(
                 "find_signed!",
-                common_relation_methods_module,
                 parameters: [
                   create_param("signed_id", type: "T.untyped"),
                   create_kw_opt_param("purpose", type: "T.untyped", default: "nil"),
@@ -624,7 +641,6 @@ module Tapioca
             when :average, :maximum, :minimum
               create_common_method(
                 method_name,
-                common_relation_methods_module,
                 parameters: [
                   create_param("column_name", type: "T.any(String, Symbol)"),
                 ],
@@ -633,7 +649,6 @@ module Tapioca
             when :calculate
               create_common_method(
                 "calculate",
-                common_relation_methods_module,
                 parameters: [
                   create_param("operation", type: "Symbol"),
                   create_param("column_name", type: "T.any(String, Symbol)"),
@@ -643,18 +658,16 @@ module Tapioca
             when :count
               create_common_method(
                 "count",
-                common_relation_methods_module,
                 parameters: [
                   create_opt_param("column_name", type: "T.untyped", default: "nil"),
                 ],
                 return_type: "T.untyped",
               )
             when :ids
-              create_common_method("ids", common_relation_methods_module, return_type: "Array")
+              create_common_method("ids", return_type: "Array")
             when :pick, :pluck
               create_common_method(
                 method_name,
-                common_relation_methods_module,
                 parameters: [
                   create_rest_param("column_names", type: "T.untyped"),
                 ],
@@ -663,7 +676,6 @@ module Tapioca
             when :sum
               create_common_method(
                 "sum",
-                common_relation_methods_module,
                 parameters: [
                   create_opt_param("column_name", type: "T.nilable(T.any(String, Symbol))", default: "nil"),
                   create_block_param("block", type: "T.nilable(T.proc.params(record: T.untyped).returns(T.untyped))"),
@@ -673,11 +685,63 @@ module Tapioca
             end
           end
 
+          BATCHES_METHODS.each do |method_name|
+            case method_name
+            when :find_each
+              order = ActiveRecord::Batches.instance_method(:find_each).parameters.include?([:key, :order])
+              create_common_method(
+                "find_each",
+                parameters: [
+                  create_kw_opt_param("start", type: "T.untyped", default: "nil"),
+                  create_kw_opt_param("finish", type: "T.untyped", default: "nil"),
+                  create_kw_opt_param("batch_size", type: "Integer", default: "1000"),
+                  create_kw_opt_param("error_on_ignore", type: "T.untyped", default: "nil"),
+                  *(create_kw_opt_param("order", type: "Symbol", default: ":asc") if order),
+                  create_block_param("block", type: "T.nilable(T.proc.params(object: #{constant_name}).void)"),
+                ],
+                return_type: "T.nilable(T::Enumerator[#{constant_name}])",
+              )
+            when :find_in_batches
+              order = ActiveRecord::Batches.instance_method(:find_in_batches).parameters.include?([:key, :order])
+              create_common_method(
+                "find_in_batches",
+                parameters: [
+                  create_kw_opt_param("start", type: "T.untyped", default: "nil"),
+                  create_kw_opt_param("finish", type: "T.untyped", default: "nil"),
+                  create_kw_opt_param("batch_size", type: "Integer", default: "1000"),
+                  create_kw_opt_param("error_on_ignore", type: "T.untyped", default: "nil"),
+                  *(create_kw_opt_param("order", type: "Symbol", default: ":asc") if order),
+                  create_block_param(
+                    "block",
+                    type: "T.nilable(T.proc.params(object: T::Array[#{constant_name}]).void)",
+                  ),
+                ],
+                return_type: "T.nilable(T::Enumerator[T::Enumerator[#{constant_name}]])",
+              )
+            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])
+              create_common_method(
+                "in_batches",
+                parameters: [
+                  create_kw_opt_param("of", type: "Integer", default: "1000"),
+                  create_kw_opt_param("start", type: "T.untyped", default: "nil"),
+                  create_kw_opt_param("finish", type: "T.untyped", default: "nil"),
+                  create_kw_opt_param("load", type: "T.untyped", default: "false"),
+                  create_kw_opt_param("error_on_ignore", type: "T.untyped", default: "nil"),
+                  *(create_kw_opt_param("order", type: "Symbol", default: ":asc") if order),
+                  *(create_kw_opt_param("use_ranges", type: "T.untyped", default: "nil") if use_ranges),
+                  create_block_param("block", type: "T.nilable(T.proc.params(object: #{RelationClassName}).void)"),
+                ],
+                return_type: "T.nilable(::ActiveRecord::Batches::BatchEnumerator)",
+              )
+            end
+          end
+
           ENUMERABLE_QUERY_METHODS.each do |method_name|
             block_type = "T.nilable(T.proc.params(record: #{constant_name}).returns(T.untyped))"
             create_common_method(
               method_name,
-              common_relation_methods_module,
               parameters: [
                 create_block_param("block", type: block_type),
               ],
@@ -689,7 +753,6 @@ module Tapioca
             block_type = "T.nilable(T.proc.params(object: #{constant_name}).void)"
             create_common_method(
               method_name,
-              common_relation_methods_module,
               parameters: [
                 create_param("attributes", type: "T.untyped"),
                 create_block_param("block", type: block_type),
@@ -701,7 +764,6 @@ module Tapioca
           BUILDER_METHODS.each do |method_name|
             create_common_method(
               method_name,
-              common_relation_methods_module,
               parameters: [
                 create_opt_param("attributes", type: "T.untyped", default: "nil"),
                 create_block_param("block", type: "T.nilable(T.proc.params(object: #{constant_name}).void)"),
@@ -714,12 +776,11 @@ module Tapioca
         sig do
           params(
             name: T.any(Symbol, String),
-            common_relation_methods_module: RBI::Scope,
             parameters: T::Array[RBI::TypedParam],
             return_type: T.nilable(String),
           ).void
         end
-        def create_common_method(name, common_relation_methods_module, parameters: [], return_type: nil)
+        def create_common_method(name, parameters: [], return_type: nil)
           common_relation_methods_module.create_method(
             name.to_s,
             parameters: parameters,
@@ -730,8 +791,6 @@ module Tapioca
         sig do
           params(
             name: T.any(Symbol, String),
-            relation_methods_module: RBI::Scope,
-            association_relation_methods_module: RBI::Scope,
             parameters: T::Array[RBI::TypedParam],
             relation_return_type: String,
             association_return_type: String,
@@ -739,8 +798,6 @@ module Tapioca
         end
         def create_relation_method(
           name,
-          relation_methods_module,
-          association_relation_methods_module,
           parameters: [],
           relation_return_type: RelationClassName,
           association_return_type: AssociationRelationClassName

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

@@ -83,7 +83,7 @@ module Tapioca
         class << self
           sig { override.returns(T::Enumerable[Module]) }
           def gather_constants
-            descendants_of(::ActiveRecord::Base).reject(&:abstract_class?)
+            descendants_of(::ActiveRecord::Base)
           end
         end
 

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

@@ -0,0 +1,74 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "active_record"
+rescue LoadError
+  return
+end
+
+require "tapioca/dsl/helpers/active_record_constants_helper"
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::ActiveModelSecurePassword` decorates RBI files for all
+      # classes that use [`ActiveRecord::SecureToken`](https://api.rubyonrails.org/classes/ActiveRecord/SecureToken/ClassMethods.html).
+      #
+      # For example, with the following class:
+      #
+      # ~~~rb
+      # class User < ActiveRecord::Base
+      #   has_secure_token
+      #   has_secure_token :auth_token, length: 36
+      # end
+      # ~~~
+      #
+      # this compiler will produce an RBI file with the following content:
+      # ~~~rbi
+      # # typed: true
+      #
+      # class User
+      #   sig { returns(T::Boolean) }
+      #   def regenerate_token; end
+      #
+      #   sig { returns(T::Boolean) }
+      #   def regenerate_auth_token; end
+      # end
+      # ~~~
+      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 }
+        def decorate
+          return if constant.__tapioca_secure_tokens.nil?
+
+          root.create_path(constant) do |model|
+            model.create_module(SecureTokensModuleName) do |mod|
+              constant.__tapioca_secure_tokens.each do |attribute|
+                mod.create_method(
+                  "regenerate_#{attribute}",
+                  return_type: "T::Boolean",
+                )
+              end
+            end
+
+            model.create_include(SecureTokensModuleName)
+          end
+        end
+
+        class << self
+          extend T::Sig
+
+          sig { override.returns(T::Enumerable[Module]) }
+          def gather_constants
+            descendants_of(::ActiveRecord::Base).reject(&:abstract_class?)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -126,17 +126,20 @@ module Tapioca
 
         private
 
-        TYPES = T.let({
-          boolean: "T::Boolean",
-          integer: "Integer",
-          string: "String",
-          float: "Float",
-          date: "Date",
-          time: "Time",
-          datetime: "DateTime",
-          decimal: "BigDecimal",
-          any: "T.untyped",
-        }.freeze, T::Hash[Symbol, String])
+        TYPES = T.let(
+          {
+            boolean: "T::Boolean",
+            integer: "Integer",
+            string: "String",
+            float: "Float",
+            date: "Date",
+            time: "Time",
+            datetime: "DateTime",
+            decimal: "BigDecimal",
+            any: "T.untyped",
+          }.freeze,
+          T::Hash[Symbol, String],
+        )
 
         sig { params(attr_type: Symbol).returns(String) }
         def type_for(attr_type)

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

@@ -85,18 +85,21 @@ module Tapioca
 
         private
 
-        TYPES = T.let({
-          boolean: "T::Boolean",
-          integer: "Integer",
-          string: "String",
-          float: "Float",
-          date: "Date",
-          time: "Time",
-          datetime: "DateTime",
-          decimal: "BigDecimal",
-          binary: "String",
-          text: "String",
-        }.freeze, T::Hash[Symbol, String])
+        TYPES = T.let(
+          {
+            boolean: "T::Boolean",
+            integer: "Integer",
+            string: "String",
+            float: "Float",
+            date: "Date",
+            time: "Time",
+            datetime: "DateTime",
+            decimal: "BigDecimal",
+            binary: "String",
+            text: "String",
+          }.freeze,
+          T::Hash[Symbol, String],
+        )
 
         sig { params(attr_type: Symbol).returns(String) }
         def type_for(attr_type)
@@ -109,9 +112,13 @@ module Tapioca
 
           klass.create_method(attribute, return_type: return_type)
           klass.create_method("#{attribute}?", return_type: "T::Boolean")
-          klass.create_method("#{attribute}=", parameters: [
-            create_param("value", type: return_type),
-          ], return_type: return_type)
+          klass.create_method(
+            "#{attribute}=",
+            parameters: [
+              create_param("value", type: return_type),
+            ],
+            return_type: return_type,
+          )
         end
       end
     end

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

@@ -48,8 +48,10 @@ module Tapioca
 
         ConstantType = type_member do
           {
-            fixed: T.all(Module,
-              ::ActiveStorage::Reflection::ActiveRecordExtensions::ClassMethods),
+            fixed: T.all(
+              Module,
+              ::ActiveStorage::Reflection::ActiveRecordExtensions::ClassMethods,
+            ),
           }
         end