lutaml 0.10.19 → 0.11.2

data/lib/lutaml/qea/verification/document_verifier.rb

@@ -1,323 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Qea
-    module Verification
-      # Main orchestrator for document verification
-      # Verifies that QEA-parsed documents contain at least as much
-      # information as XMI-parsed equivalents
-      class DocumentVerifier
-        attr_reader :normalizer, :matcher, :comparator, :result
-
-        def initialize
-          @normalizer = DocumentNormalizer.new
-          @matcher = StructureMatcher.new
-          @comparator = ElementComparator.new
-          @result = ComparisonResult.new
-        end
-
-        # Main verification method
-        #
-        # @param xmi_path [String] Path to XMI file
-        # @param qea_path [String] Path to QEA file
-        # @return [ComparisonResult] Verification result
-        def verify(xmi_path, qea_path) # rubocop:disable Metrics/MethodLength
-          # Parse documents
-          xmi_doc = parse_xmi(xmi_path)
-          qea_doc = parse_qea(qea_path)
-
-          # Normalize documents
-          xmi_normalized = normalizer.normalize(xmi_doc)
-          qea_normalized = normalizer.normalize(qea_doc)
-
-          # Perform verification
-          verify_structure(xmi_normalized, qea_normalized)
-          verify_names(xmi_normalized, qea_normalized)
-          verify_properties(xmi_normalized, qea_normalized)
-          verify_relationships(xmi_normalized, qea_normalized)
-
-          result
-        end
-
-        # Verify document with already loaded documents
-        #
-        # @param xmi_doc [Lutaml::Uml::Document] XMI document
-        # @param qea_doc [Lutaml::Uml::Document] QEA document
-        # @return [ComparisonResult] Verification result
-        def verify_documents(xmi_doc, qea_doc)
-          # Normalize documents
-          xmi_normalized = normalizer.normalize(xmi_doc)
-          qea_normalized = normalizer.normalize(qea_doc)
-
-          # Perform verification
-          verify_structure(xmi_normalized, qea_normalized)
-          verify_names(xmi_normalized, qea_normalized)
-          verify_properties(xmi_normalized, qea_normalized)
-          verify_relationships(xmi_normalized, qea_normalized)
-
-          result
-        end
-
-        # Reset cached match results (call between verifications)
-        def reset_cache
-          @cached_class_matches = nil
-          @cached_package_matches = nil
-        end
-
-        # Compare element counts
-        #
-        # @param xmi_doc [Lutaml::Uml::Document] XMI document
-        # @param qea_doc [Lutaml::Uml::Document] QEA document
-        # @return [void]
-        def verify_structure(xmi_doc, qea_doc) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-          # Compare package counts (cache for reuse in verify_properties)
-          @cached_package_matches = matcher.match_packages(xmi_doc, qea_doc)
-          result.add_matches(:packages, @cached_package_matches[:matches].size)
-          result.add_xmi_only(:packages, @cached_package_matches[:xmi_only])
-          result.add_qea_only(:packages, @cached_package_matches[:qea_only])
-
-          # Compare class counts (cache for reuse in verify_properties)
-          @cached_class_matches = matcher.match_classes(xmi_doc, qea_doc)
-          result.add_matches(:classes, @cached_class_matches[:matches].size)
-          result.add_xmi_only(:classes, @cached_class_matches[:xmi_only])
-          result.add_qea_only(:classes, @cached_class_matches[:qea_only])
-
-          # Compare enum counts
-          xmi_enums = count_all_enums(xmi_doc)
-          qea_enums = count_all_enums(qea_doc)
-          if qea_enums < xmi_enums
-            result.add_difference(
-              "Enums: #{xmi_enums} (XMI) vs #{qea_enums} (QEA) - QEA has fewer",
-            )
-          end
-
-          # Compare data type counts
-          xmi_dt = count_all_data_types(xmi_doc)
-          qea_dt = count_all_data_types(qea_doc)
-          if qea_dt < xmi_dt
-            result.add_difference(
-              "Data types: #{xmi_dt} (XMI) vs #{qea_dt} (QEA) - QEA has fewer",
-            )
-          end
-
-          # Compare association counts
-          xmi_assocs = count_all_associations(xmi_doc)
-          qea_assocs = count_all_associations(qea_doc)
-          result.add_matches(:associations, [xmi_assocs, qea_assocs].min)
-          if qea_assocs < xmi_assocs
-            result.add_difference(
-              "Associations: #{xmi_assocs} (XMI) " \
-              "vs #{qea_assocs} (QEA) - QEA has fewer",
-            )
-          end
-        end
-
-        # Verify element names are preserved
-        #
-        # @param xmi_doc [Lutaml::Uml::Document] XMI document
-        # @param qea_doc [Lutaml::Uml::Document] QEA document
-        # @return [void]
-        def verify_names(xmi_doc, qea_doc)
-          # Package names verified in match_packages
-          # Class names verified in match_classes
-          # Additional verification could be added here
-        end
-
-        # Verify properties of matched elements
-        #
-        # @param xmi_doc [Lutaml::Uml::Document] XMI document
-        # @param qea_doc [Lutaml::Uml::Document] QEA document
-        # @return [void]
-        def verify_properties(xmi_doc, qea_doc)
-          # Verify class properties (reuse cached matches from verify_structure)
-          class_matches = @cached_class_matches || matcher.match_classes(
-            xmi_doc, qea_doc
-          )
-          verify_class_properties(class_matches[:matches])
-
-          # Verify package properties (reuse cached matches from verify_structure)
-          package_matches = @cached_package_matches || matcher.match_packages(
-            xmi_doc, qea_doc
-          )
-          verify_package_properties(package_matches[:matches])
-        end
-
-        # Verify relationships (associations, generalizations)
-        #
-        # @param xmi_doc [Lutaml::Uml::Document] XMI document
-        # @param qea_doc [Lutaml::Uml::Document] QEA document
-        # @return [void]
-        def verify_relationships(xmi_doc, qea_doc)
-          # Verify associations are preserved
-          verify_associations(xmi_doc, qea_doc)
-        end
-
-        private
-
-        # Parse XMI file
-        def parse_xmi(xmi_path)
-          Lutaml::Xmi::Parsers::Xml.parse(File.new(xmi_path))
-        end
-
-        # Parse QEA file
-        def parse_qea(qea_path)
-          Lutaml::Qea.parse(qea_path)
-        end
-
-        # Count all enums in document including nested
-        def count_all_enums(document)
-          count = document.enums&.size || 0
-          count + count_enums_in_packages(document.packages)
-        end
-
-        # Count enums in packages recursively
-        def count_enums_in_packages(packages)
-          return 0 unless packages
-
-          count = 0
-          packages.each do |package|
-            count += package.enums&.size || 0
-            count += count_enums_in_packages(package.packages)
-          end
-          count
-        end
-
-        # Count all data types in document including nested
-        def count_all_data_types(document)
-          count = document.data_types&.size || 0
-          count + count_data_types_in_packages(document.packages)
-        end
-
-        # Count data types in packages recursively
-        def count_data_types_in_packages(packages)
-          return 0 unless packages
-
-          count = 0
-          packages.each do |package|
-            count += package.data_types&.size || 0
-            count += count_data_types_in_packages(package.packages)
-          end
-          count
-        end
-
-        # Count all associations in document including nested
-        def count_all_associations(document)
-          count = document.associations&.size || 0
-          count + count_associations_in_classes(document.classes)
-          count + count_associations_in_packages(document.packages)
-        end
-
-        # Count associations in classes
-        def count_associations_in_classes(classes)
-          return 0 unless classes
-
-          count = 0
-          classes.each do |klass|
-            count += klass.associations&.size || 0
-          end
-          count
-        end
-
-        # Count associations in packages recursively
-        def count_associations_in_packages(packages)
-          return 0 unless packages
-
-          count = 0
-          packages.each do |package|
-            count += count_associations_in_classes(package.classes)
-            count += count_associations_in_packages(package.packages)
-          end
-          count
-        end
-
-        # Verify class properties
-        def verify_class_properties(matches) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength
-          attr_count = 0
-          op_count = 0
-
-          matches.each do |qualified_name, pair| # rubocop:disable Metrics/BlockLength
-            xmi_class = pair[:xmi]
-            qea_class = pair[:qea]
-
-            # Compare class properties
-            comparison = comparator.compare_classes(xmi_class, qea_class)
-            unless comparison[:equal]
-              result.add_property_difference(
-                :class,
-                qualified_name,
-                comparison[:differences],
-              )
-            end
-
-            # Compare attributes
-            attr_matches = matcher.match_attributes(xmi_class, qea_class)
-            attr_count += attr_matches[:matches].size
-
-            attr_matches[:matches].each do |attr_name, attr_pair|
-              attr_comparison = comparator.compare_attributes(
-                attr_pair[:xmi],
-                attr_pair[:qea],
-              )
-              unless attr_comparison[:equal]
-                result.add_property_difference(
-                  :attribute,
-                  "#{qualified_name}.#{attr_name}",
-                  attr_comparison[:differences],
-                )
-              end
-            end
-
-            # Compare operations
-            op_matches = matcher.match_operations(xmi_class, qea_class)
-            op_count += op_matches[:matches].size
-
-            op_matches[:matches].each do |op_sig, op_pair|
-              op_comparison = comparator.compare_operations(
-                op_pair[:xmi],
-                op_pair[:qea],
-              )
-              unless op_comparison[:equal]
-                result.add_property_difference(
-                  :operation,
-                  "#{qualified_name}.#{op_sig}",
-                  op_comparison[:differences],
-                )
-              end
-            end
-          end
-
-          result.add_matches(:attributes, attr_count)
-          result.add_matches(:operations, op_count)
-        end
-
-        # Verify package properties
-        def verify_package_properties(matches)
-          matches.each do |qualified_path, pair|
-            comparison = comparator.compare_packages(pair[:xmi], pair[:qea])
-            unless comparison[:equal]
-              result.add_property_difference(
-                :package,
-                qualified_path,
-                comparison[:differences],
-              )
-            end
-          end
-        end
-
-        # Verify associations
-        def verify_associations(xmi_doc, qea_doc)
-          # Simple count-based verification for now
-          # Could be enhanced to match associations by endpoints
-          xmi_assocs = count_all_associations(xmi_doc)
-          qea_assocs = count_all_associations(qea_doc)
-
-          if qea_assocs < xmi_assocs
-            result.add_difference(
-              "Missing #{xmi_assocs - qea_assocs} associations in QEA",
-            )
-          end
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/qea/verification/element_comparator.rb

