tapioca 0.6.1 → 0.7.0

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

@@ -5,14 +5,16 @@ begin
   require "identity_cache"
 rescue LoadError
   # means IdentityCache is not installed,
-  # so let's not even define the generator.
+  # so let's not even define the compiler.
   return
 end
 
+require "tapioca/dsl/helpers/active_record_column_type_helper"
+
 module Tapioca
-  module Compilers
-    module Dsl
-      # `Tapioca::Compilers::DSL::IdentityCache` generates RBI files for Active Record models
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::IdentityCache` generates RBI files for Active Record models
       #  that use `include IdentityCache`.
       # [`IdentityCache`](https://github.com/Shopify/identity_cache) is a blob level caching solution
       # to plug into Active Record.
@@ -31,7 +33,7 @@ module Tapioca
       # end
       # ~~~
       #
-      # this generator will produce the RBI file `post.rbi` with the following content:
+      # this compiler will produce the RBI file `post.rbi` with the following content:
       #
       # ~~~rbi
       # # post.rbi
@@ -59,7 +61,7 @@ module Tapioca
       #   def fetch_by_title_and_review_date(title, review_date, includes: nil); end
       # end
       # ~~~
-      class IdentityCache < Base
+      class IdentityCache < Compiler
         extend T::Sig
 
         COLLECTION_TYPE = T.let(
@@ -67,8 +69,10 @@ module Tapioca
           T.proc.params(type: T.any(Module, String)).returns(String)
         )
 
-        sig { override.params(root: RBI::Tree, constant: T.class_of(::ActiveRecord::Base)).void }
-        def decorate(root, constant)
+        ConstantType = type_member(fixed: T.class_of(::ActiveRecord::Base))
+
+        sig { override.void }
+        def decorate
           caches = constant.send(:all_cached_associations)
           cache_indexes = constant.send(:cache_indexes)
           return if caches.empty? && cache_indexes.empty?
@@ -79,7 +83,7 @@ module Tapioca
             cache_belongs = constant.send(:cached_belongs_tos)
 
             cache_indexes.each do |field|
-              create_fetch_by_methods(field, model, constant)
+              create_fetch_by_methods(field, model)
             end
 
             cache_manys.values.each do |field|
@@ -97,7 +101,7 @@ module Tapioca
         end
 
         sig { override.returns(T::Enumerable[Module]) }
-        def gather_constants
+        def self.gather_constants
           descendants_of(::ActiveRecord::Base).select do |klass|
             klass < ::IdentityCache::WithoutPrimaryIndex
           end
@@ -116,7 +120,7 @@ module Tapioca
           if returns_collection
             COLLECTION_TYPE.call(cache_type)
           else
-            "T.nilable(::#{cache_type})"
+            as_nilable_type(T.must(qualified_name_of(cache_type)))
           end
         rescue ArgumentError
           "T.untyped"
@@ -144,28 +148,26 @@ module Tapioca
         sig do
           params(
             field: T.untyped,
-            klass: RBI::Scope,
-            constant: T.class_of(::ActiveRecord::Base),
+            klass: RBI::Scope
           ).void
         end
-        def create_fetch_by_methods(field, klass, constant)
+        def create_fetch_by_methods(field, klass)
           is_cache_index = field.instance_variable_defined?(:@attribute_proc)
 
           # Both `cache_index` and `cache_attribute` generate aliased methods
-          create_aliased_fetch_by_methods(field, klass, constant)
+          create_aliased_fetch_by_methods(field, klass)
 
           # If the method used was `cache_index` a few extra methods are created
-          create_index_fetch_by_methods(field, klass, constant) if is_cache_index
+          create_index_fetch_by_methods(field, klass) if is_cache_index
         end
 
         sig do
           params(
             field: T.untyped,
-            klass: RBI::Scope,
-            constant: T.class_of(::ActiveRecord::Base),
+            klass: RBI::Scope
           ).void
         end
-        def create_index_fetch_by_methods(field, klass, constant)
+        def create_index_fetch_by_methods(field, klass)
           field_length = field.key_fields.length
           fields_name = field.key_fields.join("_and_")
           name = "fetch_by_#{fields_name}"
@@ -175,18 +177,20 @@ module Tapioca
           parameters << create_kw_opt_param("includes", default: "nil", type: "T.untyped")
 
           if field.unique
+            type = T.must(qualified_name_of(constant))
+
             klass.create_method(
               "#{name}!",
               class_method: true,
               parameters: parameters,
-              return_type: "::#{constant}"
+              return_type: type
             )
 
             klass.create_method(
               name,
               class_method: true,
               parameters: parameters,
-              return_type: "T.nilable(::#{constant})"
+              return_type: as_nilable_type(type)
             )
           else
             klass.create_method(
@@ -213,12 +217,11 @@ module Tapioca
         sig do
           params(
             field: T.untyped,
-            klass: RBI::Scope,
-            constant: T.class_of(::ActiveRecord::Base),
+            klass: RBI::Scope
           ).void
         end
-        def create_aliased_fetch_by_methods(field, klass, constant)
-          type, _ = ActiveRecordColumnTypeHelper.new(constant).type_for(field.alias_name.to_s)
+        def create_aliased_fetch_by_methods(field, klass)
+          type, _ = Helpers::ActiveRecordColumnTypeHelper.new(constant).type_for(field.alias_name.to_s)
           multi_type = type.delete_prefix("T.nilable(").delete_suffix(")").delete_prefix("::")
           length = field.key_fields.length
           suffix = field.send(:fetch_method_suffix)

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

@@ -8,9 +8,9 @@ rescue LoadError
 end
 
 module Tapioca
-  module Compilers
-    module Dsl
-      # `Tapioca::Compilers::Dsl::MixedInClassAttributes` generates RBI files for modules that dynamically use
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::MixedInClassAttributes` generates RBI files for modules that dynamically use
       # `class_attribute` on classes.
       #
       # For example, given the following concern
