ea 0.1.0 → 0.1.4

data/lib/ea/qea/validation/database/orphan_validator.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Validation
+      # Detects orphaned entities (invalid foreign keys)
+      class OrphanValidator < BaseValidator
+        def validate
+          find_orphaned_objects
+          find_orphaned_attributes
+          find_orphaned_operations
+          find_unreferenced_objects
+        end
+
+        private
+
+        def find_orphaned_objects # rubocop:disable Metrics/MethodLength
+          objects.each do |obj|
+            next unless obj.package_id
+            next if package_exists?(obj.package_id)
+
+            result.add_error(
+              category: :orphaned,
+              entity_type: :class,
+              entity_id: obj.ea_object_id.to_s,
+              entity_name: obj.name,
+              field: "package_id",
+              reference: obj.package_id.to_s,
+              message: "Orphaned object: package #{obj.package_id} " \
+                       "does not exist",
+            )
+          end
+        end
+
+        def find_orphaned_attributes # rubocop:disable Metrics/MethodLength
+          attributes.each do |attr|
+            next if object_exists?(attr.ea_object_id)
+
+            result.add_error(
+              category: :orphaned,
+              entity_type: :attribute,
+              entity_id: attr.id.to_s,
+              entity_name: attr.name,
+              field: "object_id",
+              reference: attr.ea_object_id.to_s,
+              message: "Orphaned attribute: parent object " \
+                       "#{attr.ea_object_id} does not exist",
+            )
+          end
+        end
+
+        def find_orphaned_operations # rubocop:disable Metrics/MethodLength
+          operations.each do |op|
+            next if object_exists?(op.ea_object_id)
+
+            result.add_error(
+              category: :orphaned,
+              entity_type: :operation,
+              entity_id: op.operationid.to_s,
+              entity_name: op.name,
+              field: "object_id",
+              reference: op.ea_object_id.to_s,
+              message: "Orphaned operation: parent object " \
+                       "#{op.ea_object_id} does not exist",
+            )
+          end
+        end
+
+        def find_unreferenced_objects # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          # Find objects that are not referenced by any connector,
+          # attribute, or diagram
+          object_ids = objects.to_set(&:ea_object_id)
+
+          referenced_ids = Set.new
+
+          # Objects referenced by connectors
+          connectors.each do |conn|
+            referenced_ids << conn.start_object_id
+            referenced_ids << conn.end_object_id
+          end
+
+          # Objects referenced by attributes (as classifiers)
+          attributes.each do |attr|
+            referenced_ids << attr.ea_object_id
+            if attr.classifier&.to_i&.positive?
+              referenced_ids << attr.classifier.to_i
+            end
+          end
+
+          # Objects referenced by operations
+          operations.each do |op|
+            referenced_ids << op.ea_object_id
+          end
+
+          # Objects referenced by diagrams
+          diagram_objects.each do |diag_obj|
+            referenced_ids << diag_obj.ea_object_id
+          end
+
+          # Unreferenced objects (except root packages which
+          # may be unreferenced)
+          unreferenced = object_ids - referenced_ids
+          unreferenced.each do |obj_id|
+            obj = objects.find { |o| o.ea_object_id == obj_id }
+            next unless obj
+            # Skip DataType and Enumeration as they may not be referenced
+            next if obj.data_type? || obj.enumeration?
+
+            result.add_info(
+              category: :unreferenced,
+              entity_type: :class,
+              entity_id: obj_id.to_s,
+              entity_name: obj.name,
+              message: "Unreferenced object (not used in any relationship)",
+            )
+          end
+        end
+
+        def packages
+          @packages ||= context[:db_packages] || []
+        end
+
+        def objects
+          @objects ||= context[:db_objects] || []
+        end
+
+        def attributes
+          @attributes ||= context[:attributes] || []
+        end
+
+        def operations
+          @operations ||= context[:operations] || []
+        end
+
+        def connectors
+          @connectors ||= context[:connectors] || []
+        end
+
+        def diagram_objects
+          @diagram_objects ||= context[:diagram_objects] || []
+        end
+
+        def package_exists?(package_id)
+          packages.any? { |p| p.package_id == package_id }
+        end
+
+        def object_exists?(object_id)
+          objects.any? { |o| o.ea_object_id == object_id }
+        end
+      end
+    end
+  end
+end

