tapioca 0.6.4 → 0.7.2

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

@@ -7,12 +7,12 @@ rescue LoadError
   return
 end
 
-require "tapioca/compilers/dsl/helper/active_record_constants"
+require "tapioca/dsl/helpers/active_record_constants_helper"
 
 module Tapioca
-  module Compilers
-    module Dsl
-      # `Tapioca::Compilers::Dsl::ActiveRecordScope` decorates RBI files for
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::ActiveRecordScope` decorates RBI files for
       # subclasses of `ActiveRecord::Base` which declare
       # [`scope` fields](https://api.rubyonrails.org/classes/ActiveRecord/Scoping/Named/ClassMethods.html#method-i-scope).
       #
@@ -25,7 +25,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
@@ -42,23 +42,20 @@ module Tapioca
       #   end
       # end
       # ~~~
-      class ActiveRecordScope < Base
+      class ActiveRecordScope < Compiler
         extend T::Sig
-        include Helper::ActiveRecordConstants
+        include Helpers::ActiveRecordConstantsHelper
 
-        sig do
-          override.params(
-            root: RBI::Tree,
-            constant: T.class_of(::ActiveRecord::Base)
-          ).void
-        end
-        def decorate(root, constant)
-          method_names = scope_method_names(constant)
+        ConstantType = type_member { { fixed: T.class_of(::ActiveRecord::Base) } }
+
+        sig { override.void }
+        def decorate
+          method_names = scope_method_names
 
           return if method_names.empty?
 
           root.create_path(constant) do |model|
-            relations_enabled = generator_enabled?("ActiveRecordRelations")
+            relations_enabled = compiler_enabled?("ActiveRecordRelations")
 
             relation_methods_module = model.create_module(RelationMethodsModuleName)
             assoc_relation_methods_mod = model.create_module(AssociationRelationMethodsModuleName) if relations_enabled
@@ -84,22 +81,26 @@ module Tapioca
         end
 
         sig { override.returns(T::Enumerable[Module]) }
-        def gather_constants
+        def self.gather_constants
           descendants_of(::ActiveRecord::Base).reject(&:abstract_class?)
         end
 
         private
 
-        sig { params(constant: T.class_of(::ActiveRecord::Base)).returns(T::Array[Symbol]) }
-        def scope_method_names(constant)
+        sig { returns(T::Array[Symbol]) }
+        def scope_method_names
           scope_methods = T.let([], T::Array[Symbol])
+          constant = self.constant
 
           # Keep gathering scope methods until we hit "ActiveRecord::Base"
           until constant == ActiveRecord::Base
             scope_methods.concat(constant.send(:generated_relation_methods).instance_methods(false))
 
+            superclass = superclass_of(constant)
+            break unless superclass
+
             # we are guaranteed to have a superclass that is of type "ActiveRecord::Base"
-            constant = T.cast(constant.superclass, T.class_of(ActiveRecord::Base))
+            constant = T.cast(superclass, T.class_of(ActiveRecord::Base))
           end
 
           scope_methods

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

@@ -5,14 +5,14 @@ begin
   require "activerecord-typedstore"
 rescue LoadError
   # means ActiveRecord::TypedStore 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::ActiveRecordTypedStore` generates RBI files for Active Record models that use
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::ActiveRecordTypedStore` generates RBI files for Active Record models that use
       # [`ActiveRecord::TypedStore`](https://github.com/byroot/activerecord-typedstore) features.
       #
       # For example, with the following ActiveRecord class:
@@ -28,7 +28,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
@@ -87,18 +87,13 @@ module Tapioca
       #   end
       # end
       # ~~~
-      class ActiveRecordTypedStore < Base
+      class ActiveRecordTypedStore < Compiler
         extend T::Sig
 
-        sig do
-          override
-            .params(
-              root: RBI::Tree,
-              constant: T.class_of(::ActiveRecord::Base)
-            )
-            .void
-        end
-        def decorate(root, constant)
+        ConstantType = type_member { { fixed: T.class_of(::ActiveRecord::Base) } }
+
+        sig { override.void }
+        def decorate
           stores = constant.typed_stores
           return if stores.values.flat_map(&:accessors).empty?
 
@@ -118,7 +113,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.include?(ActiveRecord::TypedStore::Behavior)
           end

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

@@ -8,9 +8,9 @@ rescue LoadError
 end
 
 module Tapioca
-  module Compilers
-    module Dsl
-      # `Tapioca::Compilers::Dsl::ActiveResource` decorates RBI files for subclasses of
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::ActiveResource` decorates RBI files for subclasses of
       # [`ActiveResource::Base`](https://github.com/rails/activeresource) which declare
       # `schema` fields.
       #
