activerecord-erd 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 23a0f8d12a11c8f049ed894e5a622c750b7c9045651374ddbb756a107e0bb277
+  data.tar.gz: 42ac36efbd4778b8bf37b7007d396b431a82efe6930e82b377489c77cd168fb6
+SHA512:
+  metadata.gz: 807ef84e86a6a1a30deec9a82719d1dd4ba3c3c74a26edf3dbf9a56b9f0fa576c4b800d4f475e9aa1131020029fbb85e72581fa3ccf86bede1cf75742a190d2c
+  data.tar.gz: d1aed11a20dff4480dacf356b0002e1fb88a7ce74859462bad37cd8e31a16630f5b1f18d63c3a338f2e543bb3d7da1f5eae21d06e7375418e80284cd80ddc0af

data/lib/activerecord-erd/railtie.rb

@@ -0,0 +1,9 @@
+module ActiveRecordERD
+  class Railtie < Rails::Railtie
+    initializer "activerecord-erd.initialize" do
+      ActiveSupport.on_load(:active_record) do
+        ActiveRecord::Base.include(ActiveRecordERD::ERDGenerator)
+      end
+    end
+  end
+end 

data/lib/activerecord-erd/version.rb

@@ -0,0 +1,3 @@
+module ActiveRecordERD
+  VERSION = "0.1.0"
+end 

data/lib/activerecord-erd.rb

