dbwatcher 1.1.3 → 1.1.5

data/lib/dbwatcher/logging.rb

@@ -14,9 +14,12 @@ module Dbwatcher
     end
 
     # Log a debug message with optional context
+    # Only logs if debug mode is enabled
     # @param message [String] the log message
     # @param context [Hash] additional context data
     def log_debug(message, context = {})
+      return unless debug_enabled?
+
       log_with_level(:debug, message, context)
     end
 
@@ -34,6 +37,16 @@ module Dbwatcher
       log_with_level(:error, message, context)
     end
 
+    # Check if debug logging is enabled
+    # @return [Boolean] true if debug logging is enabled
+    def debug_enabled?
+      return Dbwatcher.configuration.debug_mode if defined?(Dbwatcher.configuration) &&
+                                                   Dbwatcher.configuration.respond_to?(:debug_mode)
+      return Rails.env.development? if defined?(Rails)
+
+      false
+    end
+
     private
 
     def log_with_level(level, message, context)
@@ -51,7 +64,16 @@ module Dbwatcher
     end
 
     def component_name
-      self.class.name.split("::").last
+      if is_a?(Module) && !is_a?(Class)
+        # For modules
+        name.to_s.split("::").last
+      elsif self.class.name
+        # For classes
+        self.class.name.split("::").last
+      else
+        # Fallback
+        "Logger"
+      end
     end
 
     def rails_logger

data/lib/dbwatcher/services/diagram_analyzers/concerns/activerecord_introspection.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Dbwatcher
+  module Services
+    module DiagramAnalyzers
+      module Concerns
+        # Concern for ActiveRecord introspection utilities
+        #
+        # This module provides common methods for checking ActiveRecord availability
+        # and performing model introspection operations.
+        module ActiverecordIntrospection
+          extend ActiveSupport::Concern if defined?(ActiveSupport)
+
+          private
+
+          # Check if ActiveRecord is available
+          #
+          # @return [Boolean]
+          def activerecord_available?
+            defined?(ActiveRecord::Base)
+          end
+
+          # Check if models analysis is available
+          #
+          # @return [Boolean] true if models can be analyzed
+          def models_available?
+            unless activerecord_available?
+              Rails.logger.warn "#{self.class.name}: ActiveRecord not available"
+              return false
+            end
+
+            true
+          end
+
+          # Eagerly load all models including those from gems
+          #
+          # @return [void]
+          def eager_load_models
+            return unless defined?(Rails) && Rails.respond_to?(:application)
+
+            begin
+              # Force eager loading of application models
+              Rails.application.eager_load!
+
+              # Also load models from engines/gems if any are configured
+              Rails::Engine.descendants.each do |engine|
+                engine.eager_load! if engine.respond_to?(:eager_load!)
+              rescue StandardError => e
+                error_message = "#{self.class.name}: Could not eager load engine #{engine.class.name}: #{e.message}"
+                Rails.logger.debug error_message
+              end
+            rescue StandardError => e
+              Rails.logger.debug "#{self.class.name}: Could not eager load models: #{e.message}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dbwatcher/services/diagram_analyzers/concerns/association_scope_filtering.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Dbwatcher
+  module Services
+    module DiagramAnalyzers
+      module Concerns
+        # Concern for filtering associations based on scope
+        #
+        # This module provides methods for determining which associations
+        # should be included in the analysis based on session context.
+        module AssociationScopeFiltering
+          extend ActiveSupport::Concern if defined?(ActiveSupport)
+
+          private
+
+          # Check if target model is in analysis scope
+          #
+          # @param association [Object] association object
+          # @param session_tables [Array<String>] tables from session context
+          # @return [Boolean] true if target model should be included
+          def target_model_in_scope?(association, session_tables = [])
+            target_table = get_association_table_name(association)
+
+            # If analyzing session, both tables must be in session
+            # If analyzing globally, include all
+            return true if session_tables.empty?
+
+            # Skip if target table is not in session
+            return false if target_table && !session_tables.include?(target_table)
+
+            true
+          end
+
+          # Get table name for association target
+          #
+          # @param association [Object] association object
+          # @return [String, nil] table name
+          def get_association_table_name(association)
+            association.table_name
+          rescue StandardError => e
+            Rails.logger.warn "#{self.class.name}: Could not get table name for #{association.name}: #{e.message}"
+            nil
+          end
+
+          # Extract tables that were involved in the session
+          #
+          # @param session [Object] session object with changes
+          # @return [Array<String>] unique table names
+          def extract_session_tables(session)
+            return [] unless session&.changes
+
+            session.changes.map do |change|
+              change[:table_name] || change["table_name"]
+            end.compact.uniq
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dbwatcher/services/diagram_analyzers/inferred_relationship_analyzer.rb

