lutaml 0.9.43 → 0.10.0

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

@@ -0,0 +1,320 @@
+# frozen_string_literal: true
+
+require_relative "document_normalizer"
+require_relative "structure_matcher"
+require_relative "element_comparator"
+require_relative "comparison_result"
+require_relative "../../qea"
+require_relative "../../parser"
+
+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
+
+        # 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
+          match_result = matcher.match_packages(xmi_doc, qea_doc)
+          result.add_matches(:packages, match_result[:matches].size)
+          result.add_xmi_only(:packages, match_result[:xmi_only])
+          result.add_qea_only(:packages, match_result[:qea_only])
+
+          # Compare class counts
+          match_result = matcher.match_classes(xmi_doc, qea_doc)
+          result.add_matches(:classes, match_result[:matches].size)
+          result.add_xmi_only(:classes, match_result[:xmi_only])
+          result.add_qea_only(:classes, match_result[: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
+          class_matches = matcher.match_classes(xmi_doc, qea_doc)
+          verify_class_properties(class_matches[:matches])
+
+          # Verify package properties
+          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::Parser.parse([File.new(xmi_path)]).first
+        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

@@ -0,0 +1,306 @@
+# 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.respond_to?(:is_abstract) &&
+              qea_class.respond_to?(:is_abstract) &&
+              xmi_class.is_abstract != qea_class.is_abstract
+            differences << "is_abstract: #{xmi_class.is_abstract} " \
+                           "vs #{qea_class.is_abstract}"
+          end
+
+          # Compare type
+          if xmi_class.respond_to?(:type) &&
+              qea_class.respond_to?(:type) &&
+              normalize_value(xmi_class.type) != normalize_value(qea_class.type)
+            differences << "type: '#{xmi_class.type}' vs '#{qea_class.type}'"
+          end
+
+          # Compare modifier
+          if xmi_class.respond_to?(:modifier) &&
+              qea_class.respond_to?(:modifier) &&
+              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 xmi_attr.respond_to?(:type) &&
+              qea_attr.respond_to?(:type) &&
+              normalize_value(xmi_attr.type) !=
+                  normalize_value(qea_attr.type)
+            differences << "type: '#{xmi_attr.type}' vs '#{qea_attr.type}'"
+          end
+
+          # Compare visibility
+          if xmi_attr.respond_to?(:visibility) &&
+              qea_attr.respond_to?(:visibility) &&
+              normalize_value(xmi_attr.visibility) !=
+                  normalize_value(qea_attr.visibility)
+            differences << "visibility: '#{xmi_attr.visibility}' " \
+                           "vs '#{qea_attr.visibility}'"
+          end
+
+          # Compare cardinality if present
+          if xmi_attr.respond_to?(:cardinality) &&
+              qea_attr.respond_to?(:cardinality)
+            xmi_card = xmi_attr.cardinality
+            qea_card = qea_attr.cardinality
+            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 xmi_op.respond_to?(:return_type) &&
+              qea_op.respond_to?(:return_type) &&
+              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 xmi_op.respond_to?(:visibility) &&
+              qea_op.respond_to?(:visibility) &&
+              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) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          return true if card1.nil? && card2.nil?
+          return false if card1.nil? || card2.nil?
+
+          min_equal = (
+            card1.min || (card1.respond_to?(:min_value) && card1.min_value)
+          ) == (
+            card2.min || (card2.respond_to?(:min_value) && card2.min_value)
+          )
+          max_equal = (
+            card1.max || (card1.respond_to?(:max_value) && card1.max_value)
+          ) == (
+            card2.max || (card2.respond_to?(:max_value) && card2.max_value)
+          )
+
+          min_equal && max_equal
+        end
+
+        # Format cardinality for display
+        def format_cardinality(card)
+          return "nil" if card.nil?
+
+          min = card.min || (card.respond_to?(:min_value) && card.min_value)
+          max = card.max || (card.respond_to?(:max_value) && card.max_value)
+
+          "#{min}..#{max}"
+        end
+      end
+    end
+  end
+end