tapioca 0.4.27 → 0.5.3

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

@@ -0,0 +1,131 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "active_model"
+rescue LoadError
+  return
+end
+
+module Tapioca
+  module Compilers
+    module Dsl
+      # `Tapioca::Compilers::Dsl::ActiveModelAttributes` decorates RBI files for all
+      # classes that use [`ActiveModel::Attributes`](https://edgeapi.rubyonrails.org/classes/ActiveModel/Attributes/ClassMethods.html).
+      #
+      # For example, with the following class:
+      #
+      # ~~~rb
+      # class Shop
+      #   include ActiveModel::Attributes
+      #
+      #   attribute :name, :string
+      # end
+      # ~~~
+      #
+      # this generator will produce an RBI file with the following content:
+      # ~~~rbi
+      # # typed: true
+      #
+      # class Shop
+      #
+      #   sig { returns(T.nilable(::String)) }
+      #   def name; end
+      #
+      #   sig { params(name: T.nilable(::String)).returns(T.nilable(::String)) }
+      #   def name=(name); end
+      # end
+      # ~~~
+      class ActiveModelAttributes < Base
+        extend T::Sig
+
+        sig { override.params(root: RBI::Tree, constant: T.all(Class, ::ActiveModel::Attributes::ClassMethods)).void }
+        def decorate(root, constant)
+          attribute_methods = attribute_methods_for(constant)
+          return if attribute_methods.empty?
+
+          root.create_path(constant) do |klass|
+            attribute_methods.each do |method, attribute_type|
+              generate_method(klass, method, attribute_type)
+            end
+          end
+        end
+
+        sig { override.returns(T::Enumerable[Module]) }
+        def gather_constants
+          all_classes.grep(::ActiveModel::Attributes::ClassMethods)
+        end
+
+        private
+
+        HANDLED_METHOD_TARGETS = T.let(["attribute", "attribute="], T::Array[String])
+
+        sig { params(constant: ::ActiveModel::Attributes::ClassMethods).returns(T::Array[[::String, ::String]]) }
+        def attribute_methods_for(constant)
+          constant.attribute_method_matchers.flat_map do |matcher|
+            constant.attribute_types.map do |name, value|
+              next unless handle_method_matcher?(matcher)
+
+              [matcher.method_name(name), type_for(value)]
+            end.compact
+          end
+        end
+
+        sig do
+          params(matcher: ::ActiveModel::AttributeMethods::ClassMethods::AttributeMethodMatcher)
+            .returns(T::Boolean)
+        end
+        def handle_method_matcher?(matcher)
+          target = if matcher.respond_to?(:method_missing_target)
+            # Pre-Rails 6.0, the field is named "method_missing_target"
+            T.unsafe(matcher).method_missing_target
+          else
+            # Rails 6.0+ has renamed the field to "target"
+            matcher.target
+          end
+
+          HANDLED_METHOD_TARGETS.include?(target.to_s)
+        end
+
+        sig { params(attribute_type_value: ::ActiveModel::Type::Value).returns(::String) }
+        def type_for(attribute_type_value)
+          type = case attribute_type_value
+          when ActiveModel::Type::Boolean
+            "T::Boolean"
+          when ActiveModel::Type::Date
+            "::Date"
+          when ActiveModel::Type::DateTime, ActiveModel::Type::Time
+            "::DateTime"
+          when ActiveModel::Type::Decimal
+            "::BigDecimal"
+          when ActiveModel::Type::Float
+            "::Float"
+          when ActiveModel::Type::Integer
+            "::Integer"
+          when ActiveModel::Type::String
+            "::String"
+          else
+            # we don't want untyped to be wrapped by T.nilable, so just return early
+            return "T.untyped"
+          end
+
+          "T.nilable(#{type})"
+        end
+
+        sig { params(klass: RBI::Scope, method: String, type: String).void }
+        def generate_method(klass, method, type)
+          if method.end_with?("=")
+            parameter = create_param("value", type: type)
+            klass.create_method(
+              method,
+              parameters: [parameter],
+              return_type: type
+            )
+          else
+            klass.create_method(method, return_type: type)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "active_model"
+rescue LoadError
+  return
+end
+
+module Tapioca
+  module Compilers
+    module Dsl
+      # `Tapioca::Compilers::Dsl::ActiveModelSecurePassword` decorates RBI files for all
+      # classes that use [`ActiveModel::SecurePassword`](http://api.rubyonrails.org/classes/ActiveModel/SecurePassword/ClassMethods.html).
+      #
+      # For example, with the following class:
+      #
+      # ~~~rb
+      # class User
+      #   include ActiveModel::SecurePassword
+      #
+      #   has_secure_password
+      #   has_secure_password :token
+      # end
+      # ~~~
+      #
+      # this generator will produce an RBI file with the following content:
+      # ~~~rbi
+      # # typed: true
+      #
+      # class User
+      #   sig { params(unencrypted_password: T.untyped).returns(T.untyped) }
+      #   def authenticate(unencrypted_password); end
+      #
+      #   sig { params(unencrypted_password: T.untyped).returns(T.untyped) }
+      #   def authenticate_password(unencrypted_password); end
+      #
+      #   sig { params(unencrypted_password: T.untyped).returns(T.untyped) }
+      #   def authenticate_token(unencrypted_password); end
+      #
+      #   sig { returns(T.untyped) }
+      #   def password; end
+      #
+      #   sig { params(unencrypted_password: T.untyped).returns(T.untyped) }
+      #   def password=(unencrypted_password); end
+      #
+      #   sig { params(unencrypted_password: T.untyped).returns(T.untyped) }
+      #   def password_confirmation=(unencrypted_password); end
+      #
+      #   sig { returns(T.untyped) }
+      #   def token; end
+      #
+      #   sig { params(unencrypted_password: T.untyped).returns(T.untyped) }
+      #   def token=(unencrypted_password); end
+      #
+      #   sig { params(unencrypted_password: T.untyped).returns(T.untyped) }
+      #   def token_confirmation=(unencrypted_password); end
+      # end
+      # ~~~
+      class ActiveModelSecurePassword < Base
+        extend T::Sig
+
+        sig do
+          override
+            .params(root: RBI::Tree, constant: T.all(Class, ::ActiveModel::SecurePassword::ClassMethods))
+            .void
+        end
+        def decorate(root, constant)
+          instance_methods_modules = if constant < ActiveModel::SecurePassword::InstanceMethodsOnActivation
+            # pre Rails 6.0, this used to be a single static module
+            [ActiveModel::SecurePassword::InstanceMethodsOnActivation]
+          else
+            # post Rails 6.0, this is now using a dynmaic module builder pattern
+            # and we can have multiple different ones included into the model
+            constant.ancestors.grep(ActiveModel::SecurePassword::InstanceMethodsOnActivation)
+          end
+
+          return if instance_methods_modules.empty?
+
+          methods = instance_methods_modules.flat_map { |mod| mod.instance_methods(false) }
+          return if methods.empty?
+
+          root.create_path(constant) do |klass|
+            methods.each do |method|
+              create_method_from_def(klass, constant.instance_method(method))
+            end
+          end
+        end
+
+        sig { override.returns(T::Enumerable[Module]) }
+        def gather_constants
+          # This selects all classes that are `ActiveModel::SecurePassword::ClassMethods === klass`.
+          # In other words, we select all classes that have `ActiveModel::SecurePassword::ClassMethods`
+          # as an ancestor of its singleton class, i.e. all classes that have extended the
+          # `ActiveModel::SecurePassword::ClassMethods` module.
+          all_classes.grep(::ActiveModel::SecurePassword::ClassMethods)
+        end
+      end
+    end
+  end
+end

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