@@ -25,7 +25,7 @@ module Tapioca
       # end
       # ~~~
       #
-      # this generator will produce the RBI file `taggeable.rbi` with the following content:
+      # this compiler will produce the RBI file `taggeable.rbi` with the following content:
       #
       # ~~~rbi
       # # typed: strong
@@ -48,12 +48,14 @@ module Tapioca
       #   end
       # end
       # ~~~
-      class MixedInClassAttributes < Base
+      class MixedInClassAttributes < Compiler
         extend T::Sig
 
-        sig { override.params(root: RBI::Tree, constant: Module).void }
-        def decorate(root, constant)
-          mixin_compiler = DynamicMixinCompiler.new(constant)
+        ConstantType = type_member(fixed: Module)
+
+        sig { override.void }
+        def decorate
+          mixin_compiler = Runtime::DynamicMixinCompiler.new(constant)
           return if mixin_compiler.empty_attributes?
 
           root.create_path(constant) do |mod|
@@ -62,10 +64,10 @@ module Tapioca
         end
 
         sig { override.returns(T::Enumerable[Module]) }
-        def gather_constants
+        def self.gather_constants
           # Select all non-anonymous modules that have overridden Module.included
           all_modules.select do |mod|
-            !mod.is_a?(Class) && name_of(mod) && Tapioca::Reflection.method_of(mod, :included).owner != Module
+            !mod.is_a?(Class) && name_of(mod) && Runtime::Reflection.method_of(mod, :included).owner != Module
           end
         end
       end

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

@@ -8,9 +8,9 @@ rescue LoadError
 end
 
 module Tapioca
-  module Compilers
-    module Dsl
-      # `Tapioca::Compilers::Dsl::Protobuf` decorates RBI files for subclasses of
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::Protobuf` decorates RBI files for subclasses of
       # [`Google::Protobuf::MessageExts`](https://github.com/protocolbuffers/protobuf/tree/master/ruby).
       #
       # For example, with the following "cart.rb" file:
@@ -28,7 +28,7 @@ module Tapioca
       # end
       # ~~~
       #
-      # this generator will produce the RBI file `cart.rbi` with the following content:
+      # this compiler will produce the RBI file `cart.rbi` with the following content:
       #
       # ~~~rbi
       # # cart.rbi
@@ -60,7 +60,7 @@ module Tapioca
       #   def number_value=(value); end
       # end
       # ~~~
-      class Protobuf < Base
+      class Protobuf < Compiler
         class Field < T::Struct
           prop :name, String
           prop :type, String
@@ -70,8 +70,10 @@ module Tapioca
 
         extend T::Sig
 
-        sig { override.params(root: RBI::Tree, constant: Module).void }
-        def decorate(root, constant)
+        ConstantType = type_member(fixed: Module)
+
+        sig { override.void }
+        def decorate
           root.create_path(constant) do |klass|
             if constant == Google::Protobuf::RepeatedField
               create_type_members(klass, "Elem")
@@ -92,7 +94,7 @@ module Tapioca
         end
 
         sig { override.returns(T::Enumerable[Module]) }
-        def gather_constants
+        def self.gather_constants
           marker = Google::Protobuf::MessageExts::ClassMethods
           results = T.cast(ObjectSpace.each_object(marker).to_a, T::Array[Module])
           results.any? ? results + [Google::Protobuf::RepeatedField, Google::Protobuf::Map] : []

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

@@ -9,9 +9,9 @@ rescue LoadError
 end
 
 module Tapioca
-  module Compilers
-    module Dsl
-      # `Tapioca::Compilers::Dsl::RailsGenerators` generates RBI files for Rails generators
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::RailsGenerators` generates RBI files for Rails generators
       #
       # For example, with the following generator:
       #
