tapioca 0.15.0 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f93b130a7096e0712ccd91b8406d92ce537287afafc8aad7586e7f670d88a131
-  data.tar.gz: b2cc1e6d2658002600c1edd9c5c88b22704e3f4170ff19aff93bb9fc21df688e
+  metadata.gz: 3a448cd511151879e4eef761b28cc8f5b1904f0d57e560a38af09bdda9689f98
+  data.tar.gz: 563c5e68f866444da629a4b206fed22b8a27531c36c0378d669886aa2a704eaf
 SHA512:
-  metadata.gz: aa10ff7ffd4768cea802b63dc68273fa0abf7f69b61a83b1325669e97d706cb8afcc704093c93596a830662fe04b01ad2ded3c166abd69a5c69097bd28f586c9
-  data.tar.gz: 63499428de9374990372beb46ece3f98d0f446ba28ef02bfa181179113e37e587ff9867bbe0d729d67c03ddb2813943f6f04d14f2065589a603a766a06ce8096
+  metadata.gz: c847afeb5c173ad8b0c46a0f2fd214336150124fd96f0c729029ce492a5f4aea4bf5d26adfd64cf386486f22342b21f502cdbc52c68ca544a65c4bf6777dacee
+  data.tar.gz: e25a62343cc4522d37e9508b4215f6efb9115b93e1e9ba38c71edf26da025126732b4762b834304d0e439c741d581f238e29e22dded9fcbf0415256041f8f849

data/lib/tapioca/dsl/compiler.rb

@@ -49,7 +49,7 @@ module Tapioca
         sig { returns(T::Enumerable[T::Class[T.anything]]) }
         def all_classes
           @all_classes ||= T.let(
-            T.cast(ObjectSpace.each_object(Class), T::Enumerable[T::Class[T.anything]]).each,
+            ObjectSpace.each_object(Class),
             T.nilable(T::Enumerable[T::Class[T.anything]]),
           )
         end
@@ -57,7 +57,7 @@ module Tapioca
         sig { returns(T::Enumerable[Module]) }
         def all_modules
           @all_modules ||= T.let(
-            T.cast(ObjectSpace.each_object(Module), T::Enumerable[Module]).each,
+            ObjectSpace.each_object(Module),
             T.nilable(T::Enumerable[Module]),
           )
         end

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

@@ -147,7 +147,7 @@ module Tapioca
                 machine.create_method(
                   method,
                   parameters: [
-                    create_opt_param("symbol", type: "T.nilable(Symbol)", default: "nil"),
+                    create_rest_param("callbacks", type: "T.any(String, Symbol, T::Class[T.anything], Proc)"),
                     create_block_param("block", type: "T.nilable(T.proc.bind(#{constant_name}).void)"),
                   ],
                 )

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

@@ -57,9 +57,7 @@ module Tapioca
           sig { override.returns(T::Enumerable[Module]) }
           def gather_constants
             # Collect all the classes that include ActiveModel::Validations
-            all_classes.select do |c|
-              c < ActiveModel::Validations
-            end
+            all_classes.select { |c| ActiveModel::Validations > c }
           end
         end
 

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

@@ -188,6 +188,7 @@ module Tapioca
         def populate_single_assoc_getter_setter(klass, association_name, reflection)
           association_class = type_for(reflection)
           association_type = as_nilable_type(association_class)
+          association_methods_module = constant.generated_association_methods
 
           klass.create_method(
             association_name.to_s,
@@ -206,6 +207,18 @@ module Tapioca
             "reset_#{association_name}",
             return_type: "void",
           )
+          if association_methods_module.method_defined?("#{association_name}_changed?")
+            klass.create_method(
+              "#{association_name}_changed?",
+              return_type: "T::Boolean",
+            )
+          end
+          if association_methods_module.method_defined?("#{association_name}_previously_changed?")
+            klass.create_method(
+              "#{association_name}_previously_changed?",
+              return_type: "T::Boolean",
+            )
+          end
           unless reflection.polymorphic?
             klass.create_method(
               "build_#{association_name}",

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

@@ -111,7 +111,7 @@ module Tapioca
         sig { params(mod: RBI::Scope, name: String).void }
         def create_fixture_method(mod, name)
           return_type = return_type_for_fixture(name)
-          mod << RBI::Method.new(name) do |node|
+          mod.create_method(name) do |node|
             node.add_opt_param("fixture_name", "nil")
             node.add_rest_param("other_fixtures")
 

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

@@ -155,6 +155,25 @@ module Tapioca
 
         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 }
         def decorate
           create_classes_and_includes
@@ -220,7 +239,7 @@ module Tapioca
           [: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, :build, :create, :create!], 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])
 
         private
@@ -663,58 +682,43 @@ module Tapioca
                 return_type: "T::Boolean",
               )
             when :find
-              # From ActiveRecord::ConnectionAdapter::Quoting#quote, minus nil
-              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
+              id_types = ID_TYPES
 
               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)