@@ -1,8 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "parlour"
-
 begin
   require "active_record"
 rescue LoadError
@@ -70,7 +68,7 @@ module Tapioca
       #     sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
       #     def comment_ids=(ids); end
       #
-      #     sig { returns(::ActiveRecord::Associations::CollectionProxy[Comment]) }
+      #     sig { returns(::ActiveRecord::Associations::CollectionProxy[::Comment]) }
       #     def comments; end
       #
       #     sig { params(value: T::Enumerable[::Comment]).void }
@@ -106,11 +104,11 @@ module Tapioca
           T.any(::ActiveRecord::Reflection::ThroughReflection, ::ActiveRecord::Reflection::AssociationReflection)
         end
 
-        sig { override.params(root: Parlour::RbiGenerator::Namespace, constant: T.class_of(ActiveRecord::Base)).void }
+        sig { override.params(root: RBI::Tree, constant: T.class_of(ActiveRecord::Base)).void }
         def decorate(root, constant)
           return if constant.reflections.empty?
 
-          root.path(constant) do |model|
+          root.create_path(constant) do |model|
             module_name = "GeneratedAssociationMethods"
 
             model.create_module(module_name) do |mod|
@@ -124,26 +122,23 @@ 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
 
         private
 
-        sig { params(mod: Parlour::RbiGenerator::Namespace, constant: T.class_of(ActiveRecord::Base)).void }
+        sig { params(mod: RBI::Scope, constant: T.class_of(ActiveRecord::Base)).void }
         def populate_nested_attribute_writers(mod, constant)
           constant.nested_attributes_options.keys.each do |association_name|
