tapioca 0.6.1 → 0.7.0

data/lib/tapioca/commands.rb

@@ -0,0 +1,13 @@
+# typed: true
+# frozen_string_literal: true
+
+module Tapioca
+  module Commands
+    autoload :Command, "tapioca/commands/command"
+    autoload :Dsl, "tapioca/commands/dsl"
+    autoload :Init, "tapioca/commands/init"
+    autoload :Gem, "tapioca/commands/gem"
+    autoload :Require, "tapioca/commands/require"
+    autoload :Todo, "tapioca/commands/todo"
+  end
+end

data/lib/tapioca/dsl/compiler.rb

@@ -0,0 +1,185 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "rbi"
+require "tapioca/rbi_ext/model"
+require "tapioca/rbi_formatter"
+require "tapioca/dsl/helpers/param_helper"
+require "tapioca/dsl/pipeline"
+
+module Tapioca
+  module Dsl
+    class Compiler
+      extend T::Sig
+      extend T::Helpers
+      extend T::Generic
+
+      include Runtime::Reflection
+      extend Runtime::Reflection
+
+      ConstantType = type_member(upper: Module)
+
+      abstract!
+
+      sig { returns(ConstantType) }
+      attr_reader :constant
+
+      sig { returns(RBI::Tree) }
+      attr_reader :root
+
+      sig { params(pipeline: Tapioca::Dsl::Pipeline, root: RBI::Tree, constant: ConstantType).void }
+      def initialize(pipeline, root, constant)
+        @pipeline = pipeline
+        @root = root
+        @constant = constant
+        @errors = T.let([], T::Array[String])
+      end
+
+      sig { params(constant: Module).returns(T::Boolean) }
+      def self.handles?(constant)
+        processable_constants.include?(constant)
+      end
+
+      sig { params(compiler_name: String).returns(T::Boolean) }
+      def compiler_enabled?(compiler_name)
+        @pipeline.compiler_enabled?(compiler_name)
+      end
+
+      sig { abstract.void }
+      def decorate; end
+
+      sig { abstract.returns(T::Enumerable[Module]) }
+      def self.gather_constants; end
+
+      sig { returns(T::Set[Module]) }
+      def self.processable_constants
+        @processable_constants ||= T.let(
+          Set.new(gather_constants).tap(&:compare_by_identity),
+          T.nilable(T::Set[Module])
+        )
+        T.must(@processable_constants)
+      end
+
+      # NOTE: This should eventually accept an `Error` object or `Exception` rather than simply a `String`.
+      sig { params(error: String).void }
+      def add_error(error)
+        @pipeline.add_error(error)
+      end
+
+      private
+
+      sig { returns(T::Enumerable[Class]) }
+      private_class_method def self.all_classes
+        @all_classes = T.let(@all_classes, T.nilable(T::Enumerable[Class]))
+        @all_classes ||= T.cast(ObjectSpace.each_object(Class), T::Enumerable[Class]).each
+      end
+
+      sig { returns(T::Enumerable[Module]) }
+      private_class_method def self.all_modules
+        @all_modules = T.let(@all_modules, T.nilable(T::Enumerable[Module]))
+        @all_modules ||= T.cast(ObjectSpace.each_object(Module), T::Enumerable[Module]).each
+      end
+
+      # Get the types of each parameter from a method signature
+      sig do
+        params(
+          method_def: T.any(Method, UnboundMethod),
+          signature: T.untyped # as `T::Private::Methods::Signature` is private
+        ).returns(T::Array[String])
+      end
+      def parameters_types_from_signature(method_def, signature)
+        params = T.let([], T::Array[String])
+
+        return method_def.parameters.map { "T.untyped" } unless signature
+
+        # parameters types
+        signature.arg_types.each { |arg_type| params << arg_type[1].to_s }
+
+        # keyword parameters types
+        signature.kwarg_types.each { |_, kwarg_type| params << kwarg_type.to_s }
+
+        # rest parameter type
+        params << signature.rest_type.to_s if signature.has_rest
+
+        # special case `.void` in a proc
+        unless signature.block_name.nil?
+          params << signature.block_type.to_s.gsub("returns(<VOID>)", "void")
+        end
+
+        params
+      end
+
+      sig { params(scope: RBI::Scope, method_def: T.any(Method, UnboundMethod), class_method: T::Boolean).void }
+      def create_method_from_def(scope, method_def, class_method: false)
+        scope.create_method(
+          method_def.name.to_s,
+          parameters: compile_method_parameters_to_rbi(method_def),
+          return_type: compile_method_return_type_to_rbi(method_def),
+          class_method: class_method
+        )
+      end
+
+      include Helpers::ParamHelper
+
+      sig { params(method_def: T.any(Method, UnboundMethod)).returns(T::Array[RBI::TypedParam]) }
+      def compile_method_parameters_to_rbi(method_def)
+        signature = signature_of(method_def)
+        method_def = signature.nil? ? method_def : signature.method
+        method_types = parameters_types_from_signature(method_def, signature)
+
+        parameters = T.let(method_def.parameters, T::Array[[Symbol, T.nilable(Symbol)]])
+
+        parameters.each_with_index.map do |(type, name), index|
+          fallback_arg_name = "_arg#{index}"
+
+          name = name ? name.to_s : fallback_arg_name
+          name = fallback_arg_name unless valid_parameter_name?(name)
+          method_type = T.must(method_types[index])
+
+          case type
+          when :req
+            create_param(name, type: method_type)
+          when :opt
+            create_opt_param(name, type: method_type, default: "T.unsafe(nil)")
+          when :rest
+            create_rest_param(name, type: method_type)
+          when :keyreq
+            create_kw_param(name, type: method_type)
+          when :key
+            create_kw_opt_param(name, type: method_type, default: "T.unsafe(nil)")
+          when :keyrest
+            create_kw_rest_param(name, type: method_type)
+          when :block
+            create_block_param(name, type: method_type)
+          else
+            raise "Unknown type `#{type}`."
+          end
+        end
+      end
+
+      sig { params(method_def: T.any(Method, UnboundMethod)).returns(String) }
+      def compile_method_return_type_to_rbi(method_def)
+        signature = signature_of(method_def)
+        return_type = signature.nil? ? "T.untyped" : name_of_type(signature.return_type)
+        return_type = "void" if return_type == "<VOID>"
+        # Map <NOT-TYPED> to `T.untyped`
+        return_type = "T.untyped" if return_type == "<NOT-TYPED>"
+        return_type
+      end
+
+      sig { params(type: String).returns(String) }
+      def as_nilable_type(type)
+        if type.start_with?("T.nilable(", "::T.nilable(") || type == "T.untyped" || type == "::T.untyped"
+          type
+        else
+          "T.nilable(#{type})"
+        end
+      end
+
+      sig { params(name: String).returns(T::Boolean) }
+      def valid_parameter_name?(name)
+        name.match?(/^[[[:alnum:]]_]+$/)
+      end
+    end
+  end
+end