@@ -38,7 +38,7 @@ module Tapioca
       #   def skip_comments; end
       # end
       # ~~~
-      class RailsGenerators < Base
+      class RailsGenerators < Compiler
         extend T::Sig
 
         BUILT_IN_MATCHER = T.let(
@@ -46,9 +46,11 @@ module Tapioca
           Regexp
         )
 
-        sig { override.params(root: RBI::Tree, constant: T.class_of(::Rails::Generators::Base)).void }
-        def decorate(root, constant)
-          base_class = base_class_for(constant)
+        ConstantType = type_member(fixed: T.class_of(::Rails::Generators::Base))
+
+        sig { override.void }
+        def decorate
+          base_class = base_class_of_constant
           arguments = constant.arguments - base_class.arguments
           class_options = constant.class_options.reject do |name, option|
             base_class.class_options[name] == option
@@ -63,7 +65,7 @@ module Tapioca
         end
 
         sig { override.returns(T::Enumerable[Module]) }
-        def gather_constants
+        def self.gather_constants
           all_classes.select do |const|
             name = qualified_name_of(const)
 
@@ -84,11 +86,8 @@ module Tapioca
           )
         end
 
-        sig do
-          params(constant: T.class_of(::Rails::Generators::Base))
-            .returns(T.class_of(::Rails::Generators::Base))
-        end
-        def base_class_for(constant)
+        sig { returns(T.class_of(::Rails::Generators::Base)) }
+        def base_class_of_constant
           ancestor = inherited_ancestors_of(constant).find do |klass|
             qualified_name_of(klass)&.match?(BUILT_IN_MATCHER)
           end
@@ -111,7 +110,7 @@ module Tapioca
           if arg.required || arg.default
             type
           else
-            "T.nilable(#{type})"
+            as_nilable_type(type)
           end
         end
       end

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

@@ -8,9 +8,9 @@ rescue LoadError
 end
 
 module Tapioca
-  module Compilers
-    module Dsl
-      # `Tapioca::Compilers::Dsl::SidekiqWorker` generates RBI files classes that include
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::SidekiqWorker` generates RBI files classes that include
       # [`Sidekiq::Worker`](https://github.com/mperham/sidekiq/wiki/Getting-Started).
       #
       # For example, with the following class that includes `Sidekiq::Worker`:
@@ -24,7 +24,7 @@ module Tapioca
       # end
       # ~~~
       #
-      # this generator will produce the RBI file `notifier_worker.rbi` with the following content:
+      # this compiler will produce the RBI file `notifier_worker.rbi` with the following content:
       #
       # ~~~rbi
       # # notifier_worker.rbi
@@ -40,11 +40,13 @@ module Tapioca
       #   def self.perform_in(interval, customer_id); end
       # end
       # ~~~
-      class SidekiqWorker < Base
+      class SidekiqWorker < Compiler
         extend T::Sig
 
-        sig { override.params(root: RBI::Tree, constant: T.class_of(::Sidekiq::Worker)).void }
-        def decorate(root, constant)
+        ConstantType = type_member(fixed: T.class_of(::Sidekiq::Worker))
+
+        sig { override.void }
+        def decorate
           return unless constant.instance_methods.include?(:perform)
 
           root.create_path(constant) do |worker|
@@ -64,14 +66,14 @@ module Tapioca
               *async_params,
             ]
 
-            generate_perform_method(constant, worker, "perform_async", async_params)
-            generate_perform_method(constant, worker, "perform_at", at_params)
-            generate_perform_method(constant, worker, "perform_in", in_params)
+            generate_perform_method(worker, "perform_async", async_params)
+            generate_perform_method(worker, "perform_at", at_params)
+            generate_perform_method(worker, "perform_in", in_params)
           end
         end
 
         sig { override.returns(T::Enumerable[Module]) }
-        def gather_constants
+        def self.gather_constants
           all_classes.select { |c| c < Sidekiq::Worker }
         end
 
@@ -79,13 +81,12 @@ module Tapioca
 
         sig do
           params(
-            constant: T.class_of(::Sidekiq::Worker),
             worker: RBI::Scope,
             method_name: String,
             parameters: T::Array[RBI::TypedParam]
           ).void
         end
-        def generate_perform_method(constant, worker, method_name, parameters)
+        def generate_perform_method(worker, method_name, parameters)
           if constant.method(method_name.to_sym).owner == Sidekiq::Worker::ClassMethods
             worker.create_method(method_name, parameters: parameters, return_type: "String", class_method: true)
           end

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

@@ -5,14 +5,14 @@ begin
   require "smart_properties"
 rescue LoadError
   # means SmartProperties is not installed,
-  # so let's not even define the generator.
+  # so let's not even define the compiler.
   return
 end
 
 module Tapioca
-  module Compilers
-    module Dsl
-      # `Tapioca::Compilers::Dsl::SmartProperties` generates RBI files for classes that include
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::SmartProperties` generates RBI files for classes that include
       # [`SmartProperties`](https://github.com/t6d/smart_properties).
       #
       # For example, with the following class that includes `SmartProperties`:
@@ -29,7 +29,7 @@ module Tapioca
       # end
       # ~~~
       #
-      # this generator will produce the RBI file `post.rbi` with the following content:
+      # this compiler will produce the RBI file `post.rbi` with the following content:
       #
       # ~~~rbi
       # # post.rbi
@@ -60,11 +60,13 @@ module Tapioca
       #   def enabled=(enabled); end
       # end
       # ~~~
-      class SmartProperties < Base
+      class SmartProperties < Compiler
         extend T::Sig
 
-        sig { override.params(root: RBI::Tree, constant: T.class_of(::SmartProperties)).void }
-        def decorate(root, constant)
+        ConstantType = type_member(fixed: T.class_of(::SmartProperties))
+
+        sig { override.void }
+        def decorate
           properties = T.let(
             T.unsafe(constant).properties,
             ::SmartProperties::PropertyCollection
@@ -84,7 +86,7 @@ module Tapioca
         end
 
         sig { override.returns(T::Enumerable[Module]) }
-        def gather_constants
+        def self.gather_constants
           all_modules.select do |c|
             name_of(c) &&
               c != ::SmartProperties::Validations::Ancestor &&
@@ -143,11 +145,8 @@ module Tapioca
             "T.untyped"
           end
 
-          # Early return for "T.untyped", nothing more to do.
-          return type if type == "T.untyped"
-
           might_be_optional = Proc === required || !required
-          type = "T.nilable(#{type})" if might_be_optional
+          type = as_nilable_type(type) if might_be_optional
 
           type
         end

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

@@ -5,15 +5,15 @@ begin
   require "state_machines"
 rescue LoadError
   # means StateMachines is not installed,
-  # so let's not even define the generator.
+  # so let's not even define the compiler.
   return
 end
 
 module Tapioca
-  module Compilers
-    module Dsl
-      # `Tapioca::Compilers::Dsl::StateMachines` generates RBI files for classes that setup a
-      # [`state_machine`](https://github.com/state-machines/state_machines). The generator also
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::StateMachines` generates RBI files for classes that setup a
+      # [`state_machine`](https://github.com/state-machines/state_machines). The compiler also
       # processes the extra methods generated by
       # [StateMachines Active Record](https://github.com/state-machines/state_machines-activerecord)
       # and [StateMachines Active Model](https://github.com/state-machines/state_machines-activemodel)
@@ -38,7 +38,7 @@ module Tapioca
       # end
       # ~~~
       #
-      # this generator will produce the RBI file `vehicle.rbi` with the following content:
+      # this compiler will produce the RBI file `vehicle.rbi` with the following content:
       #
       # ~~~rbi
       # # vehicle.rbi
@@ -115,11 +115,13 @@ module Tapioca
       #   end
       # end
       # ~~~
-      class StateMachines < Base
+      class StateMachines < Compiler
         extend T::Sig
 
-        sig { override.params(root: RBI::Tree, constant: ::StateMachines::ClassMethods).void }
-        def decorate(root, constant)
+        ConstantType = type_member(fixed: T.all(Module, ::StateMachines::ClassMethods))
+
+        sig { override.void }
+        def decorate
           return if constant.state_machines.empty?
 
           root.create_path(T.unsafe(constant)) do |klass|
@@ -159,7 +161,7 @@ module Tapioca
         end
 
         sig { override.returns(T::Enumerable[Module]) }
-        def gather_constants
+        def self.gather_constants
           all_classes.select { |mod| mod < ::StateMachines::InstanceMethods }
         end
 

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

@@ -10,9 +10,9 @@ rescue LoadError
 end
 
 module Tapioca
-  module Compilers
-    module Dsl
-      # `Tapioca::Compilers::Dsl::UrlHelpers` generates RBI files for classes that include or extend
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::UrlHelpers` generates RBI files for classes that include or extend
       # [`Rails.application.routes.url_helpers`](https://api.rubyonrails.org/v5.1.7/classes/ActionDispatch/Routing/UrlFor.html#module-ActionDispatch::Routing::UrlFor-label-URL+generation+for+named+routes).
       #
       # For example, with the following setup:
@@ -32,13 +32,13 @@ module Tapioca
       #   # Use `T.unsafe` so that Sorbet does not complain about a dynamic
       #   # module being included. This allows the `include` to happen properly
       #   # at runtime but Sorbet won't see the include. However, since this
-      #   # generator will generate the proper RBI files for the include,
+      #   # compiler will generate the proper RBI files for the include,
       #   # static type checking will work as expected.
       #   T.unsafe(self).include Rails.application.routes.url_helpers
       # end
       # ~~~
       #
-      # this generator will produce the following RBI files:
+      # this compiler will produce the following RBI files:
       #
       # ~~~rbi
       # # generated_path_helpers_module.rbi
@@ -84,18 +84,20 @@ module Tapioca
       #   include GeneratedUrlHelpersModule
       # end
       # ~~~
-      class UrlHelpers < Base
+      class UrlHelpers < Compiler
         extend T::Sig
 
-        sig { override.params(root: RBI::Tree, constant: Module).void }
-        def decorate(root, constant)
+        ConstantType = type_member(fixed: Module)
+
+        sig { override.void }
+        def decorate
           case constant
           when GeneratedPathHelpersModule.singleton_class, GeneratedUrlHelpersModule.singleton_class
             generate_module_for(root, constant)
           else
             root.create_path(constant) do |mod|
-              create_mixins_for(mod, constant, GeneratedUrlHelpersModule)
-              create_mixins_for(mod, constant, GeneratedPathHelpersModule)
+              create_mixins_for(mod, GeneratedUrlHelpersModule)
+              create_mixins_for(mod, GeneratedPathHelpersModule)
             end
           end
         end
@@ -106,7 +108,7 @@ module Tapioca
         ], T::Array[Module])
 
         sig { override.returns(T::Enumerable[Module]) }
