lutaml 0.9.43 → 0.10.0

data/lib/lutaml/qea/validation/base_validator.rb

@@ -0,0 +1,305 @@
+# frozen_string_literal: true
+
+require_relative "validation_result"
+
+module Lutaml
+  module Qea
+    module Validation
+      # Base class for all validators providing common validation
+      # infrastructure and helper methods
+      #
+      # @example Creating a custom validator
+      #   class MyValidator < BaseValidator
+      #     def validate
+      #       check_required_field(:name)
+      #       check_reference(:parent_id, :packages)
+      #     end
+      #   end
+      class BaseValidator
+        attr_reader :result, :context
+
+        # Creates a new validator
+        #
+        # @param result [ValidationResult] Result object to populate
+        # @param context [Hash] Validation context including database
+        #   connection, document, etc.
+        def initialize(result:, context: {})
+          @result = result
+          @context = context
+        end
+
+        # Performs validation and returns the result
+        #
+        # This method should be overridden by subclasses
+        #
+        # @return [ValidationResult]
+        def validate
+          raise NotImplementedError,
+                "#{self.class} must implement #validate"
+        end
+
+        # Runs validation
+        # Result is populated in the shared @result object
+        #
+        # @return [void]
+        def call
+          validate
+        end
+
+        protected
+
+        # Returns the database connection from context
+        #
+        # @return [Lutaml::Qea::Database, nil]
+        def database
+          @context[:database]
+        end
+
+        # Returns the document being validated from context
+        #
+        # @return [Object, nil]
+        def document
+          @context[:document]
+        end
+
+        # Returns validation options from context
+        #
+        # @return [Hash]
+        def options
+          @context[:options] || {}
+        end
+
+        # Checks if a reference exists in a table
+        #
+        # @param entity_id [String, Integer] ID of the entity being validated
+        # @param entity_name [String] Name of the entity being validated
+        # @param entity_type [Symbol] Type of entity (e.g., :class,
+        #   :association)
+        # @param field [String] Field name containing the reference
+        # @param reference_id [String, Integer] The referenced ID
+        # @param table [String] Table to check for reference existence
+        # @param id_column [String] ID column name in the reference table
+        # @param category [Symbol] Validation category
+        # @return [Boolean] True if reference exists, false otherwise
+        def check_reference_exists( # rubocop:disable Metrics/MethodLength,Metrics/ParameterLists
+          entity_id:,
+          entity_name:,
+          entity_type:,
+          field:,
+          reference_id:,
+          table:,
+          id_column: "ea_object_id",
+          category: :missing_reference
+        )
+          return true if reference_id.nil? || reference_id.to_s.empty?
+
+          exists = reference_exists?(table, id_column, reference_id)
+
+          unless exists
+            add_error(
+              category: category,
+              entity_type: entity_type,
+              entity_id: entity_id,
+              entity_name: entity_name,
+              field: field,
+              reference: reference_id.to_s,
+              message: "#{field} references non-existent #{table} entry",
+            )
+          end
+
+          exists
+        end
+
+        # Checks if a reference exists in the database
+        #
+        # @param table [String] Table name
+        # @param id_column [String] ID column name
+        # @param reference_id [String, Integer] The ID to check
+        # @return [Boolean]
+        def reference_exists?(table, id_column, reference_id)
+          return false unless database
+
+          collection = get_collection_for_table(table)
+          return false unless collection
+
+          collection.any? { |record| record.send(id_column) == reference_id }
+        end
+
+        # Maps table names to their corresponding collections in Database
+        #
+        # @param table [String] Table name (e.g., "t_package", "t_object")
+        # @return [Array, nil] Collection array or nil if table not mapped
+        def get_collection_for_table(table) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength
+          case table
+          when "t_package"
+            database.packages
+          when "t_object"
+            database.objects.all
+          when "t_attribute"
+            database.attributes
+          when "t_operation"
+            database.operations
+          when "t_operationparams"
+            database.operation_params
+          when "t_connector"
+            database.connectors
+          when "t_diagram"
+            database.diagrams
+          when "t_diagramobjects"
+            database.diagram_objects
+          when "t_diagramlinks"
+            database.diagram_links
+          when "t_objectconstraint"
+            database.object_constraints
+          when "t_objectproperties"
+            database.object_properties
+          when "t_taggedvalue"
+            database.tagged_values
+          when "t_attributetag"
+            database.attribute_tags
+          when "t_xref"
+            database.xrefs
+          when "t_stereotypes"
+            database.stereotypes
+          when "t_datatypes"
+            database.datatypes
+          when "t_constrainttypes"
+            database.constraint_types
+          when "t_connectortypes"
+            database.connector_types
+          when "t_diagramtypes"
+            database.diagram_types
+          when "t_objecttypes"
+            database.object_types
+          when "t_statustypes"
+            database.status_types
+          when "t_complexitytypes"
+            database.complexity_types
+          end
+        end
+
+        # Adds an error to the validation result
+        #
+        # @param args [Hash] Message attributes
+        # @return [ValidationMessage]
+        def add_error(**args)
+          @result.add_error(**args)
+        end
+
+        # Adds a warning to the validation result
+        #
+        # @param args [Hash] Message attributes
+        # @return [ValidationMessage]
+        def add_warning(**args)
+          @result.add_warning(**args)
+        end
+
+        # Adds an info message to the validation result
+        #
+        # @param args [Hash] Message attributes
+        # @return [ValidationMessage]
+        def add_info(**args)
+          @result.add_info(**args)
+        end
+
+        # Checks if a value is present (not nil and not empty)
+        #
+        # @param value [Object] Value to check
+        # @return [Boolean]
+        def present?(value)
+          !value.nil? && (value.respond_to?(:empty?) ? !value.empty? : true)
+        end
+
+        # Finds entity name from database
+        #
+        # @param table [String] Table name
+        # @param id_column [String] ID column name
+        # @param name_column [String] Name column name
+        # @param id [String, Integer] Entity ID
+        # @return [String, nil] Entity name or nil if not found
+        def find_entity_name(table, id_column, name_column, id)
+          return nil unless database
+
+          collection = get_collection_for_table(table)
+          return nil unless collection
+
+          record = collection.find { |r| r.send(id_column) == id }
+          record&.send(name_column)
+        end
+
+        # Validates a collection of entities
+        #
+        # @param entities [Array] Collection of entities to validate
+        # @yield [entity] Validation block for each entity
+        # @return [ValidationResult]
+        def validate_each(entities, &block)
+          entities.each(&block)
+          @result
+        end
+
+        # Resolves package ID to full qualified path
+        #
+        # @param package_id [Integer] Package ID to resolve
+        # @return [String] Qualified path like
+        # "Root::ModelA::PackageB (package_id: 123)"
+        def resolve_package_path(package_id) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          return "Root" if package_id.nil? || package_id.zero?
+
+          path_parts = []
+          current_id = package_id
+
+          # Walk up the parent chain to build full path
+          while current_id && !current_id.zero?
+            package = database.packages.find { |p| p.package_id == current_id }
+
+            if package
+              path_parts.unshift(package.name)
+              # Get parent_id for next iteration
+              current_id = package.parent_id
+            else
+              # Package not found, return what we have with ID
+              path_parts.unshift("Unknown")
+              break
+            end
+          end
+
+          if path_parts.empty?
+            "Unknown (package_id: #{package_id})"
+          else
+            "#{path_parts.join('::')} (package_id: #{package_id})"
+          end
+        end
+
+        # Resolves object to qualified class name including package path
+        #
+        # @param object_id [Integer] Object ID to resolve
+        # @param object_name [String, nil] Object name if already known
+        # @return [String] Qualified name like "Package::ClassName
+        # (object_id: 456)"
+        def resolve_class_path(object_id, object_name = nil) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          return "Unknown (object_id: #{object_id})" if object_id.nil?
+
+          # Get object from collection directly
+          object = database.objects.all.find do |obj|
+            obj.ea_object_id == object_id
+          end
+          return "Unknown (object_id: #{object_id})" unless object
+
+          # Get class name
+          class_name = object_name || object.name
+          package_id = object.package_id
+
+          if package_id && !package_id.zero?
+            package_path = resolve_package_path(package_id)
+            # Remove the package_id suffix from package path and add class
+            base_package_path = package_path.sub(/ \(package_id: \d+\)$/, "")
+            "#{base_package_path}::" \
+              "#{class_name || 'Unknown'} (object_id: #{object_id})"
+          else
+            "#{class_name || 'Unknown'} (object_id: #{object_id})"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/qea/validation/class_validator.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require_relative "base_validator"
+
+module Lutaml
+  module Qea
+    module Validation
+      # Validates class/object references and structure
+      class ClassValidator < BaseValidator
+        def validate
+          validate_package_references
+          validate_duplicate_names
+          validate_generalization_parents
+        end
+
+        private
+
+        def validate_package_references # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          objects.each do |obj|
+            next unless obj.package_id
+
+            unless package_exists?(obj.package_id)
+              class_path = resolve_class_path(obj.ea_object_id, obj.name)
+              result.add_error(
+                category: :missing_reference,
+                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: "Package #{obj.package_id} does not exist",
+                location: class_path,
+              )
+            end
+          end
+        end
+
+        def validate_duplicate_names # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          objects_by_package = objects.group_by(&:package_id)
+
+          objects_by_package.each do |package_id, package_objects|
+            names = package_objects.map(&:name)
+            duplicates = names.select { |name| names.count(name) > 1 }.uniq
+
+            duplicates.each do |dup_name|
+              dup_objects = package_objects.select { |o| o.name == dup_name }
+              dup_objects.each do |obj|
+                class_path = resolve_class_path(obj.ea_object_id, obj.name)
+                package_path = if package_id
+                                 resolve_package_path(package_id)
+                               else
+                                 "Root"
+                               end
+                result.add_warning(
+                  category: :duplicate,
+                  entity_type: :class,
+                  entity_id: obj.ea_object_id.to_s,
+                  entity_name: obj.name,
+                  field: "name",
+                  message: "Duplicate class name '#{dup_name}' " \
+                           "in #{package_path}",
+                  location: class_path,
+                )
+              end
+            end
+          end
+        end
+
+        def validate_generalization_parents # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+          connectors.select(&:generalization?).each do |gen|
+            parent_id = gen.end_object_id
+
+            unless object_exists?(parent_id)
+              child = objects.find { |o| o.ea_object_id == gen.start_object_id }
+              child_path = if child
+                             resolve_class_path(child.ea_object_id,
+                                                child.name)
+                           else
+                             "Unknown"
+                           end
+              result.add_error(
+                category: :missing_reference,
+                entity_type: :generalization,
+                entity_id: gen.connector_id.to_s,
+                entity_name: child&.name || "Unknown",
+                field: "end_object_id",
+                reference: parent_id.to_s,
+                message: "Generalization parent #{parent_id} does not exist",
+                location: child_path,
+              )
+            end
+          end
+        end
+
+        def objects
+          @objects ||= begin
+            # Use database objects for referential integrity checks
+            # Filter to only Class and Interface types (exclude Notes, etc.)
+            all_objects = context[:db_objects] || context[:objects] || []
+            all_objects.select { |obj| obj.uml_class? || obj.interface? }
+          end
+        end
+
+        def packages
+          # Use database packages for referential integrity checks
+          @packages ||= context[:db_packages] || context[:packages] || []
+        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
+      end
+    end
+  end
+end