-                id_types << type if type != "T.untyped"
+
+                id_types = ID_TYPES.union([type]) if type != "T.untyped"
               end
 
               id_types = "T.any(#{id_types.to_a.join(", ")})"
+              if constant.try(:composite_primary_key?)
+                id_types = "T::Array[#{id_types}]"
+              end
 
-              array_type = if constant.try(:composite_primary_key?)
-                "T::Array[T::Array[#{id_types}]]"
-              else
-                "T::Array[#{id_types}]"
+              array_type = "T::Array[#{id_types}]"
+
+              common_relation_methods_module.create_method("find") do |method|
+                method.add_opt_param("args", "nil")
+                method.add_block_param("block")
+
+                method.add_sig do |sig|
+                  sig.add_param("args", id_types)
+                  sig.return_type = constant_name
+                end
+
+                method.add_sig do |sig|
+                  sig.add_param("args", array_type)
+                  sig.return_type = "T::Enumerable[#{constant_name}]"
+                end
+
+                method.add_sig do |sig|
+                  sig.add_param("args", "NilClass")
+                  sig.add_param("block", "T.proc.params(object: #{constant_name}).void")
+                  sig.return_type = as_nilable_type(constant_name)
+                end
               end
-              sigs = [
-                common_relation_methods_module.create_sig(
-                  parameters: { args: id_types },
-                  return_type: constant_name,
-                ),
-                common_relation_methods_module.create_sig(
-                  parameters: { args: array_type },
-                  return_type: "T::Enumerable[#{constant_name}]",
-                ),
-                common_relation_methods_module.create_sig(
-                  parameters: {
-                    args: "NilClass",
-                    block: "T.proc.params(object: #{constant_name}).void",
-                  },
-                  return_type: as_nilable_type(constant_name),
-                ),
-              ]
-              common_relation_methods_module.create_method_with_sigs(
-                "find",
-                sigs: sigs,
-                parameters: [RBI::OptParam.new("args", "nil"), RBI::BlockParam.new("block")],
-              )
             when :find_by
               create_common_method(
                 "find_by",
@@ -747,21 +751,18 @@ module Tapioca
                 return_type: constant_name,
               )
             when :first, :last, :take
-              sigs = [
-                common_relation_methods_module.create_sig(
-                  parameters: { limit: "NilClass" },
-                  return_type: as_nilable_type(constant_name),
-                ),
-                common_relation_methods_module.create_sig(
-                  parameters: { limit: "Integer" },
-                  return_type: "T::Array[#{constant_name}]",
-                ),
-              ]
-              common_relation_methods_module.create_method_with_sigs(
-                method_name.to_s,
-                sigs: sigs,
-                parameters: [RBI::OptParam.new("limit", "nil")],
-              )
+              common_relation_methods_module.create_method(method_name.to_s) do |method|
+                method.add_opt_param("limit", "nil")
+
+                method.add_sig do |sig|
+                  sig.return_type = as_nilable_type(constant_name)
+                end
+
+                method.add_sig do |sig|
+                  sig.add_param("limit", "Integer")
+                  sig.return_type = "T::Array[#{constant_name}]"
+                end
+              end
             when :raise_record_not_found_exception!
               # skip
             else
@@ -821,24 +822,21 @@ module Tapioca
                 return_type: "T.any(Integer, Float, BigDecimal)",
               )
             when :count
-              sigs = [
-                common_relation_methods_module.create_sig(
-                  parameters: { column_name: "T.nilable(T.any(String, Symbol))" },
-                  return_type: "Integer",
-                ),
-                common_relation_methods_module.create_sig(
-                  parameters: { column_name: "NilClass", block: "T.proc.params(object: #{constant_name}).void" },
-                  return_type: "Integer",
-                ),
-              ]
-              common_relation_methods_module.create_method_with_sigs(
-                "count",
-                sigs: sigs,
-                parameters: [
-                  RBI::OptParam.new("column_name", "nil"),
-                  RBI::BlockParam.new("block"),
-                ],
-              )
+              common_relation_methods_module.create_method(method_name.to_s) do |method|
+                method.add_opt_param("column_name", "nil")
+                method.add_block_param("block")
+
+                method.add_sig do |sig|
+                  sig.add_param("column_name", "T.nilable(T.any(String, Symbol))")
+                  sig.return_type = "Integer"
+                end
+
+                method.add_sig do |sig|
+                  sig.add_param("column_name", "NilClass")
+                  sig.add_param("block", "T.proc.params(object: #{constant_name}).void")
+                  sig.return_type = "Integer"
+                end
+              end
             when :ids
               create_common_method("ids", return_type: "Array")
             when :pick, :pluck
@@ -850,29 +848,21 @@ module Tapioca
                 return_type: "T.untyped",
               )
             when :sum