@@ -232,6 +232,37 @@ module Dbwatcher
         # @param primary_key [String, nil] optional primary key for testing
         # @return [Boolean] true if likely self-referential
         def self_referential_column?(column_name, table_name, primary_key = nil)
+          # Get the singular form of the table name
+          base_name = singularize(table_name)
+
+          # Special case for post_id in posts table - not a self-reference
+          return false if column_name == "#{base_name}_id" && table_name == "posts" && base_name == "post"
+
+          # Check primary key if this is a table-specific reference
+          if column_name == "#{base_name}_id"
+            if primary_key.nil?
+              begin
+                primary_key = connection.primary_key(table_name)
+              rescue StandardError
+                return false
+              end
+            end
+
+            return column_name != primary_key
+          end
+
+          # Use pattern matching to check various self-referential patterns
+          common_pattern?(column_name) ||
+            hierarchy_pattern?(column_name, base_name) ||
+            relationship_pattern?(column_name) ||
+            directional_pattern?(column_name)
+        end
+
+        # Check if column matches common self-referential patterns
+        #
+        # @param column_name [String] column name to check
+        # @return [Boolean] true if matches common patterns
+        def common_pattern?(column_name)
           # Common self-referential patterns
           self_ref_patterns = %w[
             parent_id
@@ -257,52 +288,47 @@ module Dbwatcher
             replied_to_id
           ]
 
-          # Check for exact matches with common patterns
-          return true if self_ref_patterns.include?(column_name)
-
-          # Get the singular form of the table name
-          base_name = singularize(table_name)
-
-          # Special case for post_id in posts table - not a self-reference
-          return false if column_name == "#{base_name}_id" && table_name == "posts" && base_name == "post"
-
-          # Check for table-specific self-references (e.g., comment_id in comments table)
-          if column_name == "#{base_name}_id"
-            # Check if this is not the primary key column
-            if primary_key.nil?
-              begin
-                primary_key = connection.primary_key(table_name)
-              rescue StandardError
-                return false
-              end
-            end
-
-            return column_name != primary_key
-          end
+          self_ref_patterns.include?(column_name)
+        end
 
-          # Check for hierarchy patterns with table name
+        # Check for hierarchy patterns with table name
+        #
+        # @param column_name [String] column name to check
+        # @param base_name [String] singular form of table name
+        # @return [Boolean] true if matches hierarchy patterns
+        def hierarchy_pattern?(column_name, base_name)
           hierarchy_prefixes = %w[parent child ancestor descendant superior subordinate manager supervisor]
-          hierarchy_prefixes.each do |prefix|
-            # Check for patterns like parent_comment_id in comments table
-            return true if column_name.start_with?("#{prefix}_#{base_name}_id")
 
-            # Check for patterns like parent_of_id in any table
-            return true if column_name.start_with?("#{prefix}_of_id")
+          hierarchy_prefixes.any? do |prefix|
+            # Check for patterns like parent_comment_id in comments table
+            column_name.start_with?("#{prefix}_#{base_name}_id") ||
+              # Check for patterns like parent_of_id in any table
+              column_name.start_with?("#{prefix}_of_id")
           end