@@ -24,7 +24,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
@@ -58,11 +58,13 @@ module Tapioca
       #   def year?; end
       # end
       # ~~~
-      class ActiveResource < Base
+      class ActiveResource < Compiler
         extend T::Sig
 
-        sig { override.params(root: RBI::Tree, constant: T.class_of(::ActiveResource::Base)).void }
-        def decorate(root, constant)
+        ConstantType = type_member { { fixed: T.class_of(::ActiveResource::Base) } }
+
+        sig { override.void }
+        def decorate
           return if constant.schema.blank?
 
           root.create_path(constant) do |resource|
@@ -73,7 +75,7 @@ module Tapioca
         end
 
         sig { override.returns(T::Enumerable[Module]) }
-        def gather_constants
+        def self.gather_constants
           descendants_of(::ActiveResource::Base)
         end
 

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

@@ -9,9 +9,9 @@ rescue LoadError
 end
 
 module Tapioca
-  module Compilers
-    module Dsl
-      # `Tapioca::Compilers::Dsl::ActiveStorage` decorates RBI files for subclasses of
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::ActiveStorage` decorates RBI files for subclasses of
       # `ActiveRecord::Base` that declare [one](https://edgeguides.rubyonrails.org/active_storage_overview.html#has-one-attached)
       # or [many](https://edgeguides.rubyonrails.org/active_storage_overview.html#has-many-attached) attachments.
       #
@@ -24,7 +24,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
       # # typed: strong
@@ -43,14 +43,18 @@ module Tapioca
       #   def photo=(attachable); end
       # end
       # ~~~
-      class ActiveStorage < Base
+      class ActiveStorage < Compiler
         extend T::Sig
 
-        sig do
-          override.params(root: RBI::Tree,
-            constant: T.all(Module, ::ActiveStorage::Reflection::ActiveRecordExtensions::ClassMethods)).void
+        ConstantType = type_member do
+          {
+            fixed: T.all(Module,
+              ::ActiveStorage::Reflection::ActiveRecordExtensions::ClassMethods),
+          }
         end
-        def decorate(root, constant)
+
+        sig { override.void }
+        def decorate
           return if constant.reflect_on_all_attachments.empty?
 
           root.create_path(constant) do |scope|
@@ -71,7 +75,7 @@ module Tapioca
         end
 
         sig { override.returns(T::Enumerable[Module]) }
-        def gather_constants
+        def self.gather_constants
           descendants_of(::ActiveRecord::Base)
             .reject(&:abstract_class?)
             .grep(::ActiveStorage::Reflection::ActiveRecordExtensions::ClassMethods)

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

@@ -1,8 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "tapioca/compilers/sorbet"
-
 begin
   require "active_support"
 rescue LoadError
@@ -10,9 +8,9 @@ rescue LoadError
 end
 
 module Tapioca
-  module Compilers
-    module Dsl
-      # `Tapioca::Compilers::Dsl::ActiveSupportConcern` generates RBI files for classes that both `extend`
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::ActiveSupportConcern` generates RBI files for classes that both `extend`
       # `ActiveSupport::Concern` and `include` another class that extends `ActiveSupport::Concern`
       #
       # For example for the following hierarchy:
@@ -35,7 +33,7 @@ module Tapioca
       # end
       # ~~~
       #
-      # this generator will produce the RBI file `concern.rbi` with the following content:
+      # this compiler will produce the RBI file `concern.rbi` with the following content:
       #
       # ~~~rbi
       # # typed: true
@@ -43,12 +41,14 @@ module Tapioca
       #   mixes_in_class_methods(::Foo::ClassMethods)
       # end
       # ~~~
