tapioca 0.6.4 → 0.7.2

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

@@ -7,14 +7,14 @@ 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::ActiveRecordAssociations` refines RBI files for subclasses of
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::ActiveRecordAssociations` refines RBI files for subclasses of
       # [`ActiveRecord::Base`](https://api.rubyonrails.org/classes/ActiveRecord/Base.html).
-      # This generator is only responsible for defining the methods that would be created for the associations that
+      # This compiler is only responsible for defining the methods that would be created for the associations that
       # are defined in the Active Record model.
       #
       # For example, with the following model class:
@@ -29,7 +29,7 @@ module Tapioca
       # end
       # ~~~
       #
-      # this generator will produce the following methods in the RBI file
+      # this compiler will produce the following methods in the RBI file
       # `post.rbi`:
       #
       # ~~~rbi
@@ -99,9 +99,9 @@ module Tapioca
       #   end
       # end
       # ~~~
-      class ActiveRecordAssociations < Base
+      class ActiveRecordAssociations < Compiler
         extend T::Sig
-        include Helper::ActiveRecordConstants
+        include Helpers::ActiveRecordConstantsHelper
 
         class SourceReflectionError < StandardError
         end
@@ -119,18 +119,16 @@ module Tapioca
           end
         end
 
-        ReflectionType = T.type_alias do
-          T.any(::ActiveRecord::Reflection::ThroughReflection, ::ActiveRecord::Reflection::AssociationReflection)
-        end
+        ConstantType = type_member { { fixed: T.class_of(ActiveRecord::Base) } }
 
-        sig { override.params(root: RBI::Tree, constant: T.class_of(ActiveRecord::Base)).void }
-        def decorate(root, constant)
+        sig { override.void }
+        def decorate
           return if constant.reflections.empty?
 
           root.create_path(constant) do |model|
             model.create_module(AssociationMethodsModuleName) do |mod|
-              populate_nested_attribute_writers(mod, constant)
-              populate_associations(mod, constant)
+              populate_nested_attribute_writers(mod)
+              populate_associations(mod)
             end
 
             model.create_include(AssociationMethodsModuleName)