-              sigs = [
-                common_relation_methods_module.create_sig(
-                  parameters: { initial_value_or_column: "T.untyped" },
-                  return_type: "T.any(Integer, Float, BigDecimal)",
-                ),
-                common_relation_methods_module.create_sig(
-                  type_parameters: ["U"],
-                  parameters:
-                  {
-                    initial_value_or_column: "T.nilable(T.type_parameter(:U))",
-                    block: "T.proc.params(object: #{constant_name}).returns(T.type_parameter(:U))",
-                  },
-                  return_type: "T.type_parameter(:U)",
-                ),
-              ]
-              common_relation_methods_module.create_method_with_sigs(
-                method_name.to_s,
-                sigs: sigs,
-                parameters: [
-                  RBI::OptParam.new("initial_value_or_column", "nil"),
-                  RBI::BlockParam.new("block"),
-                ],
-              )
+              common_relation_methods_module.create_method(method_name.to_s) do |method|
+                method.add_opt_param("initial_value_or_column", "nil")
+                method.add_block_param("block")
+
+                method.add_sig do |sig|
+                  sig.add_param("initial_value_or_column", "T.untyped")
+                  sig.return_type = "T.any(Integer, Float, BigDecimal)"
+                end
+
+                method.add_sig(type_params: ["U"]) do |sig|
+                  sig.add_param("initial_value_or_column", "T.nilable(T.type_parameter(:U))")
+                  sig.add_param("block", "T.proc.params(object: #{constant_name}).returns(T.type_parameter(:U))")
+                  sig.return_type = "T.type_parameter(:U)"
+                end
+              end
             end
           end
 
@@ -880,102 +870,100 @@ module Tapioca
             case method_name
             when :find_each
               order = ActiveRecord::Batches.instance_method(:find_each).parameters.include?([:key, :order])
-              parameters = {
-                start: "T.untyped",
-                finish: "T.untyped",
-                batch_size: "Integer",
-                error_on_ignore: "T.untyped",
-                order: ("Symbol" if order),
-              }.compact
-              sigs = [
-                common_relation_methods_module.create_sig(
-                  parameters: parameters.merge(block: "T.proc.params(object: #{constant_name}).void"),
-                  return_type: "void",
-                ),
-                common_relation_methods_module.create_sig(
-                  parameters: parameters,
-                  return_type: "T::Enumerator[#{constant_name}]",
-                ),
-              ]
-              common_relation_methods_module.create_method_with_sigs(
-                "find_each",
-                sigs: sigs,
-                parameters: [
-                  RBI::KwOptParam.new("start", "nil"),
-                  RBI::KwOptParam.new("finish", "nil"),
-                  RBI::KwOptParam.new("batch_size", "1000"),
-                  RBI::KwOptParam.new("error_on_ignore", "nil"),
-                  *(RBI::KwOptParam.new("order", ":asc") if order),
-                  RBI::BlockParam.new("block"),
-                ],
-              )
+
+              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")
+
+                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
+
+                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
+              end
             when :find_in_batches
               order = ActiveRecord::Batches.instance_method(:find_in_batches).parameters.include?([:key, :order])
-              parameters = {
-                start: "T.untyped",
-                finish: "T.untyped",
-                batch_size: "Integer",
-                error_on_ignore: "T.untyped",
-                order: ("Symbol" if order),
-              }.compact
-              sigs = [
-                common_relation_methods_module.create_sig(
-                  parameters: parameters.merge(block: "T.proc.params(object: T::Array[#{constant_name}]).void"),
-                  return_type: "void",
-                ),
-                common_relation_methods_module.create_sig(
-                  parameters: parameters,
-                  return_type: "T::Enumerator[T::Enumerator[#{constant_name}]]",
-                ),
-              ]
-              common_relation_methods_module.create_method_with_sigs(
-                "find_in_batches",
-                sigs: sigs,
-                parameters: [
-                  RBI::KwOptParam.new("start", "nil"),
-                  RBI::KwOptParam.new("finish", "nil"),
-                  RBI::KwOptParam.new("batch_size", "1000"),
-                  RBI::KwOptParam.new("error_on_ignore", "nil"),
-                  *(RBI::KwOptParam.new("order", ":asc") if order),
-                  RBI::BlockParam.new("block"),
-                ],
-              )
+              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_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}]]"
+                end
+              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])
-              parameters = {
-                of: "Integer",
-                start: "T.untyped",
-                finish: "T.untyped",
-                load: "T.untyped",
-                error_on_ignore: "T.untyped",
-                order: ("Symbol" if order),
-                use_ranges: ("T.untyped" if use_ranges),
-              }.compact
-              sigs = [
-                common_relation_methods_module.create_sig(
-                  parameters: parameters.merge(block: "T.proc.params(object: #{RelationClassName}).void"),
-                  return_type: "void",
-                ),
-                common_relation_methods_module.create_sig(
-                  parameters: parameters,
-                  return_type: "::ActiveRecord::Batches::BatchEnumerator",
-                ),
-              ]
-              common_relation_methods_module.create_method_with_sigs(
-                "in_batches",
-                sigs: sigs,
-                parameters: [
-                  RBI::KwOptParam.new("of", "1000"),
-                  RBI::KwOptParam.new("start", "nil"),
-                  RBI::KwOptParam.new("finish", "nil"),
-                  RBI::KwOptParam.new("load", "false"),
-                  RBI::KwOptParam.new("error_on_ignore", "nil"),
-                  *(RBI::KwOptParam.new("order", ":asc") if order),
-                  *(RBI::KwOptParam.new("use_ranges", "nil") if use_ranges),
-                  RBI::BlockParam.new("block"),
-                ],
-              )
+
+              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"
+                end
+              end
             end
           end
 