@@ -1,277 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Qea
-    module Verification
-      # Compares matched element pairs to find differences
-      class ElementComparator
-        # Compare package properties
-        #
-        # @param xmi_pkg [Lutaml::Uml::Package] XMI package
-        # @param qea_pkg [Lutaml::Uml::Package] QEA package
-        # @return [Hash] Comparison result with :equal and :differences
-        def compare_packages(xmi_pkg, qea_pkg) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-          differences = []
-
-          # Compare basic properties
-          unless names_equal?(xmi_pkg.name, qea_pkg.name)
-            differences << "Name: '#{xmi_pkg.name}' vs '#{qea_pkg.name}'"
-          end
-
-          # Compare collection counts
-          compare_collection_count(
-            xmi_pkg.classes, qea_pkg.classes, "classes", differences
-          )
-          compare_collection_count(
-            xmi_pkg.enums, qea_pkg.enums, "enums", differences
-          )
-          compare_collection_count(
-            xmi_pkg.data_types, qea_pkg.data_types, "data_types", differences
-          )
-          compare_collection_count(
-            xmi_pkg.packages, qea_pkg.packages, "packages", differences
-          )
-
-          {
-            equal: differences.empty?,
-            differences: differences,
-          }
-        end
-
-        # Compare class properties
-        #
-        # @param xmi_class [Lutaml::Uml::Class] XMI class
-        # @param qea_class [Lutaml::Uml::Class] QEA class
-        # @return [Hash] Comparison result with :equal and :differences
-        def compare_classes(xmi_class, qea_class) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          differences = []
-
-          # Compare name
-          unless names_equal?(xmi_class.name, qea_class.name)
-            differences << "Name: '#{xmi_class.name}' vs '#{qea_class.name}'"
-          end
-
-          # Compare is_abstract
-          if xmi_class.is_abstract != qea_class.is_abstract
-            differences << "is_abstract: #{xmi_class.is_abstract} " \
-                           "vs #{qea_class.is_abstract}"
-          end
-
-          # Compare type
-          if normalize_value(xmi_class.type) != normalize_value(qea_class.type)
-            differences << "type: '#{xmi_class.type}' vs '#{qea_class.type}'"
-          end
-
-          # Compare modifier
-          if normalize_value(xmi_class.modifier) !=
-              normalize_value(qea_class.modifier)
-            differences << "modifier: '#{xmi_class.modifier}' " \
-                           "vs '#{qea_class.modifier}'"
-          end
-
-          # Compare collection counts
-          compare_collection_count(
-            xmi_class.attributes, qea_class.attributes,
-            "attributes", differences
-          )
-          compare_collection_count(
-            xmi_class.operations, qea_class.operations,
-            "operations", differences
-          )
-
-          {
-            equal: differences.empty?,
-            differences: differences,
-          }
-        end
-
-        # Compare attribute properties
-        #
-        # @param xmi_attr [Lutaml::Uml::TopElementAttribute] XMI attribute
-        # @param qea_attr [Lutaml::Uml::TopElementAttribute] QEA attribute
-        # @return [Hash] Comparison result with :equal and :differences
-        def compare_attributes(xmi_attr, qea_attr) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          differences = []
-
-          # Compare name
-          unless names_equal?(xmi_attr.name, qea_attr.name)
-            differences << "Name: '#{xmi_attr.name}' vs '#{qea_attr.name}'"
-          end
-
-          # Compare type
-          if normalize_value(xmi_attr.type) !=
-              normalize_value(qea_attr.type)
-            differences << "type: '#{xmi_attr.type}' vs '#{qea_attr.type}'"
-          end
-
-          # Compare visibility
-          if normalize_value(xmi_attr.visibility) !=
-              normalize_value(qea_attr.visibility)
-            differences << "visibility: '#{xmi_attr.visibility}' " \
-                           "vs '#{qea_attr.visibility}'"
-          end
-
-          # Compare cardinality if present
-          xmi_card = xmi_attr.cardinality
-          qea_card = qea_attr.cardinality
-          if xmi_card || qea_card
-            if xmi_card && qea_card
-              unless cardinalities_equal?(xmi_card, qea_card)
-                differences << "cardinality: #{format_cardinality(xmi_card)} " \
-                               "vs #{format_cardinality(qea_card)}"
-              end
-            elsif xmi_card || qea_card
-              differences << "cardinality: #{format_cardinality(xmi_card)} " \
-                             "vs #{format_cardinality(qea_card)}"
-            end
-          end
-
-          {
-            equal: differences.empty?,
-            differences: differences,
-          }
-        end
-
-        # Compare operation properties
-        #
-        # @param xmi_op [Lutaml::Uml::Operation] XMI operation
-        # @param qea_op [Lutaml::Uml::Operation] QEA operation
-        # @return [Hash] Comparison result with :equal and :differences
-        def compare_operations(xmi_op, qea_op) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          differences = []
-
-          # Compare name
-          unless names_equal?(xmi_op.name, qea_op.name)
-            differences << "Name: '#{xmi_op.name}' vs '#{qea_op.name}'"
-          end
-
-          # Compare return type
-          if normalize_value(xmi_op.return_type) !=
-              normalize_value(qea_op.return_type)
-            differences << "return_type: '#{xmi_op.return_type}' " \
-                           "vs '#{qea_op.return_type}'"
-          end
-
-          # Compare visibility
-          if normalize_value(xmi_op.visibility) !=
-              normalize_value(qea_op.visibility)
-            differences << "visibility: '#{xmi_op.visibility}' " \
-                           "vs '#{qea_op.visibility}'"
-          end
-
-          # Compare parameter counts
-          compare_collection_count(
-            xmi_op.parameters, qea_op.parameters, "parameters", differences
-          )
-
-          {
-            equal: differences.empty?,
-            differences: differences,
-          }
-        end
-
-        # Compare association properties
-        #
-        # @param xmi_assoc [Lutaml::Uml::Association] XMI association
-        # @param qea_assoc [Lutaml::Uml::Association] QEA association
-        # @return [Hash] Comparison result with :equal and :differences
-        def compare_associations(xmi_assoc, qea_assoc) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          differences = []
-
-          # Compare owner end
-          unless normalize_value(xmi_assoc.owner_end) ==
-              normalize_value(qea_assoc.owner_end)
-            differences << "owner_end: '#{xmi_assoc.owner_end}' " \
-                           "vs '#{qea_assoc.owner_end}'"
-          end
-
-          # Compare member end
-          unless normalize_value(xmi_assoc.member_end) ==
-              normalize_value(qea_assoc.member_end)
-            differences << "member_end: '#{xmi_assoc.member_end}' " \
-                           "vs '#{qea_assoc.member_end}'"
-          end
-
-          # Compare owner end cardinality
-          if xmi_assoc.owner_end_cardinality &&
-              qea_assoc.owner_end_cardinality &&
-              !cardinalities_equal?(
-                xmi_assoc.owner_end_cardinality,
-                qea_assoc.owner_end_cardinality,
-              )
-            differences << "owner_end_cardinality: " \
-                           "#{format_cardinality(xmi_assoc
-                           .owner_end_cardinality)} " \
-                           "vs #{format_cardinality(qea_assoc
-                           .owner_end_cardinality)}"
-          end
-
-          # Compare member end cardinality
-          if xmi_assoc.member_end_cardinality &&
-              qea_assoc.member_end_cardinality &&
-              !cardinalities_equal?(
-                xmi_assoc.member_end_cardinality,
-                qea_assoc.member_end_cardinality,
-              )
-            differences << "member_end_cardinality: " \
-                           "#{format_cardinality(xmi_assoc
-                            .member_end_cardinality)} " \
-                            "vs #{format_cardinality(qea_assoc
-                            .member_end_cardinality)}"
-          end
-
-          {
-            equal: differences.empty?,
-            differences: differences,
-          }
-        end
-
-        private
-
-        # Compare names with normalization
-        def names_equal?(name1, name2)
-          normalize_value(name1) == normalize_value(name2)
-        end
-
-        # Normalize value for comparison
-        def normalize_value(value)
-          return nil if value.nil?
-          return value unless value.is_a?(String)
-
-          value.strip
-        end
-
-        # Compare collection counts
-        def compare_collection_count(xmi_coll, qea_coll, name, differences) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          xmi_count = xmi_coll&.size || 0
-          qea_count = qea_coll&.size || 0
-
-          return if xmi_count == qea_count
-
-          suffix = if qea_count < xmi_count
-                     "QEA has fewer"
-                   else
-                     "QEA has more (acceptable)"
-                   end
-          differences << "#{name}: #{xmi_count} (XMI) vs " \
-                         "#{qea_count} (QEA) - #{suffix}"
-        end
-
-        # Check if cardinalities are equal
-        def cardinalities_equal?(card1, card2)
-          return true if card1.nil? && card2.nil?
-          return false if card1.nil? || card2.nil?
-
-          card1.min == card2.min && card1.max == card2.max
-        end
-
-        # Format cardinality for display
-        def format_cardinality(card)
-          return "nil" if card.nil?
-
-          "\#{card.min}..\#{card.max}"
-        end
-      end
-    end
-  end
-end