lutaml 0.10.19 → 0.11.2

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

@@ -1,312 +0,0 @@
-# frozen_string_literal: true
-
-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? do |record|
-            record.public_send(id_column) == reference_id
-          end
-        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)
-          return false if value.nil?
-          return !value.empty? if value.is_a?(String) || value.is_a?(Array)
-
-          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.public_send(id_column) == id }
-          record&.public_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, &)
-          entities.each(&)
-          @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
-          visited = Set.new
-
-          # Walk up the parent chain to build full path
-          while current_id && !current_id.zero?
-            break if visited.include?(current_id)
-
-            visited.add(current_id)
-            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

@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -1,153 +0,0 @@
-# frozen_string_literal: true
-
-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