-            create_method(
-              mod,
+            mod.create_method(
               "#{association_name}_attributes=",
-              parameters: [
-                Parlour::RbiGenerator::Parameter.new("attributes", type: "T.untyped"),
-              ],
+              parameters: [create_param("attributes", type: "T.untyped")],
               return_type: "T.untyped"
             )
           end
         end
 
-        sig { params(mod: Parlour::RbiGenerator::Namespace, constant: T.class_of(ActiveRecord::Base)).void }
+        sig { params(mod: RBI::Scope, constant: T.class_of(ActiveRecord::Base)).void }
         def populate_associations(mod, constant)
           constant.reflections.each do |association_name, reflection|
             if reflection.collection?
@@ -156,7 +151,7 @@ module Tapioca
 
         sig do
           params(
-            klass: Parlour::RbiGenerator::Namespace,
+            klass: RBI::Scope,
             constant: T.class_of(ActiveRecord::Base),
             association_name: T.any(String, Symbol),
             reflection: ReflectionType
@@ -166,49 +161,41 @@ module Tapioca
           association_class = type_for(constant, reflection)
           association_type = "T.nilable(#{association_class})"
 
-          create_method(
-            klass,
+          klass.create_method(
             association_name.to_s,
             return_type: association_type,
           )
-          create_method(
-            klass,
+          klass.create_method(
             "#{association_name}=",
-            parameters: [
-              Parlour::RbiGenerator::Parameter.new("value", type: association_type),
-            ],
-            return_type: nil
+            parameters: [create_param("value", type: association_type)],
+            return_type: "void"
           )
-          create_method(
-            klass,
+          klass.create_method(
             "reload_#{association_name}",
             return_type: association_type,
           )
           unless reflection.polymorphic?
-            create_method(
-              klass,
+            klass.create_method(
               "build_#{association_name}",
               parameters: [
-                Parlour::RbiGenerator::Parameter.new("*args", type: "T.untyped"),
-                Parlour::RbiGenerator::Parameter.new("&blk", type: "T.untyped"),
+                create_rest_param("args", type: "T.untyped"),
+                create_block_param("blk", type: "T.untyped"),
               ],
               return_type: association_class
             )
-            create_method(
-              klass,
+            klass.create_method(
               "create_#{association_name}",
               parameters: [
-                Parlour::RbiGenerator::Parameter.new("*args", type: "T.untyped"),
-                Parlour::RbiGenerator::Parameter.new("&blk", type: "T.untyped"),
+                create_rest_param("args", type: "T.untyped"),
+                create_block_param("blk", type: "T.untyped"),
               ],
               return_type: association_class
             )
-            create_method(
-              klass,
+            klass.create_method(
               "create_#{association_name}!",
               parameters: [
-                Parlour::RbiGenerator::Parameter.new("*args", type: "T.untyped"),
-                Parlour::RbiGenerator::Parameter.new("&blk", type: "T.untyped"),
+                create_rest_param("args", type: "T.untyped"),
+                create_block_param("blk", type: "T.untyped"),
               ],
               return_type: association_class
             )
@@ -217,7 +204,7 @@ module Tapioca
 
         sig do
           params(
-            klass: Parlour::RbiGenerator::Namespace,
+            klass: RBI::Scope,
             constant: T.class_of(ActiveRecord::Base),
             association_name: T.any(String, Symbol),
             reflection: ReflectionType
@@ -227,30 +214,22 @@ module Tapioca
           association_class = type_for(constant, reflection)
           relation_class = relation_type_for(constant, reflection)
 
-          create_method(
-            klass,
+          klass.create_method(
             association_name.to_s,
             return_type: relation_class,
           )
-          create_method(
-            klass,
+          klass.create_method(
             "#{association_name}=",
-            parameters: [
-              Parlour::RbiGenerator::Parameter.new("value", type: "T::Enumerable[#{association_class}]"),
-            ],
-            return_type: nil,
+            parameters: [create_param("value", type: "T::Enumerable[#{association_class}]")],
+            return_type: "void",
           )
-          create_method(
-            klass,
+          klass.create_method(
             "#{association_name.to_s.singularize}_ids",
             return_type: "T::Array[T.untyped]"
           )
-          create_method(
-            klass,
+          klass.create_method(
             "#{association_name.to_s.singularize}_ids=",
-            parameters: [
-              Parlour::RbiGenerator::Parameter.new("ids", type: "T::Array[T.untyped]"),
-            ],
+            parameters: [create_param("ids", type: "T::Array[T.untyped]")],
             return_type: "T::Array[T.untyped]"
           )
         end
@@ -264,7 +243,7 @@ module Tapioca
         def type_for(constant, reflection)
           return "T.untyped" if !constant.table_exists? || polymorphic_association?(reflection)
 
-          "::#{reflection.klass.name}"
+          T.must(qualified_name_of(reflection.klass))
         end
 
         sig do
@@ -278,7 +257,7 @@ module Tapioca
                                                             polymorphic_association?(reflection)
 
           # Change to: "::#{reflection.klass.name}::ActiveRecord_Associations_CollectionProxy"
-          "::ActiveRecord::Associations::CollectionProxy[#{reflection.klass.name}]"
+          "::ActiveRecord::Associations::CollectionProxy[#{qualified_name_of(reflection.klass)}]"
         end
 
         sig do

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

@@ -1,8 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "parlour"
-
 begin
   require "active_record"
 rescue LoadError
@@ -99,11 +97,11 @@ module Tapioca
       class ActiveRecordColumns < Base
         extend T::Sig
 
-        sig { override.params(root: Parlour::RbiGenerator::Namespace, constant: T.class_of(ActiveRecord::Base)).void }
+        sig { override.params(root: RBI::Tree, constant: T.class_of(ActiveRecord::Base)).void }
         def decorate(root, constant)
           return unless constant.table_exists?
 
-          root.path(constant) do |model|
+          root.create_path(constant) do |model|
             module_name = "GeneratedAttributeMethods"
 
             model.create_module(module_name) do |mod|
@@ -129,34 +127,31 @@ 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
 
         private
 
         sig do
           params(
-            klass: Parlour::RbiGenerator::Namespace,
+            klass: RBI::Scope,
             name: String,
             methods_to_add: T.nilable(T::Array[String]),
-            return_type: T.nilable(String),
+            return_type: String,
             parameters: T::Array[[String, String]]
           ).void
         end
-        def add_method(klass, name, methods_to_add, return_type: nil, parameters: [])
-          create_method(
-            klass,
+        def add_method(klass, name, methods_to_add, return_type: "void", parameters: [])
+          klass.create_method(
             name,
-            parameters: parameters.map do |param, type|
-              Parlour::RbiGenerator::Parameter.new(param, type: type)
-            end,
+            parameters: parameters.map { |param, type| create_param(param, type: type) },
             return_type: return_type
           ) if methods_to_add.nil? || methods_to_add.include?(name)
         end
 
         sig do
           params(
-            klass: Parlour::RbiGenerator::Namespace,
+            klass: RBI::Scope,
             constant: T.class_of(ActiveRecord::Base),
             column_name: String,
             attribute_name: String,
@@ -164,7 +159,7 @@ module Tapioca
           ).void
         end
         def add_methods_for_attribute(klass, constant, column_name, attribute_name = column_name, methods_to_add = nil)
-          getter_type, setter_type = type_for(constant, column_name)
+          getter_type, setter_type = ActiveRecordColumnTypeHelper.new(constant).type_for(column_name)
 
           # Added by ActiveRecord::AttributeMethods::Read
           #
@@ -298,96 +293,6 @@ module Tapioca
           )
         end
 
-        sig do
-          params(
-            constant: T.class_of(ActiveRecord::Base),
-            column_name: String
-          ).returns([String, String])
-        end
-        def type_for(constant, column_name)
-          return ["T.untyped", "T.untyped"] if do_not_generate_strong_types?(constant)
-
-          column_type = constant.attribute_types[column_name]
-
-          getter_type =
-            case column_type
-            when defined?(MoneyColumn) && MoneyColumn::ActiveRecordType
-              "::Money"
-            when ActiveRecord::Type::Integer
-              "::Integer"
-            when ActiveRecord::Type::String
-              "::String"
-            when ActiveRecord::Type::Date
-              "::Date"
-            when ActiveRecord::Type::Decimal
-              "::BigDecimal"
-            when ActiveRecord::Type::Float
-              "::Float"
-            when ActiveRecord::Type::Boolean
-              "T::Boolean"
-            when ActiveRecord::Type::DateTime, ActiveRecord::Type::Time
-              "::DateTime"
-            when ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter
-              "::ActiveSupport::TimeWithZone"
-            else
-              handle_unknown_type(column_type)
-            end
-
-          column = constant.columns_hash[column_name]
-          setter_type = getter_type
-
-          if column&.null
-            return ["T.nilable(#{getter_type})", "T.nilable(#{setter_type})"]
-          end
-
-          if column_name == constant.primary_key ||
-              column_name == "created_at" ||
-              column_name == "updated_at"
-            getter_type = "T.nilable(#{getter_type})"
-          end
-
-          [getter_type, setter_type]
-        end
-
-        sig { params(constant: Module).returns(T::Boolean) }
-        def do_not_generate_strong_types?(constant)
-          Object.const_defined?(:StrongTypeGeneration) &&
-              !(constant.singleton_class < Object.const_get(:StrongTypeGeneration))
-        end
-
-        sig { params(column_type: Object).returns(String) }
-        def handle_unknown_type(column_type)
-          return "T.untyped" unless ActiveModel::Type::Value === column_type
-
-          lookup_return_type_of_method(column_type, :deserialize) ||
-            lookup_return_type_of_method(column_type, :cast) ||
-            lookup_arg_type_of_method(column_type, :serialize) ||
-            "T.untyped"
-        end
-
-        sig { params(column_type: ActiveModel::Type::Value, method: Symbol).returns(T.nilable(String)) }
-        def lookup_return_type_of_method(column_type, method)
-          signature = T::Private::Methods.signature_for_method(column_type.method(method))
-          return unless signature
-
-          return_type = signature.return_type
-          return if return_type == T::Private::Types::Void || return_type == T::Private::Types::NotTyped
-
-          return_type.to_s
-        end
-
-        sig { params(column_type: ActiveModel::Type::Value, method: Symbol).returns(T.nilable(String)) }
-        def lookup_arg_type_of_method(column_type, method)
-          signature = T::Private::Methods.signature_for_method(column_type.method(method))
-          return unless signature
-
-          # Arg types is an array [name, type] entries, so we desctructure the type of
-          # first argument to get the first argument type
-          _, first_argument_type = signature.arg_types.first
-
-          first_argument_type.to_s
-        end
-
         sig { params(type: String).returns(String) }
         def as_nilable_type(type)
           return type if type.start_with?("T.nilable(")

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

@@ -1,8 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "parlour"
-
 begin
   require "active_record"
 rescue LoadError
@@ -60,11 +58,11 @@ module Tapioca
       class ActiveRecordEnum < Base
         extend T::Sig
 
-        sig { override.params(root: Parlour::RbiGenerator::Namespace, constant: T.class_of(::ActiveRecord::Base)).void }
+        sig { override.params(root: RBI::Tree, constant: T.class_of(::ActiveRecord::Base)).void }
         def decorate(root, constant)
           return if constant.defined_enums.empty?
 
-          root.path(constant) do |model|
+          root.create_path(constant) do |model|
             module_name = "EnumMethodsModule"
 
             model.create_module(module_name) do |mod|
@@ -75,14 +73,14 @@ module Tapioca
 
             constant.defined_enums.each do |name, enum_map|
               type = type_for_enum(enum_map)
-              create_method(model, name.pluralize, class_method: true, return_type: type)
+              model.create_method(name.pluralize, class_method: true, return_type: type)
             end
           end
         end
 
         sig { override.returns(T::Enumerable[Module]) }
         def gather_constants
-          ::ActiveRecord::Base.descendants.reject(&:abstract_class?)
+          descendants_of(::ActiveRecord::Base).reject(&:abstract_class?)
         end
 
         private
@@ -93,21 +91,21 @@ module Tapioca
           value_type = if value_type.length == 1
             value_type.first
           else
-            "T.any(#{value_type.join(', ')})"
+            "T.any(#{value_type.join(", ")})"
           end
 
           "T::Hash[T.any(String, Symbol), #{value_type}]"
         end
 
-        sig { params(constant: T.class_of(::ActiveRecord::Base), klass: Parlour::RbiGenerator::Namespace).void }
+        sig { params(constant: T.class_of(::ActiveRecord::Base), klass: RBI::Scope).void }
         def generate_instance_methods(constant, klass)
           methods = constant.send(:_enum_methods_module).instance_methods
 
           methods.each do |method|
             method = method.to_s
-            return_type = "T::Boolean" if method.end_with?("?")
+            return_type = method.end_with?("?") ? "T::Boolean" : "void"
 
-            create_method(klass, method, return_type: return_type)
+            klass.create_method(method, return_type: return_type)
           end
         end
       end