-      class ActiveSupportConcern < Base
+      class ActiveSupportConcern < Compiler
         extend T::Sig
 
-        sig { override.params(root: RBI::Tree, constant: Module).void }
-        def decorate(root, constant)
-          dependencies = linearized_dependencies_of(constant)
+        ConstantType = type_member { { fixed: Module } }
+
+        sig { override.void }
+        def decorate
+          dependencies = linearized_dependencies
 
           mixed_in_class_methods = dependencies
             .uniq # Deduplicate
@@ -67,7 +67,7 @@ module Tapioca
         end
 
         sig { override.returns(T::Enumerable[Module]) }
-        def gather_constants
+        def self.gather_constants
           # Find all Modules that are:
           all_modules.select do |mod|
             # named (i.e. not anonymous)
@@ -81,15 +81,20 @@ module Tapioca
           end
         end
 
+        sig { params(concern: Module).returns(T::Array[Module]) }
+        def self.dependencies_of(concern)
+          concern.instance_variable_get(:@_dependencies)
+        end
+
         private
 
         sig { params(concern: Module).returns(T::Array[Module]) }
         def dependencies_of(concern)
-          concern.instance_variable_get(:@_dependencies)
+          self.class.dependencies_of(concern)
         end
 
         sig { params(concern: Module).returns(T::Array[Module]) }
-        def linearized_dependencies_of(concern)
+        def linearized_dependencies(concern = constant)
           # Grab all the dependencies of the concern
           dependencies = dependencies_of(concern)
 
@@ -97,7 +102,7 @@ module Tapioca
           dependencies.flat_map do |dependency|
             # Linearize dependencies of the current dependency,
             # which, itself, is a concern
-            linearized_dependencies_of(dependency) << dependency
+            linearized_dependencies(dependency) << dependency
           end
         end
       end

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

@@ -10,9 +10,9 @@ rescue LoadError
 end
 
 module Tapioca
-  module Compilers
-    module Dsl
-      # `Tapioca::Compilers::Dsl::ActiveSupportCurrentAttributes` decorates RBI files for all
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::ActiveSupportCurrentAttributes` decorates RBI files for all
       # subclasses of
       # [`ActiveSupport::CurrentAttributes`](https://api.rubyonrails.org/classes/ActiveSupport/CurrentAttributes.html).
       #
@@ -35,7 +35,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
       #
@@ -59,20 +59,15 @@ module Tapioca
       #   def self.helper; end
       # end
       # ~~~
-      class ActiveSupportCurrentAttributes < Base
+      class ActiveSupportCurrentAttributes < Compiler
         extend T::Sig
 
-        sig do
-          override
-            .params(
-              root: RBI::Tree,
-              constant: T.class_of(::ActiveSupport::CurrentAttributes)
-            )
-            .void
-        end
-        def decorate(root, constant)
-          dynamic_methods = dynamic_methods_for(constant)
-          instance_methods = instance_methods_for(constant) - dynamic_methods
+        ConstantType = type_member { { fixed: T.class_of(::ActiveSupport::CurrentAttributes) } }
+
+        sig { override.void }
+        def decorate
+          dynamic_methods = dynamic_methods_of_constant
+          instance_methods = instance_methods_of_constant - dynamic_methods
           return if dynamic_methods.empty? && instance_methods.empty?
 
           root.create_path(constant) do |current_attributes|
@@ -94,19 +89,19 @@ module Tapioca
         end
 
         sig { override.returns(T::Enumerable[Module]) }
-        def gather_constants
+        def self.gather_constants
           descendants_of(::ActiveSupport::CurrentAttributes)
         end
 
         private
 
-        sig { params(constant: T.class_of(::ActiveSupport::CurrentAttributes)).returns(T::Array[Symbol]) }
-        def dynamic_methods_for(constant)
+        sig { returns(T::Array[Symbol]) }
+        def dynamic_methods_of_constant
           constant.instance_variable_get(:@generated_attribute_methods)&.instance_methods(false) || []
         end
 
-        sig { params(constant: T.class_of(::ActiveSupport::CurrentAttributes)).returns(T::Array[Symbol]) }
-        def instance_methods_for(constant)
+        sig { returns(T::Array[Symbol]) }
+        def instance_methods_of_constant
           constant.instance_methods(false)
         end
 

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

@@ -8,9 +8,9 @@ rescue LoadError
 end
 
 module Tapioca
-  module Compilers
-    module Dsl
-      # `Tapioca::Compilers::Dsl::Config` generates RBI files for classes generated by the
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::Config` generates RBI files for classes generated by the
       # [`config`](https://github.com/rubyconfig/config) gem.
       #
       # The gem creates a `Config::Options` instance based on the settings files and/or