@@ -991,26 +979,50 @@ module Tapioca
           end
 
           FIND_OR_CREATE_METHODS.each do |method_name|
-            block_type = "T.nilable(T.proc.params(object: #{constant_name}).void)"
-            create_common_method(
-              method_name,
-              parameters: [
-                create_param("attributes", type: "T.untyped"),
-                create_block_param("block", type: block_type),
-              ],
-              return_type: constant_name,
-            )
+            common_relation_methods_module.create_method(method_name.to_s) do |method|
+              method.add_param("attributes")
+              method.add_block_param("block")
+
+              # `T.untyped` matches `T::Array[T.untyped]` so the array signature
+              # must be defined first for Sorbet to pick it, if valid.
+              method.add_sig do |sig|
+                sig.add_param("attributes", "T::Array[T.untyped]")
+                sig.add_param("block", "T.nilable(T.proc.params(object: #{constant_name}).void)")
+                sig.return_type = "T::Array[#{constant_name}]"
+              end
+
+              method.add_sig do |sig|
+                sig.add_param("attributes", "T.untyped")
+                sig.add_param("block", "T.nilable(T.proc.params(object: #{constant_name}).void)")
+                sig.return_type = constant_name
+              end
+            end
           end
 
           BUILDER_METHODS.each do |method_name|
-            create_common_method(
-              method_name,
-              parameters: [
-                create_opt_param("attributes", type: "T.untyped", default: "nil"),
-                create_block_param("block", type: "T.nilable(T.proc.params(object: #{constant_name}).void)"),
-              ],
-              return_type: constant_name,
-            )
+            common_relation_methods_module.create_method(method_name.to_s) do |method|
+              method.add_opt_param("attributes", "nil")
+              method.add_block_param("block")
+
+              method.add_sig do |sig|
+                sig.add_param("block", "T.nilable(T.proc.params(object: #{constant_name}).void)")
+                sig.return_type = constant_name
+              end
+
+              # `T.untyped` matches `T::Array[T.untyped]` so the array signature
+              # must be defined first for Sorbet to pick it, if valid.
+              method.add_sig do |sig|
+                sig.add_param("attributes", "T::Array[T.untyped]")
+                sig.add_param("block", "T.nilable(T.proc.params(object: #{constant_name}).void)")
+                sig.return_type = "T::Array[#{constant_name}]"
+              end
+
+              method.add_sig do |sig|
+                sig.add_param("attributes", "T.untyped")
+                sig.add_param("block", "T.nilable(T.proc.params(object: #{constant_name}).void)")
+                sig.return_type = constant_name
+              end
+            end
           end
         end
 

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

@@ -66,19 +66,18 @@ module Tapioca
 
           sig { override.returns(T::Enumerable[Module]) }
           def gather_constants
-            # Find all Modules that are:
             all_modules.select do |mod|
-              # named (i.e. not anonymous)
-              name_of(mod) &&
-                # not singleton classes
+              name_of(mod) && # i.e. not anonymous
                 !mod.singleton_class? &&
-                # extend ActiveSupport::Concern, and
-                mod.singleton_class < ActiveSupport::Concern &&
-                # have dependencies (i.e. include another concern)
-                !dependencies_of(mod).empty?
+                ActiveSupport::Concern > mod.singleton_class &&
+                has_dependencies?(mod)
             end
           end
 
+          # Returns true when `mod` includes other concerns
+          sig { params(mod: Module).returns(T::Boolean) }
+          def has_dependencies?(mod) = dependencies_of(mod).any?
+
           sig { params(concern: Module).returns(T::Array[Module]) }
           def dependencies_of(concern)
             concern.instance_variable_get(:@_dependencies) || []

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

