tapioca 0.6.4 → 0.7.0

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

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

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

data/lib/tapioca/dsl/helpers/active_record_column_type_helper.rb

@@ -0,0 +1,114 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Dsl
+    module Helpers
+      class ActiveRecordColumnTypeHelper
+        extend T::Sig
+
+        sig { params(constant: T.class_of(ActiveRecord::Base)).void }
+        def initialize(constant)
+          @constant = constant
+        end
+
+        sig { params(column_name: String).returns([String, String]) }
+        def type_for(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 [as_nilable_type(getter_type), as_nilable_type(setter_type)]
+          end
+
+          if column_name == @constant.primary_key ||
+              column_name == "created_at" ||
+              column_name == "updated_at"
+            getter_type = as_nilable_type(getter_type)
+          end
+
+          [getter_type, setter_type]
+        end
+
+        private
+
+        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(type: String).returns(String) }
+        def as_nilable_type(type)
+          if type.start_with?("T.nilable(") || type == "T.untyped"
+            type
+          else
+            "T.nilable(#{type})"
+          end
+        end
+
+        sig { params(column_type: Object).returns(String) }
+        def handle_unknown_type(column_type)
+          return "T.untyped" unless ActiveModel::Type::Value === column_type
+          return "T.untyped" if Runtime::GenericTypeRegistry.generic_type_instance?(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 = Runtime::Reflection.signature_of(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 = Runtime::Reflection.signature_of(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
+      end
+    end
+  end
+end

data/lib/tapioca/dsl/helpers/active_record_constants_helper.rb

@@ -0,0 +1,29 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module Dsl
+    module Helpers
+      module ActiveRecordConstantsHelper
+        extend T::Sig
+
+        ReflectionType = T.type_alias do
+          T.any(::ActiveRecord::Reflection::ThroughReflection, ::ActiveRecord::Reflection::AssociationReflection)
+        end
+
+        AttributeMethodsModuleName = T.let("GeneratedAttributeMethods", String)
+        AssociationMethodsModuleName = T.let("GeneratedAssociationMethods", String)
+
+        RelationMethodsModuleName = T.let("GeneratedRelationMethods", String)
+        AssociationRelationMethodsModuleName = T.let("GeneratedAssociationRelationMethods", String)
+        CommonRelationMethodsModuleName = T.let("CommonRelationMethods", String)
+
+        RelationClassName = T.let("PrivateRelation", String)
+        RelationWhereChainClassName = T.let("PrivateRelationWhereChain", String)
+        AssociationRelationClassName = T.let("PrivateAssociationRelation", String)
+        AssociationRelationWhereChainClassName = T.let("PrivateAssociationRelationWhereChain", String)
+        AssociationsCollectionProxyClassName = T.let("PrivateCollectionProxy", String)
+      end
+    end
+  end
+end

data/lib/tapioca/{compilers/dsl → dsl/helpers}/param_helper.rb

@@ -2,8 +2,8 @@
 # frozen_string_literal: true
 
 module Tapioca
-  module Compilers
-    module Dsl
+  module Dsl
+    module Helpers
       module ParamHelper
         extend T::Sig