@@ -0,0 +1,713 @@
+require "activerecord-erd/version"
+require "active_record"
+
+module ActiveRecordERD
+  module ERDGenerator
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.include(InstanceMethods)
+    end
+
+    module ClassMethods
+      def erd(empty: false)
+        generate_erd(:class, nil, empty)
+      end
+
+      def erd_for_instance(instance, empty: false)
+        generate_erd(:instance, instance, empty)
+      end
+      
+      private
+      
+      # Shared method for generating ERD diagrams
+      def generate_erd(scope, instance = nil, empty = false)
+        # Get all foreign key constraints for this model
+        foreign_keys = connection.foreign_keys(table_name)
+        
+        # Get all associations that have dependent: :destroy
+        dependent_associations = reflect_on_all_associations.select do |assoc|
+          assoc.options[:dependent] == :destroy
+        end
+        
+        # Log all dependent associations
+        Rails.logger.debug("Model #{name} has dependent associations: #{dependent_associations.map(&:name).join(', ')}")
+
+        # Build the ERD diagram
+        diagram = ["erDiagram"]
+        
+        # Track entity counts for boxes
+        entity_counts = {}
+        
+        # Track dependent counts for each model
+        dependent_counts = {}
+        
+        # Track entity metadata for entity boxes
+        entity_metadata = {}
+        
+        # Map of models to show in the diagram
+        models_to_show = {}
+        
+        # Track which models are simple vs complex dependencies
+        simple_dependencies = {}
+        complex_dependencies = {}
+        
+        # Track entities that only have belongs_to relationships with the primary entity
+        belongs_to_only_entities = {}
+        
+        # Count all dependents - for class or instance scope
+        dependent_associations.each do |assoc|
+          if scope == :class
+            count_dependents(self, assoc, dependent_counts)
+          else
+            count_dependents(instance, assoc, dependent_counts)
+          end
+        end
+        
+        # Debug which dependent associations exist
+        Rails.logger.debug("ERD for #{name} - dependent associations: #{dependent_associations.map(&:name).inspect}")
+        
+        # Define entity boxes with counts
+        if scope == :class
+          # For class level, count total records
+          total_count = count
+          entity_counts[name] = total_count
+        else
+          # For instance level, just show 1 for the current instance
+          entity_counts[name] = 1
+        end
+        
+        # Initialize metadata for current entity
+        entity_metadata[name] = {
+          foreign_keys: [],
+          dependent_assocs: [],
+          through_assocs: [],
+          complex_assocs: []
+        }
+        
+        # Add counts to dependent entities
+        dependent_associations.each do |assoc|
+          target_class = assoc.klass
+          next unless target_class < ActiveRecord::Base
+          
+          count = dependent_counts[target_class.name] || 0
+          entity_counts[target_class.name] = count
+          
+          # Mark this model to be shown
+          models_to_show[target_class.name] = true
+          
+          # Initialize metadata if needed
+          entity_metadata[target_class.name] ||= {
+            foreign_keys: [],
+            dependent_assocs: [],
+            through_assocs: [],
+            complex_assocs: []
+          }
+          
+          # Add info about this dependent association
+          entity_metadata[target_class.name][:dependent_assocs] << "#{assoc.foreign_key || 'unknown'} -> #{name} (#{assoc.name})"
+        end
+        
+        # Process all has_many and has_one associations
+        reflect_on_all_associations.each do |assoc|
+          next if assoc.polymorphic?
+          
+          begin
+            target_class = assoc.klass
+            next unless target_class < ActiveRecord::Base
+            
+            # Calculate count for the association
+            count = 0
+            if scope == :instance
+              begin
+                if assoc.macro == :has_many || assoc.macro == :has_one
+                  # For has_many, call count on the collection
+                  # For has_one, check if present (1) or not (0)
+                  if assoc.macro == :has_many
+                    count = instance.send(assoc.name).count
+                  else
+                    # For has_one, just check if it exists
+                    count = instance.send(assoc.name).present? ? 1 : 0 
+                  end
+                elsif assoc.macro == :belongs_to
+                  # For belongs_to, check if present (1) or not (0)
+                  count = instance.send(assoc.name).present? ? 1 : 0
+                  
+                  # Immediately mark this as a belongs_to only entity unless already marked otherwise
+                  unless complex_dependencies[target_class.name] || simple_dependencies[target_class.name]
+                    belongs_to_only_entities[target_class.name] = true
+                  end
+                end
+              rescue => e
+                # For errors (undefined method 'count' for nil or object), log and continue
+                Rails.logger.error("Error counting #{assoc.name} association: #{e.message}")
+                # If error was trying to call count on nil, set count to 0
+                count = 0
+              end
+            else
+              # For class level, we'll just use general counts
+              count = target_class.count
+              
+              # If this is a belongs_to association, mark it as belongs_to only unless already marked otherwise
+              if assoc.macro == :belongs_to
+                unless complex_dependencies[target_class.name] || simple_dependencies[target_class.name]
+                  belongs_to_only_entities[target_class.name] = true
+                end
+              end
+            end
+            
+            entity_counts[target_class.name] = count
+            
+            # Initialize metadata if needed
+            entity_metadata[target_class.name] ||= {
+              foreign_keys: [],
+              dependent_assocs: [],
+              through_assocs: [],
+              complex_assocs: []
+            }
+            
+            # Mark this model to be shown if it has records or if it's a direct has_many/has_one relationship
+            # This ensures that even empty has_many relationships will show up in the diagram
+            if count > 0 || empty || (assoc.macro == :has_many && assoc.options[:dependent] == :destroy)
+              models_to_show[target_class.name] = true
+            end
+            
+            # Handle special association types
+            if assoc.options[:through]
+              # Handle has_many :through associations
+              through_assoc = reflect_on_association(assoc.options[:through])
+              next unless through_assoc
+              
+              source_assoc = reflect_on_association(through_assoc.options[:source] || through_assoc.name) 
+              next unless source_assoc
+              
+              join_table = through_assoc.table_name
+              join_fk = assoc.foreign_key
+              
+              # Add through association metadata
+              entity_metadata[target_class.name][:through_assocs] << "via #{join_table}.#{join_fk} (#{assoc.name})"
+              
+              # Mark as complex dependency
+              complex_dependencies[target_class.name] = true
+              # Ensure we don't treat this as a belongs_to only entity
+              belongs_to_only_entities.delete(target_class.name)
+              # Always show through associations in the diagram
+              models_to_show[target_class.name] = true
+            elsif assoc.scope.present? && (assoc.macro == :has_many || assoc.macro == :has_one)
+              # Handle complex join
+              entity_metadata[target_class.name][:complex_assocs] << "custom join (#{assoc.name})"
+              
+              # Mark as complex dependency
+              complex_dependencies[target_class.name] = true
+              # Ensure we don't treat this as a belongs_to only entity
+              belongs_to_only_entities.delete(target_class.name)
+              # Always show complex associations in the diagram
+              models_to_show[target_class.name] = true
+            elsif assoc.macro == :belongs_to
+              # Skip belongs_to relationships for the primary entity 
+              # as they don't prevent removal of the entity
+              unless name == target_class.name
+                # For secondary entities, still track foreign key info
+                entity_metadata[target_class.name][:foreign_keys] << "#{assoc.foreign_key} -> #{target_class.name}"
+                
+                # Mark this entity as belongs_to only, unless it already has other relationships
+                unless complex_dependencies[target_class.name] || simple_dependencies[target_class.name]
+                  belongs_to_only_entities[target_class.name] = true
+                end
+              end
+            else
+              # For simpler has_many/has_one, add dependency info to target
+              fk_column = "#{model_name.singular}_id" # Default guess
+              
+              # Try to find the actual foreign key if possible
+              target_reflection = target_class.reflect_on_all_associations(:belongs_to).find do |r|
+                !r.polymorphic? && r.klass == self
+              end
+              
+              fk_column = target_reflection.foreign_key if target_reflection
+              
+              if assoc.options[:dependent] == :destroy
+                # This has a dependent: :destroy option, mark it for inclusion in the diagram
+                models_to_show[target_class.name] = true
+                
+                # Check if this is a simple dependency
+                if !complex_dependencies[target_class.name] && 
+                   target_class.reflect_on_all_associations.count { |a| a.options[:dependent] == :destroy } == 0
+                  # This is a simple dependency - it has no further dependents
+                  simple_dependencies[target_class.name] = true
+                  # This entity has a relationship beyond belongs_to
+                  belongs_to_only_entities.delete(target_class.name)
+                else
+                  # This entity has its own dependents or is involved in complex relations
+                  complex_dependencies[target_class.name] = true
+                  simple_dependencies.delete(target_class.name)
+                  # This entity has a relationship beyond belongs_to
+                  belongs_to_only_entities.delete(target_class.name)
+                end
+              else
+                # Non-dependent association
+                entity_metadata[target_class.name][:dependent_assocs] << "#{fk_column} -> #{name} (#{assoc.name})"
+                # This entity has a relationship beyond belongs_to
+                belongs_to_only_entities.delete(target_class.name)
+              end
+            end
+          rescue => e
+            Rails.logger.error("Error processing association #{assoc.name}: #{e.message}")
+          end
+        end
+        
+        # Add foreign key constraint info
+        foreign_keys.each do |fk|
+          referenced_table = fk.to_table
+          referenced_model = referenced_table.classify.constantize rescue nil
+          next unless referenced_model && referenced_model < ActiveRecord::Base
+          
+          # Skip foreign keys for the primary entity for belongs_to relationships
+          # that don't prevent removal of the entity
+          if reflect_on_all_associations(:belongs_to).any? do |assoc| 
+              assoc.foreign_key == fk.column && assoc.klass.name == referenced_model.name
+            end
+            # If we found a belongs_to relationship, mark it as belongs_to only and skip
+            belongs_to_only_entities[referenced_model.name] = true
+            models_to_show.delete(referenced_model.name)
+            
+            Rails.logger.debug("Skipping foreign key #{fk.column} -> #{referenced_model.name} as it's a belongs_to relationship that doesn't prevent entity removal")
+            next
+          end
+          
+          # Get count for the referenced model
+          fk_count = 0
+          if scope == :instance
+            begin
+              # For instance-level, check if the foreign key is non-null
+              fk_value = instance.send(fk.column)
+              if fk_value
+                # If FK has a value, count is 1 (the reference exists)
+                fk_count = 1
+              end
+            rescue => e
+              Rails.logger.error("Error checking foreign key #{fk.column}: #{e.message}")
+            end
+          else
+            # For class-level, count non-null foreign keys
+            begin
+              fk_count = where.not(fk.column => nil).count
+            rescue => e
+              Rails.logger.error("Error counting foreign key #{fk.column}: #{e.message}")
+            end
+          end
+          
+          # Track foreign key data with count
+          entity_metadata[name][:foreign_keys] << "#{fk.column} -> #{referenced_model.name} (#{fk_count})"
+          
+          # Update entity count for the referenced model
+          if fk_count > 0
+            entity_counts[referenced_model.name] ||= 0
+            entity_counts[referenced_model.name] += fk_count
+          end
+          
+          # Mark the model to be shown if it has records or empty is true
+          if entity_counts[referenced_model.name].to_i > 0 || empty
+            models_to_show[referenced_model.name] = true
+          end
+          
+          # Mark as complex dependency because it's referenced by a foreign key
+          complex_dependencies[referenced_model.name] = true
+          # This entity has a relationship beyond belongs_to
+          belongs_to_only_entities.delete(referenced_model.name)
+        end
+        
+        # Add dependent association info
+        dependent_associations.each do |assoc|
+          target_class = assoc.klass
+          next unless target_class < ActiveRecord::Base
+          
+          # Get the actual foreign key column name
+          fk_column = if assoc.macro == :belongs_to 
+                        assoc.foreign_key
+                      elsif assoc.polymorphic?
+                        "polymorphic"
+                      else
+                        # For has_many/has_one, the foreign key is on the other model
+                        target_reflection = nil
+                        begin
+                          target_reflection = target_class.reflect_on_all_associations(:belongs_to).find do |r|
+                            !r.polymorphic? && r.klass == self
+                          end
+                        rescue => e
+                          # If we can't find a reflection, just use a default
+                          Rails.logger.error("Error finding reflection: #{e.message}")
+                        end
+                        target_reflection&.foreign_key || "#{model_name.singular}_id"
+                      end
+          
+          # Track dependent association data for target class
+          entity_metadata[target_class.name][:dependent_assocs] << "#{fk_column} -> #{name} (#{assoc.name})"
+          
+          # Check if this is a simple dependency (has no further dependents)
+          if target_class.reflect_on_all_associations.none? { |a| a.options[:dependent] == :destroy }
+            simple_dependencies[target_class.name] = true
+          else
+            complex_dependencies[target_class.name] = true
+            simple_dependencies.delete(target_class.name)
+          end
+        end
+        
+        # Always include the current model
+        models_to_show[name] = true
+        complex_dependencies[name] = true # Root entity is always complex
+        
+        # Any model that has a foreign key or is referenced by a complex model is also complex
+        entity_metadata.each do |entity_name, metadata|
+          if metadata[:foreign_keys].any? || metadata[:through_assocs].any? || metadata[:complex_assocs].any?
+            complex_dependencies[entity_name] = true
+            simple_dependencies.delete(entity_name)
+            # This entity has a relationship beyond belongs_to
+            belongs_to_only_entities.delete(entity_name)
+          end
+        end
+        
+        # Final check to ensure belongs_to associations are completely excluded
+        # Check all belongs_to associations and ensure they're fully excluded
+        reflect_on_all_associations(:belongs_to).each do |assoc|
+          next if assoc.polymorphic?
+          
+          begin
+            target_class = assoc.klass
+            next unless target_class < ActiveRecord::Base
+            
+            # Skip self-references
+            next if target_class.name == name
+            
+            # IMPORTANT FIX: Skip if there is a dependent: :destroy association going back to this model
+            # This prevents removing models like Build that have a has_many relationship from App
+            if dependent_associations.any? { |da| da.klass == target_class }
+              # For models that are both a belongs_to target and have a dependent: :destroy relationship,
+              # ensure they're properly added to simple_dependencies
+              simple_dependencies[target_class.name] = true
+              models_to_show[target_class.name] = true
+              # Also remove from belongs_to_only_entities
+              belongs_to_only_entities.delete(target_class.name)
+              Rails.logger.debug("Keeping #{target_class.name} as it has a dependent: :destroy relationship with #{name}")
+              # Add to diagram as a comment for debugging
+              diagram << "    %% Ensuring #{target_class.name} stays in the SimpleDependencies"
+              next
+            end
+            
+            # Remove from models_to_show and mark as belongs_to only
+            belongs_to_only_entities[target_class.name] = true
+            models_to_show.delete(target_class.name)
+            complex_dependencies.delete(target_class.name)
+            simple_dependencies.delete(target_class.name)
+            
+            Rails.logger.debug("Final check - removing #{target_class.name} as it's a belongs_to relationship with #{name}")
+          rescue => e
+            Rails.logger.error("Error in final belongs_to check for #{assoc.name}: #{e.message}")
+          end
+        end
+        
+        # Before processing relationships, ensure belongs_to only entities are not shown
+        belongs_to_only_entities.each_key do |entity_name|
+          models_to_show.delete(entity_name)
+        end
+                
+        # Add a subgraph for simple dependencies if any exist
+        if simple_dependencies.keys.any?
+          diagram << "    %% Simple Dependencies Subgraph"
+          
+          # Create a single entity for all simple dependencies
+          valid_simple_deps = simple_dependencies.keys.select do |entity_name|
+            models_to_show[entity_name] && (entity_counts[entity_name].to_i > 0 || empty)
+          end.sort
+          
+          if valid_simple_deps.any?
+            # Create a single entity box containing all simple dependencies
+            diagram << "    SimpleDependencies {"
+            diagram << "        title string \"Simple Dependencies\""
+            
+            # Add each simple dependency as a property
+            valid_simple_deps.each_with_index do |entity_name, idx|
+              count = entity_counts[entity_name] || 0
+              diagram << "        dep#{idx+1} string \"#{entity_name} (#{count})\""
+            end
+            
+            diagram << "    }"
+            
+            # Add relationship lines from the main model to SimpleDependencies
+            diagram << "    #{name} ||--o{ SimpleDependencies : \"has simple dependencies\""
+          end
+        end
+        
+        # Complex dependencies section (without subgraph)
+        diagram << "    %% Complex Dependencies"
+        
+        # Define entity boxes for complex dependencies
+        complex_dependencies.keys.sort.each do |entity_name|
+          next unless models_to_show[entity_name]
+          count = entity_counts[entity_name] || 0
+          
+          # Skip if count is 0 and we're not showing empty relationships
+          next if !empty && count == 0
+          
+          metadata = entity_metadata[entity_name] || {}
+          
+          # Build entity box with metadata
+          entity_box = ["    #{entity_name} {"]
+          entity_box << "        count integer \"#{count}\""
+          
+          # Add foreign keys section if present
+          if metadata[:foreign_keys]&.any?
+            metadata[:foreign_keys].each_with_index do |fk_info, idx|
+              entity_box << "        fk#{idx+1} string \"#{fk_info}\""
+            end
+          end
+          
+          # Add dependent associations section if present
+          if metadata[:dependent_assocs]&.any?
+            metadata[:dependent_assocs].each_with_index do |dep_info, idx|
+              entity_box << "        dep#{idx+1} string \"#{dep_info}\""
+            end
+          end
+          
+          # Add through associations section if present
+          if metadata[:through_assocs]&.any?
+            metadata[:through_assocs].each_with_index do |through_info, idx|
+              entity_box << "        through#{idx+1} string \"#{through_info}\""
+            end
+          end
+          
+          # Add complex associations section if present
+          if metadata[:complex_assocs]&.any?
+            metadata[:complex_assocs].each_with_index do |complex_info, idx|
+              entity_box << "        complex#{idx+1} string \"#{complex_info}\""
+            end
+          end
+          
+          entity_box << "    }"
+          diagram << entity_box.join("\n")
+        end
+        
+        # Add relationship lines
+        
+        # Add foreign key relationships with simplified labels
+        foreign_keys.each do |fk|
+          referenced_table = fk.to_table
+          referenced_model = referenced_table.classify.constantize rescue nil
+          next unless referenced_model && referenced_model < ActiveRecord::Base
+          
+          # Skip if model should not be shown or is a belongs_to only entity
+          next unless models_to_show[referenced_model.name]
+          next if belongs_to_only_entities[referenced_model.name]
+          
+          # Add the relationship with simplified label
+          diagram << "    #{referenced_model.name} ||--o{ #{name} : references"
+        end
+
+        # Add dependent: :destroy relationships with simplified labels
+        dependent_associations.each do |assoc|
+          target_class = assoc.klass
+          next unless target_class < ActiveRecord::Base
+          
+          # Skip if model should not be shown or is a belongs_to only entity
+          next unless models_to_show[target_class.name]
+          next if belongs_to_only_entities[target_class.name]
+          
+          # Skip if this is a simple dependency - it's now represented by the SimpleDependencies entity
+          next if simple_dependencies[target_class.name]
+          
+          # Skip belongs_to relationships for the primary entity
+          next if assoc.macro == :belongs_to && target_class.name != name
+          
+          # Add the relationship with a label that includes dependent: :destroy
+          diagram << "    #{name} ||--o{ #{target_class.name} : \"dependent: :destroy (#{assoc.name})\""
+        end
+        
+        # Add has_many/has_one/belongs_to relationships not covered by above
+        reflect_on_all_associations.each do |assoc|
+          next if assoc.polymorphic?
+          next if assoc.options[:dependent] == :destroy # Already handled
+          
+          begin
+            target_class = assoc.klass
+            next unless target_class < ActiveRecord::Base
+            
+            # Skip if model should not be shown or is a belongs_to only entity
+            next unless models_to_show[target_class.name]
+            next if belongs_to_only_entities[target_class.name]
+            
+            # Skip if this is a simple dependency - it's now represented by the SimpleDependencies entity
+            next if simple_dependencies[target_class.name]
+            
+            # Skip self-references 
+            next if target_class.name == name
+            
+            # Skip belongs_to relationships for the primary entity
+            next if assoc.macro == :belongs_to && target_class.name != name
+            
+            # Handle various association types
+            if assoc.options[:through]
+              # Add has_many through relationship
+              through_assoc = reflect_on_association(assoc.options[:through])
+              next unless through_assoc
+              
+              source_assoc = reflect_on_association(through_assoc.options[:source] || through_assoc.name)
+              next unless source_assoc
+              
+              diagram << "    #{name} ||--o{ #{target_class.name} : \"has_many through (#{assoc.name})\""
+            elsif assoc.scope.present? && (assoc.macro == :has_many || assoc.macro == :has_one)
+              # Add complex scoped association
+              diagram << "    #{name} ||--o{ #{target_class.name} : \"complex join (#{assoc.name})\""
+            elsif assoc.macro == :belongs_to
+              # Add belongs_to (reverse the arrow direction compared to has_many)
+              diagram << "    #{target_class.name} ||--o{ #{name} : \"belongs_to (#{assoc.name})\""
+            elsif assoc.macro == :has_many
+              # Add standard has_many
+              diagram << "    #{name} ||--o{ #{target_class.name} : \"has_many (#{assoc.name})\""
+            elsif assoc.macro == :has_one
+              # Add has_one
+              diagram << "    #{name} ||--|| #{target_class.name} : \"has_one (#{assoc.name})\""
+            end
+          rescue => e
+            Rails.logger.error("Error adding relationship for #{assoc.name}: #{e.message}")
+          end
+        end
+        
+        # Return the diagram as a string without mermaid prefix/suffix
+        diagram.join("\n")
+      end
+      
+      # Helper method to count dependents recursively
+      def count_dependents(model, association, counts)
+        target_class = association.klass
+        return unless target_class < ActiveRecord::Base
+        
+        # Count direct dependents using the association's foreign key
+        begin
+          count = 0
+          if model.is_a?(Class)
+            # Class-level counting (all records)
+            if association.macro == :has_many || association.macro == :has_one
+              # For has_many/has_one, the foreign key is on the target model
+              # Try to determine the correct foreign key
+              target_reflection = nil
+              begin
+                target_reflection = target_class.reflect_on_all_associations(:belongs_to).find do |r|
+                  !r.polymorphic? && r.klass == self
+                end
+              rescue => e
+                Rails.logger.error("Error finding reflection: #{e.message}")
+              end
+              
+              foreign_key = if target_reflection
+                target_reflection.foreign_key
+              elsif association.respond_to?(:foreign_key) && target_class.column_names.include?(association.foreign_key.to_s)
+                association.foreign_key
+              else
+                "#{model_name.singular}_id"
+              end
+              
+              # Only proceed if the foreign key column actually exists
+              if target_class.column_names.include?(foreign_key.to_s)
+                count = target_class.where(foreign_key => model.pluck(:id)).count
+              else
+                Rails.logger.error("Foreign key column '#{foreign_key}' not found in '#{target_class.name}' table")
+                count = 0
+              end
+            elsif association.macro == :belongs_to
+              # For belongs_to, the foreign key is on this model
+              foreign_key = association.foreign_key
+              count = target_class.where(id: model.where.not(foreign_key => nil).select(foreign_key)).count
+            end
+          else
+            # Instance-level counting (single record)
+            if association.macro == :has_many || association.macro == :has_one
+              # For has_many/has_one relationships
+              count = instance_count_dependents(model, association)
+            elsif association.macro == :belongs_to
+              # For belongs_to, check if the association exists
+              count = model.send(association.name).present? ? 1 : 0
+            end
+          end
+          
+          # Add to counts
+          counts[target_class.name] ||= 0
+          counts[target_class.name] += count
+          
+          # Recursively count dependents of dependents
+          target_class.reflect_on_all_associations.each do |dep_assoc|
+            next unless dep_assoc.options[:dependent] == :destroy
+            # Pass on a collection of target records for recursive counting
+            if model.is_a?(Class)
+              # For class-level recursion, use a simpler approach to avoid errors
+              begin
+                related_records = target_class.all.to_a
+                # Limit this to avoid performance issues
+                related_records = related_records.first(10)
+              rescue => e
+                Rails.logger.error("Error fetching related records: #{e.message}")
+                related_records = []
+              end
+            else
+              # For instance-level recursion, fetch the associated records
+              related_records = instance_fetch_associated_records(model, association) || []
+            end
+            
+            # Count each related record's dependents
+            related_records.each do |record|
+              count_dependents(record, dep_assoc, counts)
+            end
+          end
+        rescue => e
+          # Log errors to help with debugging
+          Rails.logger.error("Error counting dependents for #{model.name || model.class.name} -> #{target_class.name}: #{e.message}")
+        end
+      end
+      
+      # Helper method to count instance-level dependents
+      def instance_count_dependents(instance, association)
+        return 0 unless instance && association
+        
+        begin
+          # Try to get the count directly from the association
+          if association.scope.present?
+            # For complex scoped associations, just evaluate the association
+            instance.send(association.name).count
+          else
+            # For standard associations, try to use the association's count
+            instance.send(association.name).count
+          end
+        rescue => e
+          Rails.logger.error("Error counting instance-level dependents for #{association.name}: #{e.message}")
+          0
+        end
+      end
+      
+      # Helper method to fetch associated records for an instance
+      def instance_fetch_associated_records(instance, association)
+        return [] unless instance && association
+        
+        begin
+          # Try to get the associated records
+          if association.scope.present?
+            # For complex scoped associations, just evaluate the association
+            instance.send(association.name).to_a
+          else
+            # For standard associations, fetch the records
+            instance.send(association.name).to_a
+          end
+        rescue => e
+          Rails.logger.error("Error fetching associated records for #{association.name}: #{e.message}")
+          []
+        end
+      end
+    end
+
+    module InstanceMethods
+      def erd(empty: false)
+        self.class.erd_for_instance(self, empty: empty)
+      end
+    end
+  end
+end
+
+# Railtie to hook into Rails initialization
+require "activerecord-erd/railtie" if defined?(Rails) 

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-erd
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jonathan
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-03-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+description: Generate Mermaid-based ERD diagrams for ActiveRecord models with their
+  dependencies
+email:
+- email@no-spam-please.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/activerecord-erd.rb
+- lib/activerecord-erd/railtie.rb
+- lib/activerecord-erd/version.rb
+homepage: https://github.com/usiegj00/activerecord-erd
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/usiegj00/activerecord-erd
+  source_code_uri: https://github.com/usiegj00/activerecord-erd
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.16
+signing_key:
+specification_version: 4
+summary: Entity Relationship Diagram generator for ActiveRecord models
+test_files: []