@@ -32,7 +32,7 @@ module Tapioca
       #   config.const_name = "AppSettings"
       # end
       # ```
-      # this generator will produce the following RBI file:
+      # this compiler will produce the following RBI file:
       # ```rbi
       # AppSettings = T.let(T.unsafe(nil), AppSettingsConfigOptions)
       #
@@ -44,13 +44,15 @@ module Tapioca
       #   def github=(value); end
       # end
       # ```
-      class Config < Base
+      class Config < Compiler
         extend T::Sig
 
         CONFIG_OPTIONS_SUFFIX = "ConfigOptions"
 
-        sig { override.params(root: RBI::Tree, constant: Module).void }
-        def decorate(root, constant)
+        ConstantType = type_member { { fixed: Module } }
+
+        sig { override.void }
+        def decorate
           # The constant we are given is the specialized config options type
           option_class_name = constant.name
           return unless option_class_name
@@ -75,7 +77,7 @@ module Tapioca
             # enumerates the entries, we don't make any assumptions about their
             # types.
             mod.create_extend("T::Generic")
-            mod.create_type_member("Elem", value: "type_member(fixed: T.untyped)")
+            mod.create_type_variable("Elem", type: "type_member", fixed: "T.untyped")
 
             method_names.each do |method_name|
               # Create getter method
@@ -95,7 +97,7 @@ module Tapioca
         end
 
         sig { override.returns(T::Enumerable[Module]) }
-        def gather_constants
+        def self.gather_constants
           name = ::Config.const_name
           return [] unless Object.const_defined?(name)
 

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

@@ -8,9 +8,9 @@ rescue LoadError
 end
 
 module Tapioca
-  module Compilers
-    module Dsl
-      # `Tapioca::Compilers::Dsl::FrozenRecord` generates RBI files for subclasses of
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::FrozenRecord` generates RBI files for subclasses of
       # [`FrozenRecord::Base`](https://github.com/byroot/frozen_record).
       #
       # For example, with the following FrozenRecord class:
@@ -33,7 +33,7 @@ module Tapioca
       #   last_name:  Lord
       # ~~~
       #
-      # this generator will produce the RBI file `student.rbi` with the following content:
+      # this compiler will produce the RBI file `student.rbi` with the following content:
       #
       # ~~~rbi
       # # Student.rbi
@@ -62,11 +62,13 @@ module Tapioca
       #   end
       # end
       # ~~~
-      class FrozenRecord < Base
+      class FrozenRecord < Compiler
         extend T::Sig
 
-        sig { override.params(root: RBI::Tree, constant: T.class_of(::FrozenRecord::Base)).void }
-        def decorate(root, constant)
+        ConstantType = type_member { { fixed: T.class_of(::FrozenRecord::Base) } }
+
+        sig { override.void }
+        def decorate
           attributes = constant.attributes
           return if attributes.empty?
 
@@ -82,19 +84,19 @@ module Tapioca
 
             record.create_include(module_name)
 
-            decorate_scopes(constant, record)
+            decorate_scopes(record)
           end
         end
 
         sig { override.returns(T::Enumerable[Module]) }
-        def gather_constants
+        def self.gather_constants
           descendants_of(::FrozenRecord::Base).reject(&:abstract_class?)
         end
 
         private
 
-        sig { params(constant: T.class_of(::FrozenRecord::Base), record: RBI::Scope).void }
-        def decorate_scopes(constant, record)
+        sig { params(record: RBI::Scope).void }
+        def decorate_scopes(record)
           scopes = T.unsafe(constant).__tapioca_scope_names
           return if scopes.nil?
 

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
@@ -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}"
@@ -215,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)