data/lib/tapioca/{compilers/dsl → dsl/compilers}/aasm.rb

@@ -9,9 +9,9 @@ rescue LoadError
 end
 
 module Tapioca
-  module Compilers
-    module Dsl
-      # `Tapioca::Compilers::Dsl::AASM` generate types for AASM state machines.
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::AASM` generate types for AASM state machines.
       # This gem dynamically defines constants and methods at runtime. For
       # example, given a class:
       #
@@ -37,7 +37,7 @@ module Tapioca
       #   sleeping?, running?, cleaning?
       #   run, run!, run_without_validation!, may_run?
       #
-      class AASM < Tapioca::Compilers::Dsl::Base
+      class AASM < Compiler
         extend T::Sig
 
         # Taken directly from the AASM::Core::Event class, here:
@@ -45,12 +45,14 @@ module Tapioca
         EVENT_CALLBACKS =
           T.let(
             ["after", "after_commit", "after_transaction", "before", "before_transaction", "ensure", "error",
-             "before_success", "success"].freeze,
+             "before_success", "success",].freeze,
             T::Array[String]
           )
 
-        sig { override.params(root: RBI::Tree, constant: T.all(::AASM::ClassMethods, Class)).void }
-        def decorate(root, constant)
+        ConstantType = type_member(fixed: T.all(::AASM::ClassMethods, Class))
+
+        sig { override.void }
+        def decorate
           aasm = constant.aasm
           return if !aasm || aasm.states.empty?
 
@@ -103,7 +105,8 @@ module Tapioca
                   event.create_method(
                     method,
                     parameters: [
-                      create_block_param("block", type: "T.proc.bind(#{constant.name}).void"),
+                      create_opt_param("symbol", type: "T.nilable(Symbol)", default: "nil"),
+                      create_block_param("block", type: "T.nilable(T.proc.bind(#{name_of(constant)}).void)"),
                     ]
                   )
                 end
@@ -113,7 +116,7 @@ module Tapioca
         end
 
         sig { override.returns(T::Enumerable[Module]) }
-        def gather_constants
+        def self.gather_constants
           T.cast(ObjectSpace.each_object(::AASM::ClassMethods), T::Enumerable[Module])
         end
       end

data/lib/tapioca/{compilers/dsl → dsl/compilers}/action_controller_helpers.rb

@@ -8,9 +8,9 @@ rescue LoadError
 end
 
 module Tapioca
-  module Compilers
-    module Dsl
-      # `Tapioca::Compilers::Dsl::ActionControllerHelpers` decorates RBI files for all
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::ActionControllerHelpers` decorates RBI files for all
       # subclasses of [`ActionController::Base`](https://api.rubyonrails.org/classes/ActionController/Helpers.html).
       #
       # For example, with the following `MyHelper` module:
@@ -41,7 +41,7 @@ module Tapioca
       # end
       # ~~~
       #
-      # this generator will produce an RBI file `user_controller.rbi` with the following content:
+      # this compiler will produce an RBI file `user_controller.rbi` with the following content:
       #
       # ~~~rbi
       # # user_controller.rbi
@@ -65,15 +65,13 @@ module Tapioca
       #   def helpers; end
       # end
       # ~~~
-      class ActionControllerHelpers < Base
+      class ActionControllerHelpers < Compiler
         extend T::Sig
 
-        sig do
-          override
-            .params(root: RBI::Tree, constant: T.class_of(::ActionController::Base))
-            .void
-        end
-        def decorate(root, constant)
+        ConstantType = type_member(fixed: T.class_of(::ActionController::Base))
+
+        sig { override.void }
+        def decorate
           helpers_module = constant._helpers
           proxied_helper_methods = constant._helper_methods.map(&:to_s).map(&:to_sym)
 
@@ -103,7 +101,7 @@ module Tapioca
               # 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)
-                  helper_method_proxy_target(constant, method_name)
+                  helper_method_proxy_target(method_name)
                 else
                   helpers_module.instance_method(method_name)
                 end
@@ -124,19 +122,14 @@ module Tapioca
         end
 
         sig { override.returns(T::Enumerable[Module]) }
-        def gather_constants
+        def self.gather_constants
           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)
+        sig { params(method_name: Symbol).returns(T.nilable(UnboundMethod)) }
+        def helper_method_proxy_target(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)

data/lib/tapioca/{compilers/dsl → dsl/compilers}/action_mailer.rb

@@ -8,9 +8,9 @@ rescue LoadError
 end
 
 module Tapioca