-        def gather_constants
+        def self.gather_constants
           Object.const_set(:GeneratedUrlHelpersModule, Rails.application.routes.named_routes.url_helpers_module)
           Object.const_set(:GeneratedPathHelpersModule, Rails.application.routes.named_routes.path_helpers_module)
 
@@ -140,8 +142,8 @@ module Tapioca
           end
         end
 
-        sig { params(mod: RBI::Scope, constant: Module, helper_module: Module).void }
-        def create_mixins_for(mod, constant, helper_module)
+        sig { params(mod: RBI::Scope, helper_module: Module).void }
+        def create_mixins_for(mod, helper_module)
           include_helper = constant.ancestors.include?(helper_module) || NON_DISCOVERABLE_INCLUDERS.include?(constant)
           extend_helper = constant.singleton_class.ancestors.include?(helper_module)
 
@@ -150,7 +152,7 @@ module Tapioca
         end
 
         sig { params(mod: Module, helper: Module).returns(T::Boolean) }
-        def includes_helper?(mod, helper)
+        private_class_method def self.includes_helper?(mod, helper)
           superclass_ancestors = []
 
           if Class === mod

data/lib/tapioca/dsl/compilers.rb

@@ -0,0 +1,31 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "tapioca/rbi_ext/model"
+require "tapioca/dsl/helpers/param_helper"
+require "tapioca/dsl/pipeline"
+
+module Tapioca
+  module Dsl
+    module Compilers
+      DIRECTORY = T.let(
+        File.expand_path("compilers", __dir__),
+        String
+      )
+
+      # DSL compilers are either built-in to Tapioca and live under the
+      # `Tapioca::Dsl::Compilers` namespace (i.e. this namespace), and
+      # can be referred to by just using the class name, or they live in
+      # a different namespace and can only be referred to using their fully
+      # qualified name. This constant encapsulates that dual lookup when
+      # a compiler needs to be resolved by name.
+      NAMESPACES = T.let(
+        [
+          "#{name}::", # compilers in this namespace
+          "::", # compilers that need to be fully namespaced
+        ],
+        T::Array[String]
+      )
+    end
+  end
+end

data/lib/tapioca/{compilers/dsl → dsl}/extensions/frozen_record.rb

@@ -8,8 +8,8 @@ rescue LoadError
 end
 
 module Tapioca
-  module Compilers
-    module Dsl
+  module Dsl
+    module Compilers
       module Extensions
         module FrozenRecord
           attr_reader :__tapioca_scope_names