@@ -0,0 +1,68 @@
+# typed: strict
+# frozen_string_literal: true
+
+return unless defined?(Time.current) && defined?(ActiveSupport::TimeWithZone)
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::ActiveSupportTimeExt` generates an RBI file for the `Time#current` method
+      # defined by [Active Support's Time extensions](https://api.rubyonrails.org/classes/Time.html).
+      #
+      # If `Time.zone` or `config.time_zone` are set, then the `Time.current` method will be defined as returning
+      # an instance of `ActiveSupport::TimeWithZone`, otherwise it will return an instance of `Time`.
+      #
+      # For an application that is configured with:
+      # ```ruby
+      # config.time_zone = "UTC"
+      # ```
+      # this compiler will produce the following RBI file:
+      # ```rbi
+      # class Time
+      #   class << self
+      #     sig { returns(::ActiveSupport::TimeWithZone) }
+      #     def current; end
+      #   end
+      # end
+      # ```
+      # whereas if `Time.zone` and `config.time_zone` are not set, it will produce:
+      # ```rbi
+      # class Time
+      #   class << self
+      #     sig { returns(::Time) }
+      #     def current; end
+      #   end
+      # end
+      # ```
+      class ActiveSupportTimeExt < Compiler
+        extend T::Sig
+
+        ConstantType = type_member { { fixed: T.class_of(::Time) } }
+
+        sig { override.void }
+        def decorate
+          return unless constant.respond_to?(:zone)
+
+          root.create_path(constant) do |mod|
+            return_type = if ::Time.zone
+              "::ActiveSupport::TimeWithZone"
+            else
+              "::Time"
+            end
+
+            mod.create_method("current", return_type: return_type, class_method: true)
+          end
+        end
+
+        class << self
+          extend T::Sig
+
+          sig { override.returns(T::Enumerable[Module]) }
+          def gather_constants
+            [::Time]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -80,7 +80,7 @@ module Tapioca
 
           sig { override.returns(T::Enumerable[Module]) }
           def gather_constants
-            all_classes.select { |c| c < GraphQL::Schema::InputObject }
+            all_classes.select { |c| GraphQL::Schema::InputObject > c }
           end
         end
       end

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

@@ -80,7 +80,7 @@ module Tapioca
 
           sig { override.returns(T::Enumerable[Module]) }
           def gather_constants
-            all_classes.select { |c| c < GraphQL::Schema::Mutation && c != GraphQL::Schema::RelayClassicMutation }
+            all_classes.select { |c| GraphQL::Schema::Mutation > c && GraphQL::Schema::RelayClassicMutation != c }
           end
         end
       end

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

@@ -100,7 +100,7 @@ module Tapioca
           sig { override.returns(T::Enumerable[Module]) }
           def gather_constants
             descendants_of(::ActiveRecord::Base).select do |klass|
-              klass < ::IdentityCache::WithoutPrimaryIndex
+              ::IdentityCache::WithoutPrimaryIndex > klass
             end
           end
         end

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

@@ -111,7 +111,7 @@ module Tapioca
           sig { override.returns(T::Enumerable[Module]) }
           def gather_constants
             all_modules.select do |c|
-              name_of(c) && c < ::JsonApiClient::Resource
+              name_of(c) && ::JsonApiClient::Resource > c
             end
           end
         end

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

@@ -159,9 +159,7 @@ module Tapioca
           def gather_constants
             marker = Google::Protobuf::MessageExts::ClassMethods
 
-            enum_modules = ObjectSpace.each_object(Google::Protobuf::EnumDescriptor).map do |desc|
-              T.cast(desc, Google::Protobuf::EnumDescriptor).enummodule
-            end
+            enum_modules = ObjectSpace.each_object(Google::Protobuf::EnumDescriptor).map(&:enummodule)
 
             results = if Google::Protobuf.const_defined?(:AbstractMessage)
               abstract_message_const = ::Google::Protobuf.const_get(:AbstractMessage)

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

@@ -73,7 +73,7 @@ module Tapioca
 
           sig { override.returns(T::Enumerable[Module]) }
           def gather_constants
-            all_classes.select { |c| c < Sidekiq::Worker }
+            all_classes.select { |c| Sidekiq::Worker > c }
           end
         end
 

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

@@ -86,8 +86,9 @@ module Tapioca
           def gather_constants
             all_modules.select do |c|
               name_of(c) &&
-                c != ::SmartProperties::Validations::Ancestor &&
-                c < ::SmartProperties && ::SmartProperties::ClassMethods === c
+                ::SmartProperties > c &&
+                ::SmartProperties::Validations::Ancestor != c &&
+                ::SmartProperties::ClassMethods === c
             end
           end
         end

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

@@ -159,7 +159,7 @@ module Tapioca
 
           sig { override.returns(T::Enumerable[Module]) }
           def gather_constants
-            all_classes.select { |mod| mod < ::StateMachines::InstanceMethods }
+            all_classes.select { |mod| ::StateMachines::InstanceMethods > mod }
           end
         end
 
@@ -231,12 +231,12 @@ module Tapioca
           instance_module.create_method(
             attribute,
             return_type: state_type,
-          )
+          ) if ::StateMachines::HelperModule === machine.owner_class.instance_method(attribute).owner
           instance_module.create_method(
             "#{attribute}=",
             parameters: [create_param("value", type: state_type)],
             return_type: state_type,
-          )
+          ) if ::StateMachines::HelperModule === machine.owner_class.instance_method("#{attribute}=").owner
         end
 
         sig { params(instance_module: RBI::Module, machine: ::StateMachines::Machine).void }

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

@@ -106,19 +106,28 @@ module Tapioca
             routes_reloader = Rails.application.routes_reloader
             routes_reloader.execute_unless_loaded if routes_reloader&.respond_to?(:execute_unless_loaded)
 
