dbwatcher 1.1.3 → 1.1.5

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

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+module Dbwatcher
+  module Services
+    module DiagramAnalyzers
+      module ModelAnalysis
+        # Service responsible for building datasets from model associations
+        #
+        # This service handles the transformation of model association data into
+        # standardized Dataset format with entities and relationships.
+        class DatasetBuilder
+          # Create entities from discovered model classes
+          #
+          # @param dataset [DiagramData::Dataset] dataset to add entities to
+          # @param models [Array<Class>] ActiveRecord model classes
+          # @return [void]
+          def create_entities_from_models(dataset, models)
+            models.each do |model_class|
+              attributes = extract_model_attributes(model_class)
+              methods = extract_model_methods(model_class)
+
+              entity = create_entity(
+                id: model_class.table_name,
+                name: model_class.name,
+                type: "model",
+                attributes: attributes,
+                metadata: {
+                  table_name: model_class.table_name,
+                  model_class: model_class.name,
+                  methods: methods
+                }
+              )
+              dataset.add_entity(entity)
+            end
+          end
+
+          # Create relationships from association data
+          #
+          # @param dataset [DiagramData::Dataset] dataset to add relationships to
+          # @param raw_data [Array<Hash>] raw association data
+          # @return [void]
+          def create_relationships_from_associations(dataset, raw_data)
+            raw_data.each do |association|
+              next if association[:type] == "node_only" || !association[:target_model]
+
+              source_id = association[:source_table]
+              target_id = association[:target_table]
+
+              # Skip if we don't have valid table IDs
+              next unless source_id && target_id
+
+              # Determine cardinality based on relationship type
+              cardinality = determine_cardinality(association[:type])
+
+              relationship = create_relationship({
+                                                   source_id: source_id,
+                                                   target_id: target_id,
+                                                   type: association[:type],
+                                                   label: association[:association_name],
+                                                   cardinality: cardinality,
+                                                   metadata: {
+                                                     association_name: association[:association_name],
+                                                     source_model: association[:source_model],
+                                                     target_model: association[:target_model],
+                                                     original_type: association[:type],
+                                                     self_referential: source_id == target_id
+                                                   }
+                                                 })
+
+              dataset.add_relationship(relationship)
+            end
+          end
+
+          # Build complete dataset from associations and models
+          #
+          # @param raw_associations [Array<Hash>] raw association data
+          # @param models [Array<Class>] ActiveRecord model classes
+          # @return [DiagramData::Dataset] standardized dataset
+          def build_from_associations(raw_associations, models)
+            dataset = create_empty_dataset
+            dataset.metadata.merge!({
+                                      total_relationships: raw_associations.count { |a| a[:target_model] },
+                                      total_models: models.length,
+                                      model_names: models.map(&:name)
+                                    })
+
+            # Create entities from actual discovered models (no inference)
+            create_entities_from_models(dataset, models)
+
+            # Create relationships from association data
+            create_relationships_from_associations(dataset, raw_associations)
+
+            dataset
+          end
+
+          private
+
+          # Extract attributes from model class
+          #
+          # @param model_class [Class, nil] ActiveRecord model class
+          # @return [Array<Attribute>] model attributes
+          def extract_model_attributes(model_class)
+            return [] unless model_class.respond_to?(:columns)
+
+            begin
+              model_class.columns.map do |column|
+                create_attribute(
+                  name: column.name,
+                  type: column.type.to_s,
+                  nullable: column.null,
+                  default: column.default,
+                  metadata: {
+                    primary_key: column.name == model_class.primary_key,
+                    foreign_key: column.name.end_with?("_id"),
+                    visibility: "+" # Public visibility for all columns
+                  }
+                )
+              end
+            rescue StandardError => e
+              Rails.logger.warn "DatasetBuilder: Could not extract attributes for " \
+                                "#{model_class.name}: #{e.message}"
+              []
+            end
+          end
+
+          # Extract methods from model class
+          #
+          # @param model_class [Class, nil] ActiveRecord model class
+          # @return [Array<Hash>] model methods
+          def extract_model_methods(model_class)
+            return [] unless model_class && Dbwatcher.configuration.diagram_show_methods
+
+            methods = []
+
+            begin
+              # Get instance methods defined in the model (not inherited from ActiveRecord::Base)
+              model_methods = model_class.instance_methods - ActiveRecord::Base.instance_methods
+              model_methods.each do |method_name|
+                # Skip association methods and attribute methods
+                next if method_name.to_s.end_with?("=") || model_class.column_names.include?(method_name.to_s)
+
+                methods << {
+                  name: method_name.to_s,
+                  visibility: "+" # Public visibility for all methods
+                }
+              end
+            rescue StandardError => e
+              Rails.logger.warn "DatasetBuilder: Could not extract methods for " \
+                                "#{model_class.name}: #{e.message}"
+            end
+
+            methods
+          end
+
+          # Determine cardinality based on relationship type
+          #
+          # @param relationship_type [String] relationship type
+          # @return [String, nil] cardinality type
+          def determine_cardinality(relationship_type)
+            case relationship_type
+            when "has_many"
+              "one_to_many"
+            when "belongs_to"
+              "many_to_one"
+            when "has_one"
+              "one_to_one"
+            when "has_and_belongs_to_many", "has_many_through"
+              "many_to_many"
+            end
+          end
+
+          # Helper method to create entities (delegated to base analyzer)
+          #
+          # @param params [Hash] entity parameters
+          # @return [DiagramData::Entity] new entity
+          def create_entity(**params)
+            Dbwatcher::Services::DiagramData::Entity.new(
+              id: params[:id],
+              name: params[:name],
+              type: params[:type] || "default",
+              attributes: params[:attributes] || [],
+              metadata: params[:metadata] || {}
+            )
+          end
+
+          # Helper method to create relationships (delegated to base analyzer)
+          #
+          # @param params [Hash] relationship parameters
+          # @return [DiagramData::Relationship] new relationship
+          def create_relationship(params)
+            params_obj = Dbwatcher::Services::DiagramData::RelationshipParams.new(params)
+            Dbwatcher::Services::DiagramData::Relationship.new(params_obj)
+          end
+
+          # Helper method to create attributes (delegated to base analyzer)
+          #
+          # @param params [Hash] attribute parameters
+          # @return [DiagramData::Attribute] new attribute
+          def create_attribute(**params)
+            Dbwatcher::Services::DiagramData::Attribute.new(
+              name: params[:name],
+              type: params[:type],
+              nullable: params[:nullable] || true,
+              default: params[:default],
+              metadata: params[:metadata] || {}
+            )
+          end
+
+          # Helper method to create empty dataset (delegated to base analyzer)
+          #
+          # @return [DiagramData::Dataset] empty dataset
+          def create_empty_dataset
+            Dbwatcher::Services::DiagramData::Dataset.new(
+              metadata: {
+                analyzer: "ModelAssociationAnalyzer",
+                analyzer_type: "model_association",
+                empty_reason: "No data found or analysis failed",
+                generated_at: Time.current.iso8601
+              }
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Dbwatcher
+  module Services
+    module DiagramAnalyzers
+      module ModelAnalysis
+        # Service responsible for discovering and filtering ActiveRecord models
+        #
+        # This service handles the complex logic of finding ActiveRecord models
+        # that are relevant for diagram analysis, including models from gems,
+        # namespaced models, and models with custom table names.
+        class ModelDiscovery
+          attr_reader :session_tables, :discovered_models
+
+          # Initialize with optional session tables for filtering
+          #
+          # @param session_tables [Array<String>] table names from session (empty for global analysis)
+          def initialize(session_tables = [])
+            @session_tables = session_tables || []
+            @discovered_models = []
+          end
+
+          # Discover models that correspond to session tables or all models if no session
+          #
+          # @return [Array<Class>] ActiveRecord model classes
+          def discover
+            return [] unless activerecord_available?
+
+            begin
+              all_models = load_all_models
+              @discovered_models = filter_models_by_session(all_models)
+
+              log_discovery_results
+              @discovered_models
+            rescue StandardError => e
+              Rails.logger.error "ModelDiscovery: Error discovering models: #{e.message}"
+              []
+            end
+          end
+
+          # Load all available ActiveRecord models including from gems
+          #
+          # @return [Array<Class>] ActiveRecord model classes
+          def load_all_models
+            eager_load_models
+
+            # Get all model classes directly from ActiveRecord descendants
+            all_models = ActiveRecord::Base.descendants
+                                           .select { |model| valid_model_class?(model) }
+                                           .uniq
+
+            Rails.logger.debug "ModelDiscovery: Found #{all_models.size} total ActiveRecord models"
+            all_models
+          end
+
+          # Check if a model class is valid for analysis
+          #
+          # @param model [Class] ActiveRecord model class
+          # @return [Boolean] true if model is valid
+          def valid_model_class?(model)
+            # Must be a proper class with a name (not anonymous)
+            return false unless model.name
+
+            # Must have a table that exists
+            return false unless model_has_table?(model)
+
+            # Skip abstract models
+            return false if model.abstract_class?
+
+            true
+          rescue StandardError => e
+            Rails.logger.debug "ModelDiscovery: Error validating model #{model}: #{e.message}"
+            false
+          end
+
+          # Check if model has a database table
+          #
+          # @param model [Class] ActiveRecord model class
+          # @return [Boolean] true if model has a table
+          def model_has_table?(model)
+            model.table_exists?
+          rescue StandardError
+            false
+          end
+
+          private
+
+          # Check if ActiveRecord is available
+          #
+          # @return [Boolean]
+          def activerecord_available?
+            defined?(ActiveRecord::Base)
+          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 = "ModelDiscovery: Could not eager load engine #{engine.class.name}: #{e.message}"
+                Rails.logger.debug error_message
+              end
+            rescue StandardError => e
+              Rails.logger.debug "ModelDiscovery: Could not eager load models: #{e.message}"
+            end
+          end
+
+          # Filter models based on session tables
+          #
+          # @param all_models [Array<Class>] all available models
+          # @return [Array<Class>] filtered models
+          def filter_models_by_session(all_models)
+            return all_models if session_tables.empty?
+
+            # Build a hash of table_name -> model for efficient lookup
+            table_to_models = {}
+            all_models.each do |model|
+              table_name = model.table_name
+              table_to_models[table_name] ||= []
+              table_to_models[table_name] << model
+            rescue StandardError => e
+              Rails.logger.warn "ModelDiscovery: Error checking table_name for " \
+                                "#{model.name}: #{e.message}"
+            end
+
+            # Select models whose tables are in the session
+            filtered_models = []
+            session_tables.each do |table_name|
+              models_for_table = table_to_models[table_name]
+              filtered_models.concat(models_for_table) if models_for_table
+            end
+
+            filtered_models
+          end
+
+          # Log discovery results for debugging
+          #
+          # @return [void]
+          def log_discovery_results
+            if discovered_models.any?
+              model_table_info = discovered_models.map { |m| "#{m.name} (#{m.table_name})" }
+              Rails.logger.debug "ModelDiscovery: Discovered models: #{model_table_info.join(", ")}"
+            end
+
+            Rails.logger.debug "ModelDiscovery: Filtered to #{discovered_models.size} " \
+                               "models matching session tables (from #{session_tables.size} tables)"
+          end
+        end
+      end
+    end
+  end
+end