tapioca 0.5.6 → 0.6.0

data/lib/tapioca/compilers/dsl/active_record_associations.rb

@@ -7,6 +7,8 @@ rescue LoadError
   return
 end
 
+require "tapioca/compilers/dsl/helper/active_record_constants"
+
 module Tapioca
   module Compilers
     module Dsl
@@ -99,6 +101,23 @@ module Tapioca
       # ~~~
       class ActiveRecordAssociations < Base
         extend T::Sig
+        include Helper::ActiveRecordConstants
+
+        class SourceReflectionError < StandardError
+        end
+
+        class MissingConstantError < StandardError
+          extend T::Sig
+
+          sig { returns(String) }
+          attr_reader :class_name
+
+          sig { params(class_name: String).void }
+          def initialize(class_name)
+            @class_name = class_name
+            super
+          end
+        end
 
         ReflectionType = T.type_alias do
           T.any(::ActiveRecord::Reflection::ThroughReflection, ::ActiveRecord::Reflection::AssociationReflection)
@@ -109,14 +128,12 @@ module Tapioca
           return if constant.reflections.empty?
 
           root.create_path(constant) do |model|
-            module_name = "GeneratedAssociationMethods"
-
-            model.create_module(module_name) do |mod|
+            model.create_module(AssociationMethodsModuleName) do |mod|
               populate_nested_attribute_writers(mod, constant)
               populate_associations(mod, constant)
             end
 
-            model.create_include(module_name)
+            model.create_include(AssociationMethodsModuleName)
           end
         end
 
@@ -146,6 +163,14 @@ module Tapioca
             else
               populate_single_assoc_getter_setter(mod, constant, association_name, reflection)
             end
+          rescue SourceReflectionError
+            add_error(<<~MSG.strip)
+              Cannot generate association `#{reflection.name}` on `#{constant}` since the source of the through association is missing.
+            MSG
+          rescue MissingConstantError => error
+            add_error(<<~MSG.strip)
+              Cannot generate association `#{declaration(reflection)}` on `#{constant}` since the constant `#{error.class_name}` does not exist.
+            MSG
           end
         end
 
@@ -241,11 +266,61 @@ module Tapioca
           ).returns(String)
         end
         def type_for(constant, reflection)
+          validate_reflection!(reflection)
+
           return "T.untyped" if !constant.table_exists? || polymorphic_association?(reflection)
 
           T.must(qualified_name_of(reflection.klass))
         end
 
+        sig do
+          params(
+            reflection: ReflectionType
+          ).void
+        end
+        def validate_reflection!(reflection)
+          # Check existence of source reflection, first, since, calling
+          # `.klass` also tries to go through the source reflection
+          # and fails with a cryptic error, otherwise.
+          if reflection.through_reflection?
+            raise SourceReflectionError unless reflection.source_reflection
+          end
+
+          # For non-polymorphic reflections, `.klass` should not be raising
+          # a `NameError`.
+          unless reflection.polymorphic?
+            reflection.klass
+          end
+        rescue NameError
+          class_name = if reflection.through_reflection?
+            reflection.send(:delegate_reflection).class_name
+          else
+            reflection.class_name
+          end
+
+          raise MissingConstantError, class_name
+        end
+
+        sig { params(reflection: ReflectionType).returns(T.nilable(String)) }
+        def declaration(reflection)
+          case reflection
+          when ActiveRecord::Reflection::HasOneReflection
+            "has_one :#{reflection.name}"
+          when ActiveRecord::Reflection::HasManyReflection
+            "has_many :#{reflection.name}"
+          when ActiveRecord::Reflection::HasAndBelongsToManyReflection
+            "has_and_belongs_to_many :#{reflection.name}"
+          when ActiveRecord::Reflection::BelongsToReflection
+            "belongs_to :#{reflection.name}"
+          when ActiveRecord::Reflection::ThroughReflection
+            delegate_reflection = reflection.send(:delegate_reflection)
+            declaration = declaration(delegate_reflection)
+            through_name = delegate_reflection.options[:through]
+
+            "#{declaration}, through: :#{through_name}"
+          end
+        end
+
         sig do
           params(
             constant: T.class_of(ActiveRecord::Base),
@@ -253,11 +328,22 @@ module Tapioca
           ).returns(String)
         end
         def relation_type_for(constant, reflection)
-          "ActiveRecord::Associations::CollectionProxy" if !constant.table_exists? ||
-                                                            polymorphic_association?(reflection)
+          validate_reflection!(reflection)
+
+          relations_enabled = generator_enabled?("ActiveRecordRelations")
+          polymorphic_association = !constant.table_exists? || polymorphic_association?(reflection)
 
-          # Change to: "::#{reflection.klass.name}::ActiveRecord_Associations_CollectionProxy"
-          "::ActiveRecord::Associations::CollectionProxy[#{qualified_name_of(reflection.klass)}]"
+          if relations_enabled
+            if polymorphic_association
+              "ActiveRecord::Associations::CollectionProxy"
+            else
+              "#{qualified_name_of(reflection.klass)}::#{AssociationsCollectionProxyClassName}"
+            end
+          elsif polymorphic_association
+            "ActiveRecord::Associations::CollectionProxy[T.untyped]"
+          else
+            "::ActiveRecord::Associations::CollectionProxy[#{qualified_name_of(reflection.klass)}]"
+          end
         end
 
         sig do

data/lib/tapioca/compilers/dsl/active_record_columns.rb

@@ -7,6 +7,8 @@ rescue LoadError
   return
 end
 
+require "tapioca/compilers/dsl/helper/active_record_constants"
+
 module Tapioca
   module Compilers
     module Dsl
@@ -96,15 +98,14 @@ module Tapioca
       # ~~~
       class ActiveRecordColumns < Base
         extend T::Sig
+        include Helper::ActiveRecordConstants
 
         sig { override.params(root: RBI::Tree, constant: T.class_of(ActiveRecord::Base)).void }
         def decorate(root, constant)
           return unless constant.table_exists?
 
           root.create_path(constant) do |model|
-            module_name = "GeneratedAttributeMethods"
-
-            model.create_module(module_name) do |mod|
+            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)
@@ -121,7 +122,7 @@ module Tapioca
               end
             end
 
-            model.create_include(module_name)
+            model.create_include(AttributeMethodsModuleName)
           end
         end