-            Object.const_set(:GeneratedUrlHelpersModule, Rails.application.routes.named_routes.url_helpers_module)
-            Object.const_set(:GeneratedPathHelpersModule, Rails.application.routes.named_routes.path_helpers_module)
+            url_helpers_module = Rails.application.routes.named_routes.url_helpers_module
+            path_helpers_module = Rails.application.routes.named_routes.path_helpers_module
+
+            Object.const_set(:GeneratedUrlHelpersModule, url_helpers_module)
+            Object.const_set(:GeneratedPathHelpersModule, path_helpers_module)
 
             constants = all_modules.select do |mod|
               next unless name_of(mod)
 
-              includes_helper?(mod, GeneratedUrlHelpersModule) ||
-                includes_helper?(mod, GeneratedPathHelpersModule) ||
-                includes_helper?(mod.singleton_class, GeneratedUrlHelpersModule) ||
-                includes_helper?(mod.singleton_class, GeneratedPathHelpersModule)
+              # Fast-path to quickly disqualify most cases
+              next false unless url_helpers_module > mod || # rubocop:disable Style/InvertibleUnlessCondition
+                path_helpers_module > mod ||
+                url_helpers_module > mod.singleton_class ||
+                path_helpers_module > mod.singleton_class
+
+              includes_helper?(mod, url_helpers_module) ||
+                includes_helper?(mod, path_helpers_module) ||
+                includes_helper?(mod.singleton_class, url_helpers_module) ||
+                includes_helper?(mod.singleton_class, path_helpers_module)
             end
 
-            constants.concat(NON_DISCOVERABLE_INCLUDERS)
+            constants.concat(NON_DISCOVERABLE_INCLUDERS).push(GeneratedUrlHelpersModule, GeneratedPathHelpersModule)
           end
 
           sig { returns(T::Array[Module]) }
@@ -134,17 +143,20 @@ module Tapioca
             end.freeze
           end
 
+          # Returns `true` if `mod` "directly" includes `helper`.
+          # For classes, this method will return false if the `helper` is included only by a superclass
           sig { params(mod: Module, helper: Module).returns(T::Boolean) }
           private def includes_helper?(mod, helper)
-            superclass_ancestors = []
+            ancestors = ancestors_of(mod)
 
-            if Class === mod
-              superclass = superclass_of(mod)
-              superclass_ancestors = ancestors_of(superclass) if superclass
+            own_ancestors = if Class === mod && (superclass = superclass_of(mod))
+              # These ancestors are unique to `mod`, and exclude those in common with `superclass`.
+              ancestors.take(ancestors.count - ancestors_of(superclass).size)
+            else
+              ancestors
             end
 
-            ancestors = Set.new.compare_by_identity.merge(ancestors_of(mod)).subtract(superclass_ancestors)
-            ancestors.any? { |ancestor| helper == ancestor }
+            own_ancestors.include?(helper)
           end
         end
 

data/lib/tapioca/dsl/helpers/active_record_column_type_helper.rb

@@ -104,7 +104,7 @@ module Tapioca
 
           column = @constant.columns_hash[column_name]
           column_type = @constant.attribute_types[column_name]
-          getter_type = type_for_activerecord_value(column_type)
+          getter_type = type_for_activerecord_value(column_type, column_nullability: !!column&.null)
           setter_type =
             case column_type
             when ActiveRecord::Enum::EnumType
@@ -121,8 +121,8 @@ module Tapioca
           end
         end
 
-        sig { params(column_type: T.untyped).returns(String) }
-        def type_for_activerecord_value(column_type)
+        sig { params(column_type: T.untyped, column_nullability: T::Boolean).returns(String) }
+        def type_for_activerecord_value(column_type, column_nullability:)
           case column_type
           when ->(type) { defined?(MoneyColumn) && MoneyColumn::ActiveRecordType === type }
             "::Money"
@@ -133,11 +133,12 @@ module Tapioca
                }
             # Reflect to see if `ActiveModel::Type::Value` is being used first.
             getter_type = Tapioca::Dsl::Helpers::ActiveModelTypeHelper.type_for(column_type)
-            return getter_type unless getter_type == "T.untyped"
 
-            # Otherwise fallback to String as `ActiveRecord::Encryption::EncryptedAttributeType` inherits from
+            # Fallback to String as `ActiveRecord::Encryption::EncryptedAttributeType` inherits from
             # `ActiveRecord::Type::Text` which inherits from `ActiveModel::Type::String`.
-            "::String"
+            return "::String" if getter_type == "T.untyped"
+
+            as_non_nilable_if_persisted_and_not_nullable(getter_type, column_nullability:)
           when ActiveRecord::Type::String
             "::String"
           when ActiveRecord::Type::Date
@@ -160,7 +161,7 @@ module Tapioca
                  defined?(ActiveRecord::Normalization::NormalizedValueType) &&
                    ActiveRecord::Normalization::NormalizedValueType === type
                }