-  module Compilers
-    module Dsl
-      # `Tapioca::Compilers::Dsl::ActionMailer` generates RBI files for subclasses of
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::ActionMailer` generates RBI files for subclasses of
       # [`ActionMailer::Base`](https://api.rubyonrails.org/classes/ActionMailer/Base.html).
       #
       # For example, with the following `ActionMailer` subclass:
@@ -23,7 +23,7 @@ module Tapioca
       # end
       # ~~~
       #
-      # this generator will produce the RBI file `notifier_mailer.rbi` with the following content:
+      # this compiler will produce the RBI file `notifier_mailer.rbi` with the following content:
       #
       # ~~~rbi
       # # notifier_mailer.rbi
@@ -33,11 +33,13 @@ module Tapioca
       #   def self.notify_customer(customer_id); end
       # end
       # ~~~
-      class ActionMailer < Base
+      class ActionMailer < Compiler
         extend T::Sig
 
-        sig { override.params(root: RBI::Tree, constant: T.class_of(::ActionMailer::Base)).void }
-        def decorate(root, constant)
+        ConstantType = type_member(fixed: T.class_of(::ActionMailer::Base))
+
+        sig { override.void }
+        def decorate
           root.create_path(constant) do |mailer|
             constant.action_methods.to_a.each do |mailer_method|
               method_def = constant.instance_method(mailer_method)
@@ -53,7 +55,7 @@ module Tapioca
         end
 
         sig { override.returns(T::Enumerable[Module]) }
-        def gather_constants
+        def self.gather_constants
           descendants_of(::ActionMailer::Base).reject(&:abstract?)
         end
       end

data/lib/tapioca/{compilers/dsl → dsl/compilers}/active_job.rb

@@ -8,9 +8,9 @@ rescue LoadError
 end
 
 module Tapioca
-  module Compilers
-    module Dsl
-      # `Tapioca::Compilers::Dsl::ActiveJob` generates RBI files for subclasses of
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::ActiveJob` generates RBI files for subclasses of
       # [`ActiveJob::Base`](https://api.rubyonrails.org/classes/ActiveJob/Base.html).
       #
       # For example, with the following `ActiveJob` subclass:
@@ -24,7 +24,7 @@ module Tapioca
       # end
       # ~~~
       #
-      # this generator will produce the RBI file `notify_user_job.rbi` with the following content:
+      # this compiler will produce the RBI file `notify_user_job.rbi` with the following content:
       #
       # ~~~rbi
       # # notify_user_job.rbi
@@ -37,11 +37,13 @@ module Tapioca
       #   def self.perform_now(user); end
       # end
       # ~~~
-      class ActiveJob < Base
+      class ActiveJob < Compiler
         extend T::Sig
 
-        sig { override.params(root: RBI::Tree, constant: T.class_of(::ActiveJob::Base)).void }
-        def decorate(root, constant)
+        ConstantType = type_member(fixed: T.class_of(::ActiveJob::Base))
+
+        sig { override.void }
+        def decorate
           return unless constant.instance_methods(false).include?(:perform)
 
           root.create_path(constant) do |job|
@@ -52,7 +54,7 @@ module Tapioca
             job.create_method(
               "perform_later",
               parameters: parameters,
-              return_type: "T.any(#{constant.name}, FalseClass)",
+              return_type: "T.any(#{name_of(constant)}, FalseClass)",
               class_method: true
             )
 
@@ -66,7 +68,7 @@ module Tapioca
         end
 
         sig { override.returns(T::Enumerable[Module]) }
-        def gather_constants
+        def self.gather_constants
           descendants_of(::ActiveJob::Base)
         end
       end

data/lib/tapioca/{compilers/dsl → dsl/compilers}/active_model_attributes.rb

@@ -8,9 +8,9 @@ rescue LoadError
 end
 
 module Tapioca
-  module Compilers
-    module Dsl
-      # `Tapioca::Compilers::Dsl::ActiveModelAttributes` decorates RBI files for all
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::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:
@@ -23,7 +23,7 @@ module Tapioca
       # end
       # ~~~
       #
-      # this generator will produce an RBI file with the following content:
+      # this compiler will produce an RBI file with the following content:
       # ~~~rbi
       # # typed: true
       #
@@ -36,12 +36,14 @@ module Tapioca
       #   def name=(name); end
       # end
       # ~~~