data/lib/ea/qea/validation/database/referential_integrity_validator.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Validation
+      # Validates referential integrity across all entities
+      class ReferentialIntegrityValidator < BaseValidator
+        def validate
+          validate_all_package_references
+          validate_all_object_references
+          validate_all_connector_references
+        end
+
+        private
+
+        def validate_all_package_references # rubocop:disable Metrics/MethodLength
+          # Check all parent_id references in packages
+          packages.each do |pkg|
+            next if pkg.root?
+
+            unless package_exists?(pkg.parent_id)
+              result.add_error(
+                category: :referential_integrity,
+                entity_type: :package,
+                entity_id: pkg.package_id.to_s,
+                entity_name: pkg.name,
+                field: "parent_id",
+                reference: pkg.parent_id.to_s,
+                message: "Foreign key violation: parent_id #{pkg.parent_id} " \
+                         "not found in t_package",
+              )
+            end
+          end
+        end
+
+        def validate_all_object_references # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength
+          # Check all package_id references in objects
+          objects.each do |obj| # rubocop:disable Metrics/BlockLength
+            next unless obj.package_id
+
+            unless package_exists?(obj.package_id)
+              result.add_error(
+                category: :referential_integrity,
+                entity_type: :class,
+                entity_id: obj.ea_object_id.to_s,
+                entity_name: obj.name,
+                field: "package_id",
+                reference: obj.package_id.to_s,
+                message: "Foreign key violation: package_id " \
+                         "#{obj.package_id} not found in t_package",
+              )
+            end
+
+            # Check classifier references
+            next unless obj.classifier&.positive?
+
+            unless object_exists?(obj.classifier)
+              result.add_warning(
+                category: :referential_integrity,
+                entity_type: :class,
+                entity_id: obj.ea_object_id.to_s,
+                entity_name: obj.name,
+                field: "classifier",
+                reference: obj.classifier.to_s,
+                message: "Classifier object #{obj.classifier} not found",
+              )
+            end
+          end
+        end
+
+        def validate_all_connector_references # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          # Check all object references in connectors
+          connectors.each do |conn|
+            unless object_exists?(conn.start_object_id)
+              result.add_error(
+                category: :referential_integrity,
+                entity_type: :connector,
+                entity_id: conn.connector_id.to_s,
+                entity_name: conn.name || "Unnamed",
+                field: "start_object_id",
+                reference: conn.start_object_id.to_s,
+                message: "Foreign key violation: start_object_id " \
+                         "#{conn.start_object_id} not found in t_object",
+              )
+            end
+
+            unless object_exists?(conn.end_object_id)
+              result.add_error(
+                category: :referential_integrity,
+                entity_type: :connector,
+                entity_id: conn.connector_id.to_s,
+                entity_name: conn.name || "Unnamed",
+                field: "end_object_id",
+                reference: conn.end_object_id.to_s,
+                message: "Foreign key violation: end_object_id " \
+                         "#{conn.end_object_id} not found in t_object",
+              )
+            end
+          end
+        end
+
+        def packages
+          @packages ||= context[:db_packages] || []
+        end
+
+        def objects
+          @objects ||= context[:db_objects] || []
+        end
+
+        def connectors
+          @connectors ||= context[:connectors] || []
+        end
+
+        def package_exists?(package_id)
+          return false unless package_id
+
+          packages.any? { |p| p.package_id == package_id }
+        end
+
+        def object_exists?(object_id)
+          return false unless object_id
+
+          objects.any? { |o| o.ea_object_id == object_id }
+        end
+      end
+    end
+  end
+end

data/lib/ea/qea/validation/database.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Validation
+      module Database
+        autoload :CircularReferenceValidator,
+                 "ea/qea/validation/database/circular_reference_validator"
+        autoload :OrphanValidator,
+                 "ea/qea/validation/database/orphan_validator"
+        autoload :ReferentialIntegrityValidator,
+                 "ea/qea/validation/database/referential_integrity_validator"
+      end
+    end
+  end
+end

