tapioca 0.16.11 → 0.17.0

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

@@ -126,7 +126,8 @@ module Tapioca
 
         ConstantType = type_member { { fixed: T.class_of(ActiveRecord::Base) } }
 
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           return unless constant.table_exists?
 
@@ -165,7 +166,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             descendants_of(::ActiveRecord::Base).reject(&:abstract_class?)
           end
@@ -175,7 +177,7 @@ module Tapioca
 
         ColumnTypeOption = Helpers::ActiveRecordColumnTypeHelper::ColumnTypeOption
 
-        sig { returns(ColumnTypeOption) }
+        #: -> ColumnTypeOption
         def column_type_option
           @column_type_option ||= T.let(
             ColumnTypeOption.from_options(options) do |value, default_column_type_option|
@@ -188,15 +190,7 @@ module Tapioca
           )
         end
 
-        sig do
-          params(
-            klass: RBI::Scope,
-            name: String,
-            methods_to_add: T.nilable(T::Array[String]),
-            return_type: String,
-            parameters: T::Array[RBI::TypedParam],
-          ).void
-        end
+        #: (RBI::Scope klass, String name, Array[String]? methods_to_add, ?return_type: String, ?parameters: Array[RBI::TypedParam]) -> void
         def add_method(klass, name, methods_to_add, return_type: "void", parameters: [])
           klass.create_method(
             name,
@@ -205,14 +199,7 @@ module Tapioca
           ) if methods_to_add.nil? || methods_to_add.include?(name)
         end
 
-        sig do
-          params(
-            klass: RBI::Scope,
-            attribute_name: String,
-            column_name: String,
-            methods_to_add: T.nilable(T::Array[String]),
-          ).void
-        end
+        #: (RBI::Scope klass, String attribute_name, ?String column_name, ?Array[String]? methods_to_add) -> void
         def add_methods_for_attribute(klass, attribute_name, column_name = attribute_name, methods_to_add = nil)
           getter_type, setter_type = Helpers::ActiveRecordColumnTypeHelper
             .new(constant, column_type_option: column_type_option)
@@ -277,12 +264,20 @@ module Tapioca
             "saved_change_to_#{attribute_name}?",
             methods_to_add,
             return_type: "T::Boolean",
+            parameters: [
+              create_kw_opt_param("from", type: "T.untyped", default: "T.unsafe(nil)"),
+              create_kw_opt_param("to", type: "T.untyped", default: "T.unsafe(nil)"),
+            ],
           )
           add_method(
             klass,
             "will_save_change_to_#{attribute_name}?",
             methods_to_add,
             return_type: "T::Boolean",
+            parameters: [
+              create_kw_opt_param("from", type: "T.untyped", default: "T.unsafe(nil)"),
+              create_kw_opt_param("to", type: "T.untyped", default: "T.unsafe(nil)"),
+            ],
           )
 
           # Added by ActiveModel::Dirty