data/lib/lutaml/qea/validation/database/circular_reference_validator.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require_relative "../base_validator"
+
+module Lutaml
+  module Qea
+    module Validation
+      # Detects circular dependencies and references
+      class CircularReferenceValidator < BaseValidator
+        def validate
+          detect_circular_packages
+          detect_circular_generalizations
+        end
+
+        private
+
+        def detect_circular_packages # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity,Metrics/MethodLength
+          packages.each do |package|
+            next if package.root?
+
+            visited = Set.new([package.package_id])
+            current_id = package.parent_id
+
+            while current_id && !current_id.zero?
+              if visited.include?(current_id)
+                result.add_error(
+                  category: :circular_reference,
+                  entity_type: :package,
+                  entity_id: package.package_id.to_s,
+                  entity_name: package.name,
+                  field: "parent_id",
+                  message: "Circular package hierarchy: " \
+                           "#{visited.to_a.join(' -> ')} -> #{current_id}",
+                )
+                break
+              end
+
+              visited << current_id
+              parent = packages.find { |p| p.package_id == current_id }
+              break unless parent
+
+              current_id = parent.parent_id
+            end
+          end
+        end
+
+        def detect_circular_generalizations # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          # Build generalization graph
+          generalizations = connectors.select(&:generalization?)
+
+          # For each class, check if it has circular inheritance
+          objects.each do |obj|
+            visited = Set.new([obj.ea_object_id])
+            queue = [obj.ea_object_id]
+
+            while queue.any?
+              current_id = queue.shift
+
+              # Find all parents of current object
+              parents = generalizations
+                .select { |g| g.start_object_id == current_id }
+                .map(&:end_object_id)
+
+              parents.each do |parent_id|
+                if visited.include?(parent_id)
+                  # Found circular inheritance
+                  result.add_error(
+                    category: :circular_reference,
+                    entity_type: :generalization,
+                    entity_id: obj.ea_object_id.to_s,
+                    entity_name: obj.name,
+                    message: "Circular inheritance detected: " \
+                             "#{format_inheritance_path(visited, parent_id)}",
+                  )
+                  next
+                end
+
+                visited << parent_id
+                queue << parent_id
+              end
+            end
+          end
+        end
+
+        def format_inheritance_path(visited_ids, circular_id) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+          path = visited_ids.map do |id|
+            obj = objects.find { |o| o.ea_object_id == id }
+            obj&.name || id.to_s
+          end
+
+          circular_obj = objects.find { |o| o.ea_object_id == circular_id }
+          path << (circular_obj&.name || circular_id.to_s)
+
+          path.join(" -> ")
+        end
+
+        def packages
+          @packages ||= context[:db_packages] || []
+        end
+
+        def objects
+          @objects ||= context[:db_objects] || []
+        end
+
+        def connectors
+          @connectors ||= context[:connectors] || []
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require_relative "../base_validator"
+
+module Lutaml
+  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