tapioca 0.4.23 → 0.5.0

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

@@ -1,8 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "parlour"
-
 begin
   require "action_controller"
 rescue LoadError
@@ -72,38 +70,54 @@ module Tapioca
 
         sig do
           override
-            .params(root: Parlour::RbiGenerator::Namespace, constant: T.class_of(::ActionController::Base))
+            .params(root: RBI::Tree, constant: T.class_of(::ActionController::Base))
             .void
         end
         def decorate(root, constant)
+          helpers_module = constant._helpers
+          proxied_helper_methods = constant._helper_methods.map(&:to_s).map(&:to_sym)
+
           helper_proxy_name = "HelperProxy"
           helper_methods_name = "HelperMethods"
-          proxied_helper_methods = constant._helper_methods.map(&:to_s).map(&:to_sym)
 
           # Define the helpers method
-          root.path(constant) do |controller|
-            create_method(controller, 'helpers', return_type: helper_proxy_name)
+          root.create_path(constant) do |controller|
+            controller.create_method("helpers", return_type: helper_proxy_name)
 
             # Create helper method module
             controller.create_module(helper_methods_name) do |helper_methods|
-              helpers_module = constant._helpers
+              # If the controller has no helper defined, then it just inherits
+              # the Action Controlller base helper methods module, so we should
+              # just add that as an include and stop doing more processing.
+              if helpers_module.name == "ActionController::Base::HelperMethods"
+                next helper_methods.create_include(T.must(qualified_name_of(helpers_module)))
+              end
 
+              # Find all the included helper modules and generate an include
+              # for each of those helper modules
               gather_includes(helpers_module).each do |ancestor|
                 helper_methods.create_include(ancestor)
               end
 
+              # Generate a method definition in the helper module for each
+              # helper method defined via the `helper_method` call in the controller.
               helpers_module.instance_methods(false).each do |method_name|
                 method = if proxied_helper_methods.include?(method_name)
-                  constant.instance_method(method_name)
+                  helper_method_proxy_target(constant, method_name)
                 else
                   helpers_module.instance_method(method_name)
                 end
-                create_method_from_def(helper_methods, method)
+
+                if method
+                  create_method_from_def(helper_methods, method)
+                else
+                  create_unknown_proxy_method(helper_methods, method_name)
+                end
               end
             end
 
             # Create helper proxy class
-            controller.create_class(helper_proxy_name, superclass: "::ActionView::Base") do |proxy|
+            controller.create_class(helper_proxy_name, superclass_name: "::ActionView::Base") do |proxy|
               proxy.create_include(helper_methods_name)
             end
           end
@@ -111,16 +125,42 @@ module Tapioca
 
         sig { override.returns(T::Enumerable[Module]) }
         def gather_constants
-          ::ActionController::Base.descendants.reject(&:abstract?).select(&:name)
+          descendants_of(::ActionController::Base).reject(&:abstract?).select(&:name)
         end
 
         private
 
+        sig do
+          params(
+            constant: T.class_of(::ActionController::Base),
+            method_name: Symbol
+          ).returns(T.nilable(UnboundMethod))
+        end
+        def helper_method_proxy_target(constant, method_name)
+          # Lookup the proxy target method only if it is defined as a public/protected or private method.
+          if constant.method_defined?(method_name) || constant.private_method_defined?(method_name)
+            constant.instance_method(method_name)
+          end
+        end
+
+        sig { params(helper_methods: RBI::Scope, method_name: Symbol).void }
+        def create_unknown_proxy_method(helper_methods, method_name)
+          helper_methods.create_method(
+            method_name.to_s,
+            parameters: [
+              create_rest_param("args", type: "T.untyped"),
+              create_kw_rest_param("kwargs", type: "T.untyped"),
+              create_block_param("blk", type: "T.untyped"),
+            ],
+            return_type: "T.untyped"
+          )
+        end
+
         sig { params(mod: Module).returns(T::Array[String]) }
         def gather_includes(mod)
           mod.ancestors
             .reject { |ancestor| ancestor.is_a?(Class) || ancestor == mod || ancestor.name.nil? }
-            .map { |ancestor| "::#{ancestor.name}" }
+            .map { |ancestor| T.must(qualified_name_of(ancestor)) }
             .reverse
         end
       end

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

@@ -1,8 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "parlour"
-
 begin
   require "action_mailer"
 rescue LoadError
@@ -38,17 +36,16 @@ module Tapioca
       class ActionMailer < Base
         extend T::Sig
 
-        sig { override.params(root: Parlour::RbiGenerator::Namespace, constant: T.class_of(::ActionMailer::Base)).void }
+        sig { override.params(root: RBI::Tree, constant: T.class_of(::ActionMailer::Base)).void }
         def decorate(root, constant)
-          root.path(constant) do |mailer|
+          root.create_path(constant) do |mailer|
             constant.action_methods.to_a.each do |mailer_method|
               method_def = constant.instance_method(mailer_method)
-              parameters = compile_method_parameters_to_parlour(method_def)
-              create_method(
-                mailer,
+              parameters = compile_method_parameters_to_rbi(method_def)
+              mailer.create_method(
                 mailer_method,
                 parameters: parameters,
-                return_type: '::ActionMailer::MessageDelivery',
+                return_type: "::ActionMailer::MessageDelivery",
                 class_method: true
               )
             end
@@ -57,7 +54,7 @@ module Tapioca
 
         sig { override.returns(T::Enumerable[Module]) }
         def gather_constants
-          ::ActionMailer::Base.descendants.reject(&:abstract?)
+          descendants_of(::ActionMailer::Base).reject(&:abstract?)
         end
       end
     end

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

@@ -1,8 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "parlour"
-
 begin
   require "active_job"
 rescue LoadError
@@ -42,25 +40,23 @@ module Tapioca
       class ActiveJob < Base
         extend T::Sig
 
-        sig { override.params(root: Parlour::RbiGenerator::Namespace, constant: T.class_of(::ActiveJob::Base)).void }
+        sig { override.params(root: RBI::Tree, constant: T.class_of(::ActiveJob::Base)).void }
         def decorate(root, constant)
-          root.path(constant) do |job|
-            next unless constant.instance_methods(false).include?(:perform)
+          return unless constant.instance_methods(false).include?(:perform)
 
+          root.create_path(constant) do |job|
             method = constant.instance_method(:perform)
-            parameters = compile_method_parameters_to_parlour(method)
-            return_type = compile_method_return_type_to_parlour(method)
+            parameters = compile_method_parameters_to_rbi(method)
+            return_type = compile_method_return_type_to_rbi(method)
 
-            create_method(
-              job,
+            job.create_method(
               "perform_later",
               parameters: parameters,
               return_type: "T.any(#{constant.name}, FalseClass)",
               class_method: true
             )
 
-            create_method(
-              job,
+            job.create_method(
               "perform_now",
               parameters: parameters,
               return_type: return_type,
@@ -71,7 +67,7 @@ module Tapioca
 
         sig { override.returns(T::Enumerable[Module]) }
         def gather_constants
-          ::ActiveJob::Base.descendants
+          descendants_of(::ActiveJob::Base)
         end
       end
     end

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_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