ea 0.1.0 → 0.1.4

data/lib/ea/qea/verification/document_normalizer.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Verification
+      # Normalizes UML documents for comparison by removing XMI IDs,
+      # sorting collections, and normalizing strings
+      class DocumentNormalizer
+        # Normalize a document for comparison
+        #
+        # @param document [Lutaml::Uml::Document] The document to normalize
+        # @return [Lutaml::Uml::Document] A normalized copy
+        def normalize(document)
+          remove_xmi_ids(document)
+          sort_collections(document)
+          normalize_strings_in_document(document)
+          document
+        end
+
+        # Remove all XMI IDs from document
+        #
+        # @param document [Lutaml::Uml::Document] The document to process
+        # @return [void]
+        def remove_xmi_ids(document) # rubocop:disable Metrics/AbcSize
+          # Remove XMI IDs from packages recursively
+          process_packages(document.packages) if document.packages
+
+          # Remove XMI IDs from classes
+          process_classes(document.classes) if document.classes
+
+          # Remove XMI IDs from associations
+          process_associations(document.associations) if document.associations
+
+          # Remove XMI IDs from enums
+          process_enums(document.enums) if document.enums
+
+          # Remove XMI IDs from data types
+          process_data_types(document.data_types) if document.data_types
+        end
+
+        # Sort collections in document for consistent comparison
+        #
+        # @param document [Lutaml::Uml::Document] The document to process
+        # @return [void]
+        def sort_collections(document) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+          # Sort top-level collections by name
+          document.packages&.sort_by! { |p| p.name || "" }
+          document.classes&.sort_by! { |c| c.name || "" }
+          document.enums&.sort_by! { |e| e.name || "" }
+          document.data_types&.sort_by! { |dt| dt.name || "" }
+          document.associations&.sort_by! do |a|
+            "#{a.owner_end}#{a.member_end}"
+          end
+
+          # Sort nested collections recursively
+          sort_package_collections(document.packages) if document.packages
+          sort_class_collections(document.classes) if document.classes
+        end
+
+        # Normalize strings (trim whitespace, normalize case for comparison)
+        #
+        # @param text [String, nil] The text to normalize
+        # @return [String, nil] Normalized text
+        def normalize_string(text)
+          return nil if text.nil?
+          return text unless text.is_a?(String)
+
+          text.strip
+        end
+
+        private
+
+        # Process packages recursively to remove XMI IDs
+        def process_packages(packages) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
+          packages.each do |package|
+            package.xmi_id = nil
+            process_classes(package.classes) if package.classes
+            process_enums(package.enums) if package.enums
+            process_data_types(package.data_types) if package.data_types
+            process_packages(package.packages) if package.packages
+          end
+        end
+
+        # Process classes to remove XMI IDs
+        def process_classes(classes) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          classes.each do |klass|
+            klass.xmi_id = nil
+
+            # Remove XMI IDs from attributes
+            klass.attributes&.each do |attr|
+              attr.xmi_id = nil
+            end
+
+            # Remove XMI IDs from operations
+            klass.operations&.each do |op|
+              op.xmi_id = nil
+              op.parameters&.each do |param|
+                param.xmi_id = nil if param.class.attributes.key?(:xmi_id)
+              end
+            end
+
+            # Process nested classes
+            if klass.is_a?(Lutaml::Uml::Package) && klass.classes
+              process_classes(klass.classes)
+            end
+          end
+        end
+
+        # Process associations to remove XMI IDs
+        def process_associations(associations)
+          associations.each do |assoc|
+            assoc.xmi_id = nil
+            if assoc.owner_end_xmi_id
+              assoc.owner_end_xmi_id = nil
+            end
+            if assoc.member_end_xmi_id
+              assoc.member_end_xmi_id = nil
+            end
+          end
+        end
+
+        # Process enums to remove XMI IDs
+        def process_enums(enums)
+          enums.each do |enum|
+            enum.xmi_id = nil
+          end
+        end
+
+        # Process data types to remove XMI IDs
+        def process_data_types(data_types)
+          data_types.each do |dt|
+            dt.xmi_id = nil
+          end
+        end
+
+        # Sort collections within packages
+        def sort_package_collections(packages) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+          packages.each do |package|
+            package.classes&.sort_by! { |c| c.name || "" }
+            package.enums&.sort_by! { |e| e.name || "" }
+            package.data_types&.sort_by! { |dt| dt.name || "" }
+            package.packages&.sort_by! { |p| p.name || "" }
+
+            sort_class_collections(package.classes) if package.classes
+            sort_package_collections(package.packages) if package.packages
+          end
+        end
+
+        # Sort collections within classes
+        def sort_class_collections(classes) # rubocop:disable Metrics/CyclomaticComplexity
+          classes.each do |klass|
+            klass.attributes&.sort_by! { |a| a.name || "" }
+            klass.operations&.sort_by! { |o| o.name || "" }
+            klass.associations&.sort_by! do |a|
+              "#{a.owner_end}#{a.member_end}"
+            end
+          end
+        end
+
+        # Normalize strings throughout document
+        def normalize_strings_in_document(document)
+          # This is a placeholder for string normalization
+          # Can be extended to normalize strings throughout the document
+          # For now, normalization happens during comparison
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,322 @@
+# frozen_string_literal: true
+
+module Ea
+  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)
+          Ea::Xmi::Parser.parse(File.new(xmi_path))
+        end
+
+        # Parse QEA file
+        def parse_qea(qea_path)
+          Ea::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_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