ea 0.1.0 → 0.1.4

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

@@ -0,0 +1,277 @@
+# frozen_string_literal: true
+
+module Ea
+  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::UmlClass] XMI class
+        # @param qea_class [Lutaml::Uml::UmlClass] 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

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

@@ -0,0 +1,287 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Verification
+      # Matches corresponding elements between XMI and QEA documents
+      # by qualified name/path
+      class StructureMatcher
+        # Match packages between documents
+        #
+        # @param xmi_doc [Lutaml::Uml::Document] XMI document
+        # @param qea_doc [Lutaml::Uml::Document] QEA document
+        # @return [Hash] Hash with :matches, :xmi_only, :qea_only
+        def match_packages(xmi_doc, qea_doc)
+          xmi_packages = build_package_index(xmi_doc.packages)
+          qea_packages = build_package_index(qea_doc.packages)
+
+          match_elements(xmi_packages, qea_packages)
+        end
+
+        # Match classes between documents
+        #
+        # @param xmi_doc [Lutaml::Uml::Document] XMI document
+        # @param qea_doc [Lutaml::Uml::Document] QEA document
+        # @return [Hash] Hash with :matches, :xmi_only, :qea_only
+        def match_classes(xmi_doc, qea_doc)
+          xmi_classes = build_class_index(xmi_doc)
+          qea_classes = build_class_index(qea_doc)
+
+          match_elements(xmi_classes, qea_classes)
+        end
+
+        # Match attributes between classes
+        #
+        # @param xmi_class [Lutaml::Uml::UmlClass] XMI class
+        # @param qea_class [Lutaml::Uml::UmlClass] QEA class
+        # @return [Hash] Hash with :matches, :xmi_only, :qea_only
+        def match_attributes(xmi_class, qea_class)
+          xmi_attrs = index_by_name(xmi_class.attributes || [])
+          qea_attrs = index_by_name(qea_class.attributes || [])
+
+          match_elements(xmi_attrs, qea_attrs)
+        end
+
+        # Match operations between classes
+        #
+        # @param xmi_class [Lutaml::Uml::UmlClass] XMI class
+        # @param qea_class [Lutaml::Uml::UmlClass] QEA class
+        # @return [Hash] Hash with :matches, :xmi_only, :qea_only
+        def match_operations(xmi_class, qea_class)
+          xmi_ops = index_by_signature(xmi_class.operations || [])
+          qea_ops = index_by_signature(qea_class.operations || [])
+
+          match_elements(xmi_ops, qea_ops)
+        end
+
+        # Build qualified name index for document
+        #
+        # @param document [Lutaml::Uml::Document] The document
+        # @return [Hash] Hash mapping qualified names to elements
+        def build_qualified_names(document)
+          {
+            packages: build_package_index(document.packages),
+            classes: build_class_index(document),
+            enums: build_enum_index(document),
+            data_types: build_data_type_index(document),
+          }
+        end
+
+        private
+
+        # Build package index with qualified paths
+        def build_package_index(packages, parent_path = "") # rubocop:disable Metrics/MethodLength
+          index = {}
+          return index unless packages
+
+          packages.each do |package|
+            next unless package.name
+
+            qualified_path = build_path(parent_path, package.name)
+            index[qualified_path] = package
+
+            # Recursively index nested packages
+            nested = build_package_index(package.packages, qualified_path)
+            index.merge!(nested)
+          end
+
+          index
+        end
+
+        # Build class index from document and packages
+        def build_class_index(document) # rubocop:disable Metrics/MethodLength
+          index = {}
+
+          # Index top-level classes
+          document.classes&.each do |klass|
+            next unless klass.name
+
+            index[klass.name] = klass
+          end
+
+          # Index classes in packages
+          if document.packages
+            index_classes_in_packages(document.packages, "",
+                                      index)
+          end
+
+          index
+        end
+
+        # Recursively index classes in packages
+        def index_classes_in_packages(packages, parent_path, index) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
+          return unless packages
+
+          packages.each do |package|
+            next unless package.name
+
+            package_path = build_path(parent_path, package.name)
+
+            package.classes&.each do |klass|
+              next unless klass.name
+
+              qualified_name = "#{package_path}::#{klass.name}"
+              index[qualified_name] = klass
+            end
+
+            # Recurse into nested packages
+            index_classes_in_packages(package.packages, package_path, index)
+          end
+        end
+
+        # Build enum index from document and packages
+        def build_enum_index(document) # rubocop:disable Metrics/MethodLength
+          index = {}
+
+          # Index top-level enums
+          document.enums&.each do |enum|
+            next unless enum.name
+
+            index[enum.name] = enum
+          end
+
+          # Index enums in packages
+          if document.packages
+            index_enums_in_packages(document.packages, "",
+                                    index)
+          end
+
+          index
+        end
+
+        # Recursively index enums in packages
+        def index_enums_in_packages(packages, parent_path, index) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
+          return unless packages
+
+          packages.each do |package|
+            next unless package.name
+
+            package_path = build_path(parent_path, package.name)
+
+            package.enums&.each do |enum|
+              next unless enum.name
+
+              qualified_name = "#{package_path}::#{enum.name}"
+              index[qualified_name] = enum
+            end
+
+            # Recurse into nested packages
+            index_enums_in_packages(package.packages, package_path, index)
+          end
+        end
+
+        # Build data type index from document and packages
+        def build_data_type_index(document) # rubocop:disable Metrics/MethodLength
+          index = {}
+
+          # Index top-level data types
+          document.data_types&.each do |dt|
+            next unless dt.name
+
+            index[dt.name] = dt
+          end
+
+          # Index data types in packages
+          if document.packages
+            index_data_types_in_packages(document.packages, "",
+                                         index)
+          end
+
+          index
+        end
+
+        # Recursively index data types in packages
+        def index_data_types_in_packages(packages, parent_path, index) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
+          return unless packages
+
+          packages.each do |package|
+            next unless package.name
+
+            package_path = build_path(parent_path, package.name)
+
+            package.data_types&.each do |dt|
+              next unless dt.name
+
+              qualified_name = "#{package_path}::#{dt.name}"
+              index[qualified_name] = dt
+            end
+
+            # Recurse into nested packages
+            index_data_types_in_packages(package.packages, package_path, index)
+          end
+        end
+
+        # Build qualified path from parent and name
+        def build_path(parent_path, name)
+          return name if parent_path.empty?
+
+          "#{parent_path}::#{name}"
+        end
+
+        # Index collection by name
+        def index_by_name(collection)
+          index = {}
+          collection.each do |element|
+            next unless element.name
+
+            index[element.name] = element
+          end
+          index
+        end
+
+        # Index operations by signature (name + parameter types)
+        def index_by_signature(operations)
+          index = {}
+          operations.each do |operation|
+            next unless operation.name
+
+            signature = build_operation_signature(operation)
+            index[signature] = operation
+          end
+          index
+        end
+
+        # Build operation signature for matching
+        def build_operation_signature(operation)
+          return operation.name unless operation.owned_parameter
+
+          param_types = operation.owned_parameter.map do |param|
+            param.type || "unknown"
+          end.join(",")
+
+          "#{operation.name}(#{param_types})"
+        end
+
+        # Match elements between two indexes
+        def match_elements(xmi_index, qea_index) # rubocop:disable Metrics/MethodLength
+          matches = {}
+          xmi_only = []
+          qea_only = []
+
+          # Find matches and XMI-only elements
+          xmi_index.each do |key, xmi_element|
+            if qea_index.key?(key)
+              matches[key] = {
+                xmi: xmi_element,
+                qea: qea_index[key],
+              }
+            else
+              xmi_only << key
+            end
+          end
+
+          # Find QEA-only elements
+          qea_index.each_key do |key|
+            qea_only << key unless xmi_index.key?(key)
+          end
+
+          {
+            matches: matches,
+            xmi_only: xmi_only.sort,
+            qea_only: qea_only.sort,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ea/qea/verification.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Verification
+      autoload :DocumentNormalizer,
+               "ea/qea/verification/document_normalizer"
+      autoload :StructureMatcher, "ea/qea/verification/structure_matcher"
+      autoload :ElementComparator, "ea/qea/verification/element_comparator"
+      autoload :ComparisonResult, "ea/qea/verification/comparison_result"
+      autoload :DocumentVerifier, "ea/qea/verification/document_verifier"
+    end
+  end
+end