@@ -299,8 +294,8 @@ module Tapioca
             methods_to_add,
             return_type: "T::Boolean",
             parameters: [
-              create_kw_opt_param("from", type: setter_type, default: "T.unsafe(nil)"),
-              create_kw_opt_param("to", type: setter_type, default: "T.unsafe(nil)"),
+              create_kw_opt_param("from", type: "T.untyped", default: "T.unsafe(nil)"),
+              create_kw_opt_param("to", type: "T.untyped", default: "T.unsafe(nil)"),
             ],
           )
           add_method(
@@ -326,8 +321,8 @@ module Tapioca
             methods_to_add,
             return_type: "T::Boolean",
             parameters: [
-              create_kw_opt_param("from", type: setter_type, default: "T.unsafe(nil)"),
-              create_kw_opt_param("to", type: setter_type, default: "T.unsafe(nil)"),
+              create_kw_opt_param("from", type: "T.untyped", default: "T.unsafe(nil)"),
+              create_kw_opt_param("to", type: "T.untyped", default: "T.unsafe(nil)"),
             ],
           )
           add_method(

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

@@ -69,7 +69,8 @@ module Tapioca
 
         ConstantType = type_member { { fixed: T.all(T.class_of(ActiveRecord::Base), Extensions::ActiveRecord) } }
 
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           return if constant.__tapioca_delegated_types.nil?
 
@@ -90,7 +91,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             descendants_of(::ActiveRecord::Base).reject(&:abstract_class?)
           end
@@ -98,7 +100,7 @@ module Tapioca
 
         private
 
-        sig { params(mod: RBI::Scope, role: Symbol, types: T::Array[String]).void }
+        #: (RBI::Scope mod, Symbol role, Array[String] types) -> void
         def populate_role_accessors(mod, role, types)
           mod.create_method(
             "#{role}_name",
@@ -119,14 +121,14 @@ module Tapioca
           )
         end
 
-        sig { params(mod: RBI::Scope, role: Symbol, types: T::Array[String], options: T::Hash[Symbol, T.untyped]).void }
+        #: (RBI::Scope mod, Symbol role, Array[String] types, Hash[Symbol, untyped] options) -> void
         def populate_type_helpers(mod, role, types, options)
           types.each do |type|
             populate_type_helper(mod, role, type, options)
           end
         end
 
-        sig { params(mod: RBI::Scope, role: Symbol, type: String, options: T::Hash[Symbol, T.untyped]).void }
+        #: (RBI::Scope mod, Symbol role, String type, Hash[Symbol, untyped] options) -> void
         def populate_type_helper(mod, role, type, options)
           singular   = type.tableize.tr("/", "_").singularize
           query      = "#{singular}?"

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

@@ -54,7 +54,8 @@ module Tapioca
 
         ConstantType = type_member { { fixed: T.class_of(::ActiveRecord::Base) } }
 
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           return if constant.defined_enums.empty?
 
@@ -77,7 +78,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             descendants_of(::ActiveRecord::Base)
           end
@@ -85,7 +87,7 @@ module Tapioca
 
         private
 
-        sig { params(enum_map: T::Hash[T.untyped, T.untyped]).returns(String) }
+        #: (Hash[untyped, untyped] enum_map) -> String
         def type_for_enum(enum_map)
           value_type = enum_map.values.map { |v| v.class.name }.uniq
           value_type = if value_type.length == 1
@@ -97,7 +99,7 @@ module Tapioca
           "T::Hash[T.any(String, Symbol), #{value_type}]"
         end
 
-        sig { params(klass: RBI::Scope).void }
+        #: (RBI::Scope klass) -> void
         def generate_instance_methods(klass)
           methods = constant.send(:_enum_methods_module).instance_methods
 

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

@@ -39,7 +39,8 @@ module Tapioca
         ConstantType = type_member { { fixed: T.class_of(ActiveSupport::TestCase) } }
         MISSING = Object.new
 
-        sig { override.void }
+        # @override
+        #: -> void
         def decorate
           method_names = if fixture_loader.respond_to?(:fixture_sets)
             method_names_from_lazy_fixture_loader
@@ -60,7 +61,8 @@ module Tapioca
         class << self
           extend T::Sig
 
-          sig { override.returns(T::Enumerable[Module]) }
+          # @override
+          #: -> T::Enumerable[Module]
           def gather_constants
             return [] unless defined?(Rails.application) && Rails.application
 
@@ -70,35 +72,32 @@ module Tapioca
 
         private
 
-        sig { returns(T::Class[ActiveRecord::TestFixtures]) }
+        #: -> Class[ActiveRecord::TestFixtures]
         def fixture_loader
-          @fixture_loader ||= T.let(
-            Class.new do
-              T.unsafe(self).include(ActiveRecord::TestFixtures)
-
-              if respond_to?(:fixture_paths=)
-                T.unsafe(self).fixture_paths = [Rails.root.join("test", "fixtures")]
-              else
-                T.unsafe(self).fixture_path = Rails.root.join("test", "fixtures")
-              end
+          @fixture_loader ||= Class.new do
+            T.unsafe(self).include(ActiveRecord::TestFixtures)
 
-              # https://github.com/rails/rails/blob/7c70791470fc517deb7c640bead9f1b47efb5539/activerecord/lib/active_record/test_fixtures.rb#L46
-              singleton_class.define_method(:file_fixture_path) do
-                Rails.root.join("test", "fixtures", "files")
-              end
+            if respond_to?(:fixture_paths=)
+              T.unsafe(self).fixture_paths = [Rails.root.join("test", "fixtures")]
+            else
+              T.unsafe(self).fixture_path = Rails.root.join("test", "fixtures")
+            end
+
+            # https://github.com/rails/rails/blob/7c70791470fc517deb7c640bead9f1b47efb5539/activerecord/lib/active_record/test_fixtures.rb#L46
+            singleton_class.define_method(:file_fixture_path) do
+              Rails.root.join("test", "fixtures", "files")
+            end
 
-              T.unsafe(self).fixtures(:all)
-            end,
-            T.nilable(T::Class[ActiveRecord::TestFixtures]),
-          )
+            T.unsafe(self).fixtures(:all)
+          end #: Class[ActiveRecord::TestFixtures]?
         end
 
-        sig { returns(T::Array[String]) }
+        #: -> Array[String]
         def method_names_from_lazy_fixture_loader
           T.unsafe(fixture_loader).fixture_sets.keys
         end
 
-        sig { returns(T::Array[String]) }
+        #: -> Array[String]
         def method_names_from_eager_fixture_loader
           fixture_loader.ancestors # get all ancestors from class that includes AR fixtures
             .drop(1) # drop the anonymous class itself from the array
@@ -108,7 +107,7 @@ module Tapioca
             end
         end
 
-        sig { params(mod: RBI::Scope, name: String).void }
+        #: (RBI::Scope mod, String name) -> void
         def create_fixture_method(mod, name)
           return_type = return_type_for_fixture(name)
           mod.create_method(name) do |node|
@@ -135,7 +134,7 @@ module Tapioca
           end
         end
 
-        sig { params(fixture_name: String).returns(String) }
+        #: (String fixture_name) -> String
         def return_type_for_fixture(fixture_name)
           fixture_class_mapping_from_fixture_files[fixture_name] ||
             fixture_class_from_fixture_set(fixture_name) ||
@@ -143,7 +142,7 @@ module Tapioca
             "T.untyped"
         end
 
-        sig { params(fixture_name: String).returns(T.nilable(String)) }
+        #: (String fixture_name) -> String?
         def fixture_class_from_fixture_set(fixture_name)
           # only rails 7.1+ support fixture sets so this is conditional
           return unless fixture_loader.respond_to?(:fixture_sets)
@@ -157,54 +156,47 @@ module Tapioca
           model_name
         end
 
-        sig { returns(T::Hash[String, String]) }
+        #: -> Hash[String, String]
         def fixture_class_from_active_record_base_class_mapping
-          @fixture_class_mapping ||= T.let(
-            begin
-              ActiveRecord::Base.descendants.each_with_object({}) do |model_class, mapping|
-                class_name = model_class.name
+          @fixture_class_mapping ||=
+            ActiveRecord::Base.descendants.each_with_object({}) do |model_class, mapping|
+              class_name = model_class.name
 
-                fixture_name = class_name.underscore.gsub("/", "_")
-                fixture_name = fixture_name.pluralize if ActiveRecord::Base.pluralize_table_names
+              fixture_name = class_name.underscore.gsub("/", "_")
+              fixture_name = fixture_name.pluralize if ActiveRecord::Base.pluralize_table_names
 
-                mapping[fixture_name] = class_name
+              mapping[fixture_name] = class_name
 
-                mapping
-              end
-            end,
-            T.nilable(T::Hash[String, String]),
-          )
+              mapping
+            end #: Hash[String, String]?
         end
 
-        sig { returns(T::Hash[String, String]) }
+        #: -> Hash[String, String]
         def fixture_class_mapping_from_fixture_files
-          @fixture_file_class_mapping ||= T.let(
-            begin
-              fixture_paths = if T.unsafe(fixture_loader).respond_to?(:fixture_paths)
-                T.unsafe(fixture_loader).fixture_paths
-              else
-                T.unsafe(fixture_loader).fixture_path
-              end
+          @fixture_file_class_mapping ||= begin
+            fixture_paths = if T.unsafe(fixture_loader).respond_to?(:fixture_paths)
+              T.unsafe(fixture_loader).fixture_paths
+            else
+              T.unsafe(fixture_loader).fixture_path
+            end
 
-              Array(fixture_paths).each_with_object({}) do |path, mapping|
-                Dir["#{path}{.yml,/{**,*}/*.yml}"].select do |file|
-                  next unless ::File.file?(file)
+            Array(fixture_paths).each_with_object({}) do |path, mapping|
+              Dir["#{path}{.yml,/{**,*}/*.yml}"].select do |file|
+                next unless ::File.file?(file)
 
-                  ActiveRecord::FixtureSet::File.open(file) do |fh|
-                    fixture_name = file.delete_prefix(path.to_s).delete_prefix("/").delete_suffix(".yml")
-                    next unless fh.model_class
+                ActiveRecord::FixtureSet::File.open(file) do |fh|
+                  fixture_name = file.delete_prefix(path.to_s).delete_prefix("/").delete_suffix(".yml")
+                  next unless fh.model_class
 
-                    mapping[fixture_name] = fh.model_class
-                  rescue ActiveRecord::Fixture::FormatError
-                    # For fixtures that are not associated to any models and just contain raw data or fixtures that
-                    # contain invalid formatting, we want to skip them and avoid crashing
-                    mapping[fixture_name] = MISSING
-                  end
+                  mapping[fixture_name] = fh.model_class
+                rescue ActiveRecord::Fixture::FormatError
+                  # For fixtures that are not associated to any models and just contain raw data or fixtures that
+                  # contain invalid formatting, we want to skip them and avoid crashing
+                  mapping[fixture_name] = MISSING
                 end
               end
-            end,
-            T.nilable(T::Hash[String, String]),
-          )
+            end
+          end #: Hash[String, String]?
         end
       end
     end