+        end
 
-          # Check for relationship patterns
+        # Check for relationship patterns
+        #
+        # @param column_name [String] column name to check
+        # @return [Boolean] true if matches relationship patterns
+        def relationship_pattern?(column_name)
           relationship_patterns = %w[related linked connected associated referenced]
-          relationship_patterns.each do |pattern|
-            return true if column_name.start_with?("#{pattern}_")
+
+          relationship_patterns.any? do |pattern|
+            column_name.start_with?("#{pattern}_")
           end
+        end
 
-          # Check for directional patterns
+        # Check for directional patterns
+        #
+        # @param column_name [String] column name to check
+        # @return [Boolean] true if matches directional patterns
+        def directional_pattern?(column_name)
           directional_patterns = %w[previous next original copy source target]
-          directional_patterns.each do |pattern|
-            return true if column_name.start_with?("#{pattern}_")
-          end
 
-          false
+          directional_patterns.any? do |pattern|
+            column_name.start_with?("#{pattern}_")
+          end
         end
 
         # Analyze junction tables (many-to-many relationships)

data/lib/dbwatcher/services/diagram_analyzers/model_analysis/association_extractor.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+module Dbwatcher
+  module Services
+    module DiagramAnalyzers
+      module ModelAnalysis
+        # Service responsible for analyzing ActiveRecord model associations
+        #
+        # This service handles the extraction and analysis of model associations,
+        # converting them into standardized relationship data for diagram generation.
+        class AssociationExtractor
+          attr_reader :session_tables
+
+          # Initialize with optional session tables for scope filtering
+          #
+          # @param session_tables [Array<String>] table names from session (empty for global analysis)
+          def initialize(session_tables = [])
+            @session_tables = session_tables || []
+          end
+
+          # Extract associations from all provided models
+          #
+          # @param models [Array<Class>] ActiveRecord model classes to analyze
+          # @return [Array<Hash>] associations array
+          def extract_all(models)
+            associations = []
+
+            models.each do |model|
+              model_associations = get_model_associations(model)
+
+              model_associations.each do |association|
+                # Skip polymorphic associations for now
+                next if association.options[:polymorphic]
+
+                # Skip if target model is not in scope
+                next unless target_model_in_scope?(association)
+
+                # Build relationship based on association type
+                relationship = build_association_relationship(model, association)
+                associations << relationship if relationship
+              end
+            end
+
+            associations
+          end
+
+          # Generate placeholder associations for models without associations
+          #
+          # @param models [Array<Class>] models to create placeholders for
+          # @return [Array<Hash>] placeholder associations
+          def generate_placeholder_associations(models)
+            result = models.map do |model|
+              {
+                type: "node_only",
+                source_model: model.name,
+                source_table: model.table_name,
+                target_model: nil,
+                target_table: nil,
+                association_name: nil
+              }
+            end
+
+            Rails.logger.info "AssociationExtractor: Generated #{result.size} placeholder nodes"
+            result
+          end
+
+          private
+
+          # Get associations for a model
+          #
+          # @param model [Class] ActiveRecord model class
+          # @return [Array] association objects
+          def get_model_associations(model)
+            model.reflect_on_all_associations
+          rescue StandardError => e
+            Rails.logger.warn "AssociationExtractor: Could not get associations for #{model.name}: #{e.message}"
+            []
+          end
+
+          # Check if target model is in analysis scope
+          #
+          # @param association [Object] association object
+          # @return [Boolean] true if target model should be included
+          def target_model_in_scope?(association)
+            target_table = get_association_table_name(association)
+
+            # If analyzing session, both tables must be in session
+            # If analyzing globally, include all
+            return true if session_tables.empty?
+
+            # Skip if target table is not in session
+            return false if target_table && !session_tables.include?(target_table)
+
+            true
+          end
+
+          # Build relationship hash based on association type
+          #
+          # @param model [Class] source model class
+          # @param association [Object] association object
+          # @return [Hash] relationship data
+          def build_association_relationship(model, association)
+            case association.macro
+            when :belongs_to
+              build_belongs_to_relationship(model, association)
+            when :has_one
+              build_has_one_relationship(model, association)
+            when :has_many
+              if association.options[:through]
+                build_has_many_through_relationship(model, association)
+              else
+                build_has_many_relationship(model, association)
+              end
+            when :has_and_belongs_to_many
+              build_habtm_relationship(model, association)
+            else
+              # Handle special cases like has_one_attached from Active Storage
+              if association.name.to_s.end_with?("_attachment") || association.name.to_s.end_with?("_attachments")
+                build_active_storage_relationship(model, association)
+              else
+                Rails.logger.warn "AssociationExtractor: Unknown association type: " \
+                                  "#{association.macro} for #{model.name}.#{association.name}"
+                nil
+              end
+            end
+          end
+
+          # Build a standardized relationship hash
+          #
+          # @param model [Class] source model class
+          # @param association [Object] association object
+          # @param type [String] relationship type
+          # @return [Hash] relationship data
+          def build_relationship_hash(model, association, type)
+            return nil unless association&.class_name
+
+            {
+              source_model: model.name,
+              source_table: model.table_name,
+              target_model: association.class_name,
+              target_table: get_association_table_name(association),
+              type: type,
+              association_name: association.name.to_s
+            }
+          end
+
+          # Build belongs_to relationship
+          #
+          # @param model [Class] source model class
+          # @param association [Object] association object
+          # @return [Hash] relationship data
+          def build_belongs_to_relationship(model, association)
+            build_relationship_hash(model, association, "belongs_to")
+          end
+
+          # Build has_one relationship
+          #
+          # @param model [Class] source model class
+          # @param association [Object] association object
+          # @return [Hash] relationship data
+          def build_has_one_relationship(model, association)
+            build_relationship_hash(model, association, "has_one")
+          end
+
+          # Build has_many relationship
+          #
+          # @param model [Class] source model class
+          # @param association [Object] association object
+          # @return [Hash] relationship data
+          def build_has_many_relationship(model, association)
+            build_relationship_hash(model, association, "has_many")
+          end
+
+          # Build has_many :through relationship
+          #
+          # @param model [Class] source model class
+          # @param association [Object] association object
+          # @return [Hash] relationship data
+          def build_has_many_through_relationship(model, association)
+            relationship = build_relationship_hash(model, association, "has_many_through")
+            relationship[:association_name] = "#{association.name} (through #{association.options[:through]})"
+            relationship
+          end
+
+          # Build has_and_belongs_to_many relationship
+          #
+          # @param model [Class] source model class
+          # @param association [Object] association object
+          # @return [Hash] relationship data
+          def build_habtm_relationship(model, association)
+            build_relationship_hash(model, association, "has_and_belongs_to_many")
+          end
+
+          # Build Active Storage relationship
+          #
+          # @param model [Class] source model class
+          # @param association [Object] association object
+          # @return [Hash] relationship data
+          def build_active_storage_relationship(model, association)
+            {
+              source_model: model.name,
+              source_table: model.table_name,
+              target_model: "ActiveStorage::Attachment",
+              target_table: "active_storage_attachments",
+              type: "has_one",
+              association_name: association.name.to_s
+            }
+          end
+
+          # Get table name for association target
+          #
+          # @param association [Object] association object
+          # @return [String, nil] table name
+          def get_association_table_name(association)
+            association.table_name
+          rescue StandardError => e
+            Rails.logger.warn "AssociationExtractor: Could not get table name for #{association.name}: #{e.message}"
+            nil
+          end
+        end
+      end
+    end
+  end
+end