tapioca 0.10.5 → 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
 
@@ -224,6 +218,7 @@ module Tapioca
           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(
@@ -234,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))
@@ -244,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)
@@ -254,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
@@ -272,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
@@ -288,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,
@@ -335,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
@@ -429,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"),
@@ -447,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"),
@@ -457,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))"
 
@@ -502,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}]",
           )
 
@@ -515,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"),
                 ],
@@ -524,7 +545,6 @@ module Tapioca
             when :include?, :member?
               create_common_method(
                 method_name,
-                common_relation_methods_module,
                 parameters: [
                   create_param("record", type: "T.untyped"),
                 ],
@@ -533,7 +553,6 @@ module Tapioca
             when :find
               create_common_method(
                 "find",
-                common_relation_methods_module,
                 parameters: [
                   create_rest_param("args", type: "T.untyped"),
                 ],
@@ -542,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"),
                 ],
@@ -551,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"),
                 ],
@@ -560,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"),
@@ -570,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"),
                 ],
@@ -594,7 +608,6 @@ module Tapioca
 
               create_common_method(
                 method_name,
-                common_relation_methods_module,
                 return_type: return_type,
               )
             end
@@ -605,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"),
@@ -615,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"),
@@ -630,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)"),
                 ],
@@ -639,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)"),
@@ -649,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"),
                 ],
@@ -669,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))"),
@@ -679,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),
               ],
@@ -695,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),
@@ -707,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)"),
@@ -720,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,
@@ -736,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,
@@ -745,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/graphql_input_object.rb

@@ -45,7 +45,11 @@ module Tapioca
 
         sig { override.void }
         def decorate
-          arguments = constant.all_argument_definitions
+          # Skip methods explicitly defined in code
+          arguments = constant.all_argument_definitions.select do |argument|
+            method_defined_by_graphql?(argument.keyword.to_s)
+          end
+
           return if arguments.empty?
 
           root.create_path(constant) do |input_object|
@@ -56,6 +60,22 @@ module Tapioca
           end
         end
 
+        private
+
+        sig { returns(T.nilable(String)) }
+        def graphql_input_object_argument_source_file
+          @graphql_input_object_argument_source_file ||= T.let(
+            GraphQL::Schema::InputObject.method(:argument).source_location&.first,
+            T.nilable(String),
+          )
+        end
+
+        sig { params(method_name: String).returns(T::Boolean) }
+        def method_defined_by_graphql?(method_name)
+          method_file = constant.instance_method(method_name).source_location&.first
+          !!(method_file && graphql_input_object_argument_source_file == method_file)
+        end
+
         class << self
           extend T::Sig
 

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

@@ -0,0 +1,130 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "kredis"
+rescue LoadError
+  return
+end
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::Kredis` decorates RBI files for all
+      # classes that include [`Kredis::Attributes`](https://github.com/rails/kredis/blob/main/lib/kredis/attributes.rb).
+      #
+      # For example, with the following class:
+      #
+      # ~~~rb
+      # class Person < ApplicationRecord
+      #   kredis_list :names
+      #   kredis_flag :awesome
+      #   kredis_counter :steps, expires_in: 1.hour
+      #   kredis_enum :morning, values: %w[ bright blue black ], default: "bright"
+      # end
+      # ~~~
+      #
+      # this compiler will produce an RBI file with the following content:
+      # ~~~rbi
+      # # typed: true
+      #
+      # class Person
+      #   module GeneratedKredisAttributeMethods
+      #     sig { returns(Kredis::Types::Flag) }
+      #     def awesome; end
+      #
+      #     sig { returns(T::Boolean) }
+      #     def awesome?; end
+      #
+      #     sig { returns(PrivateEnumMorning) }
+      #     def morning; end
+      #
+      #     sig { returns(Kredis::Types::List) }
+      #     def names; end
+      #
+      #     sig { returns(Kredis::Types::Counter) }
+      #     def steps; end
+      #
+      #     class PrivateEnumMorning < Kredis::Types::Enum
+      #       sig { void }
+      #       def black!; end
+      #
+      #       sig { returns(T::Boolean) }
+      #       def black?; end
+      #
+      #       sig { void }
+      #       def blue!; end
+      #
+      #       sig { returns(T::Boolean) }
+      #       def blue?; end
+      #
+      #       sig { void }
+      #       def bright!; end
+      #
+      #       sig { returns(T::Boolean) }
+      #       def bright?; end
+      #     end
+      #   end
+      # end
+      # ~~~
+      class Kredis < Compiler
+        extend T::Sig
+
+        ConstantType = type_member { { fixed: T.all(Class, ::Kredis::Attributes::ClassMethods, Extensions::Kredis) } }
+
+        sig { override.void }
+        def decorate
+          return if constant.__tapioca_kredis_types.nil?
+
+          module_name = "GeneratedKredisAttributeMethods"
+
+          root.create_path(constant) do |model|
+            model.create_module(module_name) do |mod|
+              constant.__tapioca_kredis_types.each do |method, data|
+                generate_methods(mod, method, data)
+              end
+            end
+            model.create_include(module_name)
+          end
+        end
+
+        class << self
+          extend T::Sig
+
+          sig { override.returns(T::Enumerable[Module]) }
+          def gather_constants
+            all_classes
+              .grep(::Kredis::Attributes::ClassMethods)
+              .reject { |klass| klass.to_s == "ActiveRecord::Base" || klass.try(:abstract_class?) }
+          end
+        end
+
+        private
+
+        sig { params(mod: RBI::Scope, method: String, data: T::Hash[Symbol, T.untyped]).void }
+        def generate_methods(mod, method, data)
+          return_type = data.fetch(:type)
+          case return_type
+          when "Kredis::Types::Enum"
+            klass_name = "PrivateEnum#{method.split("_").map(&:capitalize).join}"
+            create_enum_class(mod, klass_name, data.fetch(:values))
+            return_type = klass_name
+          when "Kredis::Types::Flag"
+            mod.create_method("#{method}?", return_type: "T::Boolean")
+          end
+
+          mod.create_method(method, return_type: return_type)
+        end
+
+        sig { params(mod: RBI::Scope, klass_name: String, values: T::Array[T.untyped]).void }
+        def create_enum_class(mod, klass_name, values)
+          klass = mod.create_class(klass_name, superclass_name: "Kredis::Types::Enum")
+          values.each do |value|
+            klass.create_method("#{value}!", return_type: "void")
+            klass.create_method("#{value}?", return_type: "T::Boolean")
+          end
+        end
+      end
+    end
+  end
+end