data/lib/ea/qea/validation/diagram_validator.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Validation
+      # Validates diagram references and structure
+      class DiagramValidator < BaseValidator
+        def validate
+          validate_package_references
+          validate_diagram_objects
+          validate_diagram_links
+        end
+
+        private
+
+        def validate_package_references # rubocop:disable Metrics/MethodLength
+          diagrams.each do |diagram|
+            next unless diagram.package_id
+
+            unless package_exists?(diagram.package_id)
+              result.add_error(
+                category: :missing_reference,
+                entity_type: :diagram,
+                entity_id: diagram.diagram_id.to_s,
+                entity_name: diagram.name,
+                field: "package_id",
+                reference: diagram.package_id.to_s,
+                message: "Package #{diagram.package_id} does not exist",
+              )
+            end
+          end
+        end
+
+        def validate_diagram_objects # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          diagram_objects.each do |diag_obj|
+            unless object_exists?(diag_obj.ea_object_id)
+              diagram = diagrams.find do |d|
+                d.diagram_id == diag_obj.diagram_id
+              end
+              result.add_warning(
+                category: :missing_reference,
+                entity_type: :diagram_object,
+                entity_id: diag_obj.instance_id.to_s,
+                entity_name: diagram&.name || "Unknown diagram",
+                field: "object_id",
+                reference: diag_obj.ea_object_id.to_s,
+                message: "Diagram object references non-existent " \
+                         "object #{diag_obj.ea_object_id}",
+              )
+            end
+          end
+        end
+
+        def validate_diagram_links # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          diagram_links.each do |diag_link|
+            unless connector_exists?(diag_link.connectorid)
+              diagram = diagrams.find do |d|
+                d.diagram_id == diag_link.diagramid
+              end
+              result.add_warning(
+                category: :missing_reference,
+                entity_type: :diagram_link,
+                entity_id: diag_link.instance_id.to_s,
+                entity_name: diagram&.name || "Unknown diagram",
+                field: "connectorid",
+                reference: diag_link.connectorid.to_s,
+                message: "Diagram link references non-existent " \
+                         "connector #{diag_link.connectorid}",
+              )
+            end
+          end
+        end
+
+        def diagrams
+          @diagrams ||= context[:diagrams] || []
+        end
+
+        def diagram_objects
+          @diagram_objects ||= context[:diagram_objects] || []
+        end
+
+        def diagram_links
+          @diagram_links ||= context[:diagram_links] || []
+        end
+
+        def packages
+          @packages ||= context[:db_packages] || []
+        end
+
+        def objects
+          @objects ||= context[:db_objects] || []
+        end
+
+        def connectors
+          @connectors ||= context[:connectors] || []
+        end
+
+        def package_exists?(package_id)
+          packages.any? { |p| p.package_id == package_id }
+        end
+
+        def object_exists?(object_id)
+          objects.any? { |o| o.ea_object_id == object_id }
+        end
+
+        def connector_exists?(connector_id)
+          connectors.any? { |c| c.connector_id == connector_id }
+        end
+      end
+    end
+  end
+end

data/lib/ea/qea/validation/formatters/json_formatter.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ea
+  module Qea
+    module Validation
+      module Formatters
+        # Formats validation results as JSON for machine consumption
+        #
+        # @example Basic usage
+        #   formatter = JsonFormatter.new(result)
+        #   puts formatter.format
+        #
+        # @example Pretty printed
+        #   formatter = JsonFormatter.new(result, pretty: true)
+        #   puts formatter.format
+        class JsonFormatter
+          attr_reader :result, :options
+
+          # Creates a new JSON formatter
+          #
+          # @param result [ValidationResult] The validation result to format
+          # @param options [Hash] Formatting options
+          # @option options [Boolean] :pretty Pretty print JSON (default: false)
+          def initialize(result: nil, **options)
+            @result = result
+            @options = {
+              pretty: false,
+            }.merge(options)
+          end
+
+          # Formats the validation result as JSON
+          #
+          # @return [String] JSON output
+          def format
+            data = build_data
+
+            if options[:pretty]
+              JSON.pretty_generate(data)
+            else
+              JSON.generate(data)
+            end
+          end
+
+          private
+
+          # Builds the data structure for JSON output
+          #
+          # @return [Hash]
+          def build_data
+            {
+              summary: build_summary,
+              messages: build_messages,
+              by_category: build_by_category,
+              by_severity: build_by_severity,
+            }
+          end
+
+          # Builds the summary section
+          #
+          # @return [Hash]
+          def build_summary
+            {
+              valid: result.valid?,
+              total_messages: result.messages.size,
+              error_count: result.errors.size,
+              warning_count: result.warnings.size,
+              info_count: result.info.size,
+            }
+          end
+
+          # Builds the messages array
+          #
+          # @return [Array<Hash>]
+          def build_messages # rubocop:disable Metrics/MethodLength
+            result.messages.map do |message|
+              {
+                severity: message.severity,
+                category: message.category,
+                entity_type: message.entity_type,
+                entity_id: message.entity_id,
+                entity_name: message.entity_name,
+                message: message.message,
+                context: message.context,
+              }
+            end
+          end
+
+          # Builds messages grouped by category
+          #
+          # @return [Hash]
+          def build_by_category
+            result.messages.group_by(&:category).transform_values do |msgs|
+              {
+                count: msgs.size,
+                messages: msgs.map(&:message),
+              }
+            end
+          end
+
+          # Builds messages grouped by severity
+          #
+          # @return [Hash]
+          def build_by_severity
+            {
+              errors: format_severity_group(result.errors),
+              warnings: format_severity_group(result.warnings),
+              info: format_severity_group(result.info),
+            }
+          end
+
+          # Formats a group of messages by severity
+          #
+          # @param messages [Array<ValidationMessage>]
+          # @return [Hash]
+          def format_severity_group(messages) # rubocop:disable Metrics/MethodLength
+            {
+              count: messages.size,
+              by_category: messages
+                .group_by(&:category).transform_values do |msgs|
+                  msgs.map do |msg|
+                    {
+                      entity_type: msg.entity_type,
+                      entity_id: msg.entity_id,
+                      entity_name: msg.entity_name,
+                      message: msg.message,
+                    }
+                  end
+                end,
+            }
+          end
+        end
+      end
+    end
+  end
+end