@@ -138,14 +136,14 @@ 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(mod: RBI::Scope, constant: T.class_of(ActiveRecord::Base)).void }
-        def populate_nested_attribute_writers(mod, constant)
+        sig { params(mod: RBI::Scope).void }
+        def populate_nested_attribute_writers(mod)
           constant.nested_attributes_options.keys.each do |association_name|
             mod.create_method(
               "#{association_name}_attributes=",
@@ -155,13 +153,13 @@ module Tapioca
           end
         end
 
-        sig { params(mod: RBI::Scope, constant: T.class_of(ActiveRecord::Base)).void }
-        def populate_associations(mod, constant)
+        sig { params(mod: RBI::Scope).void }
+        def populate_associations(mod)
           constant.reflections.each do |association_name, reflection|
             if reflection.collection?
-              populate_collection_assoc_getter_setter(mod, constant, association_name, reflection)
+              populate_collection_assoc_getter_setter(mod, association_name, reflection)
             else
-              populate_single_assoc_getter_setter(mod, constant, association_name, reflection)
+              populate_single_assoc_getter_setter(mod, association_name, reflection)
             end
           rescue SourceReflectionError
             add_error(<<~MSG.strip)
@@ -177,13 +175,12 @@ module Tapioca
         sig do
           params(
             klass: RBI::Scope,
-            constant: T.class_of(ActiveRecord::Base),
             association_name: T.any(String, Symbol),
             reflection: ReflectionType
           ).void
         end
-        def populate_single_assoc_getter_setter(klass, constant, association_name, reflection)
-          association_class = type_for(constant, reflection)
+        def populate_single_assoc_getter_setter(klass, association_name, reflection)
+          association_class = type_for(reflection)
           association_type = as_nilable_type(association_class)
 
           klass.create_method(
@@ -230,14 +227,13 @@ module Tapioca
         sig do
           params(
             klass: RBI::Scope,
-            constant: T.class_of(ActiveRecord::Base),
             association_name: T.any(String, Symbol),
             reflection: ReflectionType
           ).void
         end
-        def populate_collection_assoc_getter_setter(klass, constant, association_name, reflection)
-          association_class = type_for(constant, reflection)
-          relation_class = relation_type_for(constant, reflection)
+        def populate_collection_assoc_getter_setter(klass, association_name, reflection)
+          association_class = type_for(reflection)
+          relation_class = relation_type_for(reflection)
 
           klass.create_method(
             association_name.to_s,
@@ -261,11 +257,10 @@ module Tapioca
 
         sig do
           params(
-            constant: T.class_of(ActiveRecord::Base),
             reflection: ReflectionType
           ).returns(String)
         end
-        def type_for(constant, reflection)
+        def type_for(reflection)
           validate_reflection!(reflection)
 
           return "T.untyped" if !constant.table_exists? || polymorphic_association?(reflection)
@@ -323,14 +318,13 @@ module Tapioca
 
         sig do
           params(
-            constant: T.class_of(ActiveRecord::Base),
             reflection: ReflectionType
           ).returns(String)
         end
-        def relation_type_for(constant, reflection)
+        def relation_type_for(reflection)
           validate_reflection!(reflection)
 
-          relations_enabled = generator_enabled?("ActiveRecordRelations")
+          relations_enabled = compiler_enabled?("ActiveRecordRelations")
           polymorphic_association = !constant.table_exists? || polymorphic_association?(reflection)
 
           if relations_enabled

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

@@ -7,14 +7,15 @@ rescue LoadError
   return
 end
 
-require "tapioca/compilers/dsl/helper/active_record_constants"
+require "tapioca/dsl/helpers/active_record_column_type_helper"
+require "tapioca/dsl/helpers/active_record_constants_helper"
 
 module Tapioca
-  module Compilers
-    module Dsl
-      # `Tapioca::Compilers::Dsl::ActiveRecordColumns` refines RBI files for subclasses of
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::ActiveRecordColumns` refines RBI files for subclasses of
       # [`ActiveRecord::Base`](https://api.rubyonrails.org/classes/ActiveRecord/Base.html).
-      # This generator is only responsible for defining the attribute methods that would be
+      # This compiler is only responsible for defining the attribute methods that would be
       # created for the columns that are defined in the Active Record model.
       #
       # For example, with the following model class:
@@ -35,7 +36,7 @@ module Tapioca
       # end
       # ~~~
       #
-      # this generator will produce the following methods in the RBI file
+      # this compiler will produce the following methods in the RBI file
       # `post.rbi`:
       #
       # ~~~rbi
@@ -96,19 +97,21 @@ module Tapioca
       #   end
       # end
       # ~~~
-      class ActiveRecordColumns < Base
+      class ActiveRecordColumns < Compiler
         extend T::Sig
-        include Helper::ActiveRecordConstants
+        include Helpers::ActiveRecordConstantsHelper
 
-        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
           return unless constant.table_exists?
 
           root.create_path(constant) do |model|
             model.create_module(AttributeMethodsModuleName) do |mod|
               constant.columns_hash.each_key do |column_name|
                 column_name = column_name.to_s
-                add_methods_for_attribute(mod, constant, column_name)
+                add_methods_for_attribute(mod, column_name)
               end
 
               constant.attribute_aliases.each do |attribute_name, column_name|
@@ -124,7 +127,7 @@ module Tapioca
                 old_method_names = patterns.map { |m| m.method_name(column_name) }
                 methods_to_add = new_method_names - old_method_names
 
-                add_methods_for_attribute(mod, constant, column_name, attribute_name, methods_to_add)
+                add_methods_for_attribute(mod, column_name, attribute_name, methods_to_add)
               end
             end
 
@@ -133,7 +136,7 @@ module Tapioca
         end
 
         sig { override.returns(T::Enumerable[Module]) }
-        def gather_constants
+        def self.gather_constants
           descendants_of(::ActiveRecord::Base).reject(&:abstract_class?)
         end
 
@@ -159,14 +162,13 @@ module Tapioca
         sig do
           params(
             klass: RBI::Scope,
-            constant: T.class_of(ActiveRecord::Base),
             column_name: String,
             attribute_name: String,
             methods_to_add: T.nilable(T::Array[String])
           ).void
         end
-        def add_methods_for_attribute(klass, constant, column_name, attribute_name = column_name, methods_to_add = nil)
-          getter_type, setter_type = ActiveRecordColumnTypeHelper.new(constant).type_for(column_name)
+        def add_methods_for_attribute(klass, column_name, attribute_name = column_name, methods_to_add = nil)
+          getter_type, setter_type = Helpers::ActiveRecordColumnTypeHelper.new(constant).type_for(column_name)
 
           # Added by ActiveRecord::AttributeMethods::Read
           #

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

@@ -5,14 +5,14 @@ begin
   require "active_record"
 rescue LoadError
   # means ActiveRecord 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::ActiveRecordEnum` decorates RBI files for subclasses of
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::ActiveRecordEnum` decorates RBI files for subclasses of
       # `ActiveRecord::Base` which declare [`enum` fields](https://api.rubyonrails.org/classes/ActiveRecord/Enum.html).
       #
       # For example, with the following `ActiveRecord::Base` subclass:
@@ -23,7 +23,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
@@ -55,18 +55,20 @@ module Tapioca
       #   end
       # end
       # ~~~
-      class ActiveRecordEnum < Base
+      class ActiveRecordEnum < Compiler
         extend T::Sig
 
-        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
           return if constant.defined_enums.empty?
 
           root.create_path(constant) do |model|
             module_name = "EnumMethodsModule"
 
             model.create_module(module_name) do |mod|
-              generate_instance_methods(constant, mod)
+              generate_instance_methods(mod)
             end
 
             model.create_include(module_name)
@@ -79,7 +81,7 @@ module Tapioca
         end
 
         sig { override.returns(T::Enumerable[Module]) }
-        def gather_constants
+        def self.gather_constants
           descendants_of(::ActiveRecord::Base)
         end
 
@@ -97,8 +99,8 @@ module Tapioca
           "T::Hash[T.any(String, Symbol), #{value_type}]"
         end
 
-        sig { params(constant: T.class_of(::ActiveRecord::Base), klass: RBI::Scope).void }
-        def generate_instance_methods(constant, klass)
+        sig { params(klass: RBI::Scope).void }
+        def generate_instance_methods(klass)
           methods = constant.send(:_enum_methods_module).instance_methods
 
           methods.each do |method|

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

@@ -11,9 +11,9 @@ rescue LoadError
 end
 
 module Tapioca
-  module Compilers
-    module Dsl
-      # `Tapioca::Compilers::Dsl::ActiveRecordFixtures` decorates RBIs for test fixture methods
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::ActiveRecordFixtures` decorates RBIs for test fixture methods
       # that are created dynamically by Rails.
       #
       # For example, given an application with a posts table, we can have a fixture file
@@ -25,7 +25,7 @@ module Tapioca
       # ~~~
       #
       # Rails will allow us to invoke `posts(:first_post)` in tests to get the fixture record.
-      # The generated RBI by this generator will produce the following
+      # The generated RBI by this compiler will produce the following
       #
       # ~~~rbi
       # # test_case.rbi
@@ -35,11 +35,13 @@ module Tapioca
       #   def posts(*fixture_names); end
       # end
       # ~~~
-      class ActiveRecordFixtures < Base
+      class ActiveRecordFixtures < Compiler
         extend T::Sig
 
-        sig { override.params(root: RBI::Tree, constant: T.class_of(ActiveSupport::TestCase)).void }
-        def decorate(root, constant)
+        ConstantType = type_member { { fixed: T.class_of(ActiveSupport::TestCase) } }
+
+        sig { override.void }
+        def decorate
           method_names = fixture_loader.ancestors # get all ancestors from class that includes AR fixtures
             .drop(1) # drop the anonymous class itself from the array
             .reject(&:name) # only collect anonymous ancestors because fixture methods are always on an anonymous module
@@ -57,7 +59,9 @@ module Tapioca
         end
 
         sig { override.returns(T::Enumerable[Module]) }
-        def gather_constants
+        def self.gather_constants
+          return [] unless Rails.application
+
           [ActiveSupport::TestCase]
         end