-            type_for_activerecord_value(column_type.cast_type)
+            type_for_activerecord_value(column_type.cast_type, column_nullability:)
           when ->(type) {
                  defined?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Uuid) &&
                    ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Uuid === type
@@ -180,12 +181,25 @@ module Tapioca
                  defined?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array) &&
                    ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array === type
                }
-            "T::Array[#{type_for_activerecord_value(column_type.subtype)}]"
+            "T::Array[#{type_for_activerecord_value(column_type.subtype, column_nullability:)}]"
           else
-            ActiveModelTypeHelper.type_for(column_type)
+            as_non_nilable_if_persisted_and_not_nullable(
+              ActiveModelTypeHelper.type_for(column_type),
+              column_nullability: column_nullability,
+            )
           end
         end
 
+        sig { params(base_type: String, column_nullability: T::Boolean).returns(String) }
+        def as_non_nilable_if_persisted_and_not_nullable(base_type, column_nullability:)
+          # It's possible that when ActiveModel::Type::Value is used, the signature being reflected on in
+          # ActiveModelTypeHelper.type_for(type_value) may say the type can be nilable. However, if the type is
+          # persisted and the column is not nullable, we can assume it's not nilable.
+          return as_non_nilable_type(base_type) if @column_type_option.persisted? && !column_nullability
+
+          base_type
+        end
+
         sig { params(column_type: ActiveRecord::Enum::EnumType).returns(String) }
         def enum_setter_type(column_type)
           # In Rails < 7 this method is private. When support for that is dropped we can call the method directly

data/lib/tapioca/helpers/test/dsl_compiler.rb

@@ -1,6 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "tapioca/dsl"
 require "tapioca/helpers/test/content"
 require "tapioca/helpers/test/isolation"
 require "tapioca/helpers/test/template"

data/lib/tapioca/internal.rb

@@ -19,24 +19,24 @@ require "netrc"
 require "parallel"
 require "pathname"
 require "shellwords"
-require "spoom"
 require "tempfile"
 require "thor"
 require "yaml"
 require "yard-sorbet"
 
 require "tapioca/runtime/dynamic_mixin_compiler"
-require "tapioca/helpers/gem_helper"
-
-require "tapioca/helpers/git_attributes"
-require "tapioca/helpers/sorbet_helper"
-require "tapioca/helpers/rbi_helper"
 require "tapioca/sorbet_ext/backcompat_patches"
 require "tapioca/sorbet_ext/name_patch"
 require "tapioca/sorbet_ext/generic_name_patch"
 require "tapioca/sorbet_ext/proc_bind_patch"
 require "tapioca/runtime/generic_type_registry"
 
+require "spoom"
+require "tapioca/helpers/gem_helper"
+require "tapioca/helpers/git_attributes"
+require "tapioca/helpers/sorbet_helper"
+require "tapioca/helpers/rbi_helper"
+
 require "tapioca/helpers/source_uri"
 require "tapioca/helpers/cli_helper"
 require "tapioca/helpers/config_helper"

data/lib/tapioca/loaders/dsl.rb

@@ -63,10 +63,17 @@ module Tapioca
       def load_dsl_compilers
         say("Loading DSL compiler classes... ")
 
+        # Load all built-in compilers
+        Dir.glob("#{Tapioca::LIB_ROOT_DIR}/tapioca/dsl/compilers/*.rb").each do |compiler|
+          require File.expand_path(compiler)
+        end
+
+        # Load all custom compilers exported from gems
         ::Gem.find_files("tapioca/dsl/compilers/*.rb").each do |compiler|
           require File.expand_path(compiler)
         end
 