-      class ActiveModelAttributes < Base
+      class ActiveModelAttributes < Compiler
         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)
+        ConstantType = type_member(fixed: T.all(Class, ::ActiveModel::Attributes::ClassMethods))
+
+        sig { override.void }
+        def decorate
+          attribute_methods = attribute_methods_for_constant
           return if attribute_methods.empty?
 
           root.create_path(constant) do |klass|
@@ -52,7 +54,7 @@ module Tapioca
         end
 
         sig { override.returns(T::Enumerable[Module]) }
-        def gather_constants
+        def self.gather_constants
           all_classes.grep(::ActiveModel::Attributes::ClassMethods)
         end
 
@@ -60,28 +62,34 @@ module Tapioca
 
         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|
+        sig { returns(T::Array[[::String, ::String]]) }
+        def attribute_methods_for_constant
+          patterns = if constant.respond_to?(:attribute_method_patterns)
+            # https://github.com/rails/rails/pull/44367
+            T.unsafe(constant).attribute_method_patterns
+          else
+            constant.attribute_method_matchers
+          end
+          patterns.flat_map do |pattern|
             constant.attribute_types.map do |name, value|
-              next unless handle_method_matcher?(matcher)
+              next unless handle_method_pattern?(pattern)
 
-              [matcher.method_name(name), type_for(value)]
+              [pattern.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)
+        sig { params(pattern: T.untyped).returns(T::Boolean) }
+        def handle_method_pattern?(pattern)
+          target = if pattern.respond_to?(:method_missing_target)
             # Pre-Rails 6.0, the field is named "method_missing_target"
-            T.unsafe(matcher).method_missing_target
-          else
+            T.unsafe(pattern).method_missing_target
+          elsif pattern.respond_to?(:target)
             # Rails 6.0+ has renamed the field to "target"
-            matcher.target
+            pattern.target
+          else
+            # https://github.com/rails/rails/pull/44367/files
+            T.unsafe(pattern).proxy_target
           end
 
           HANDLED_METHOD_TARGETS.include?(target.to_s)
@@ -109,7 +117,7 @@ module Tapioca
             return "T.untyped"
           end
 
-          "T.nilable(#{type})"
+          as_nilable_type(type)
         end
 
         sig { params(klass: RBI::Scope, method: String, type: String).void }

data/lib/tapioca/{compilers/dsl → dsl/compilers}/active_model_secure_password.rb

@@ -8,9 +8,9 @@ rescue LoadError
 end
 
 module Tapioca
-  module Compilers
-    module Dsl
-      # `Tapioca::Compilers::Dsl::ActiveModelSecurePassword` decorates RBI files for all
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::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:
@@ -24,7 +24,7 @@ module Tapioca
       # end
       # ~~~
       #
-      # this generator will produce an RBI file with the following content:
+      # this compiler will produce an RBI file with the following content:
       # ~~~rbi
       # # typed: true
       #
@@ -57,15 +57,13 @@ module Tapioca
       #   def token_confirmation=(unencrypted_password); end
       # end
       # ~~~
-      class ActiveModelSecurePassword < Base
+      class ActiveModelSecurePassword < Compiler
         extend T::Sig
 
-        sig do
-          override
-            .params(root: RBI::Tree, constant: T.all(Class, ::ActiveModel::SecurePassword::ClassMethods))
-            .void
-        end
-        def decorate(root, constant)
+        ConstantType = type_member(fixed: T.all(Class, ::ActiveModel::SecurePassword::ClassMethods))
+
+        sig { override.void }
+        def decorate
           instance_methods_modules = if constant < ActiveModel::SecurePassword::InstanceMethodsOnActivation
             # pre Rails 6.0, this used to be a single static module
             [ActiveModel::SecurePassword::InstanceMethodsOnActivation]
@@ -88,7 +86,7 @@ module Tapioca
         end
 
         sig { override.returns(T::Enumerable[Module]) }
-        def gather_constants
+        def self.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