+        # Load all custom compilers from the project
         Dir.glob([
           "#{@tapioca_path}/generators/**/*.rb", # TODO: Here for backcompat, remove later
           "#{@tapioca_path}/compilers/**/*.rb",

data/lib/tapioca/loaders/loader.rb

@@ -47,12 +47,23 @@ module Tapioca
         ).void
       end
       def load_rails_application(environment_load: false, eager_load: false, app_root: ".", halt_upon_load_error: true)
-        return unless File.exist?("#{app_root}/config/application.rb")
+        return unless File.exist?(File.expand_path("config/application.rb", app_root))
 
-        if environment_load
-          require "./#{app_root}/config/environment"
+        load_path = if environment_load
+          "config/environment"
         else
-          require "./#{app_root}/config/application"
+          "config/application"
+        end
+
+        require File.expand_path(load_path, app_root)
+
+        unless defined?(Rails)
+          say(
+            "\nTried to load the app from `#{load_path}` as a Rails application " \
+              "but the `Rails` constant wasn't defined after loading the file.",
+            :yellow,
+          )
+          return
         end
 
         eager_load_rails_app if eager_load

data/lib/tapioca/rbi_ext/model.rb

@@ -80,65 +80,38 @@ module RBI
       params(
         name: String,
         parameters: T::Array[TypedParam],
-        return_type: String,
+        return_type: T.nilable(String),
         class_method: T::Boolean,
         visibility: RBI::Visibility,
         comments: T::Array[RBI::Comment],
+        block: T.nilable(T.proc.params(node: RBI::Method).void),
       ).void
     end
-    def create_method(name, parameters: [], return_type: "T.untyped", class_method: false, visibility: RBI::Public.new,
-      comments: [])
-      sig_params = parameters.to_h { |param| [param.param.name, param.type] }
-      sig = create_sig(parameters: sig_params, return_type: return_type)
-      create_method_with_sigs(
-        name,
-        sigs: [sig],
-        parameters: parameters.map(&:param),
-        class_method: class_method,
-        visibility: visibility,
-        comments: comments,
-      )
-    end
-
-    sig do
-      params(
-        name: String,
-        sigs: T::Array[RBI::Sig],
-        parameters: T::Array[RBI::Param],
-        class_method: T::Boolean,
-        visibility: RBI::Visibility,
-        comments: T::Array[RBI::Comment],
-      ).void
-    end
-    def create_method_with_sigs(name, sigs:, parameters: [], class_method: false, visibility: RBI::Public.new,
-      comments: [])
+    def create_method(name, parameters: [], return_type: nil, class_method: false, visibility: RBI::Public.new,
+      comments: [], &block)
       return unless Tapioca::RBIHelper.valid_method_name?(name)
 
+      sigs = []
+
+      if !block || !parameters.empty? || return_type
+        # If there is no block, and the params and return type have not been supplied, then
+        # we create a single signature with the given parameters and return type
+        params = parameters.map { |param| RBI::SigParam.new(param.param.name.to_s, param.type) }
+        sigs << RBI::Sig.new(params: params, return_type: return_type || "T.untyped")
+      end
+
       method = RBI::Method.new(
         name,
         sigs: sigs,
-        params: parameters,
+        params: parameters.map(&:param),
         is_singleton: class_method,
         visibility: visibility,
         comments: comments,
+        &block
       )
       self << method
     end
 
-    sig do
-      params(
-        parameters: T::Hash[T.any(String, Symbol), String],
-        type_parameters: T::Array[String],
-        return_type: String,
-      ).returns(RBI::Sig)
-    end
-    def create_sig(parameters:, type_parameters: [], return_type: "T.untyped")
-      params = parameters.map do |name, type|
-        RBI::SigParam.new(name.to_s, type)
-      end
-      RBI::Sig.new(type_params: type_parameters, params: params, return_type: return_type)
-    end
-
     private
 
     sig { returns(T::Hash[String, RBI::Node]) }

data/lib/tapioca/runtime/reflection.rb

@@ -166,7 +166,7 @@ module Tapioca
       end
       def descendants_of(klass)
         result = ObjectSpace.each_object(klass.singleton_class).reject do |k|
-          T.cast(k, Module).singleton_class? || T.unsafe(k) == klass
+          k.singleton_class? || k == klass
         end
 
         T.unsafe(result)

data/lib/tapioca/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Tapioca
-  VERSION = "0.15.0"
+  VERSION = "0.16.0"
 end

data/lib/tapioca.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require "sorbet-runtime"
+require "rubygems/user_interaction"
 
 module Tapioca
   extend T::Sig
@@ -29,6 +30,7 @@ module Tapioca
 
   class Error < StandardError; end
 
+  LIB_ROOT_DIR = T.let(T.must(__dir__), String)
   SORBET_DIR = T.let("sorbet", String)
   SORBET_CONFIG_FILE = T.let("#{SORBET_DIR}/config", String)
   TAPIOCA_DIR = T.let("#{SORBET_DIR}/tapioca", String)

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.15.0
+  version: 0.16.0
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
 - Alan Wu
 - Alexandre Terrasa
 - Peter Zhu
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-06-27 00:00:00.000000000 Z
+date: 2024-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -61,7 +61,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.4
+        version: 0.1.14
     - - "<"
       - !ruby/object:Gem::Version
         version: '0.2'
@@ -71,7 +71,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.4
+        version: 0.1.14
     - - "<"
       - !ruby/object:Gem::Version
         version: '0.2'
@@ -131,7 +131,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email:
 - ruby@shopify.com
 executables:
@@ -186,6 +186,7 @@ files:
 - lib/tapioca/dsl/compilers/active_storage.rb
 - lib/tapioca/dsl/compilers/active_support_concern.rb
 - lib/tapioca/dsl/compilers/active_support_current_attributes.rb
+- lib/tapioca/dsl/compilers/active_support_time_ext.rb
 - lib/tapioca/dsl/compilers/config.rb
 - lib/tapioca/dsl/compilers/frozen_record.rb
 - lib/tapioca/dsl/compilers/graphql_input_object.rb
@@ -274,7 +275,7 @@ licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -289,8 +290,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.13
-signing_key: 
+rubygems_version: 3.5.16
+signing_key:
 specification_version: 4
 summary: A Ruby Interface file generator for gems, core types and the Ruby standard
   library