ea 0.1.0 → 0.1.4

data/lib/ea/qea/validation/validation_result.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Validation
+      # Collects and organizes validation messages, providing summary
+      # statistics and filtering capabilities
+      #
+      # @example Basic usage
+      #   result = ValidationResult.new
+      #   result.add_error(
+      #     category: :missing_reference,
+      #     entity_type: :association,
+      #     entity_id: "123",
+      #     entity_name: "MyAssociation",
+      #     message: "member_end references non-existent class"
+      #   )
+      #   puts result.summary
+      class ValidationResult
+        attr_reader :messages
+
+        def initialize
+          @messages = []
+        end
+
+        # Adds an error message to the result
+        #
+        # @param args [Hash] Message attributes (see ValidationMessage)
+        # @return [ValidationMessage] The created message
+        def add_error(**args)
+          add_message(severity: :error, **args)
+        end
+
+        # Adds a warning message to the result
+        #
+        # @param args [Hash] Message attributes (see ValidationMessage)
+        # @return [ValidationMessage] The created message
+        def add_warning(**args)
+          add_message(severity: :warning, **args)
+        end
+
+        # Adds an info message to the result
+        #
+        # @param args [Hash] Message attributes (see ValidationMessage)
+        # @return [ValidationMessage] The created message
+        def add_info(**args)
+          add_message(severity: :info, **args)
+        end
+
+        # Adds a message to the result
+        #
+        # @param args [Hash] Message attributes (see ValidationMessage)
+        # @return [ValidationMessage] The created message
+        def add_message(**args)
+          message = ValidationMessage.new(**args)
+          @messages << message
+          message
+        end
+
+        # Checks if there are any error messages
+        #
+        # @return [Boolean]
+        def has_errors?
+          @messages.any?(&:error?)
+        end
+
+        # Checks if there are any warning messages
+        #
+        # @return [Boolean]
+        def has_warnings?
+          @messages.any?(&:warning?)
+        end
+
+        # Checks if there are any info messages
+        #
+        # @return [Boolean]
+        def has_info?
+          @messages.any?(&:info?)
+        end
+
+        # Checks if the result is valid (no errors)
+        #
+        # @return [Boolean]
+        def valid?
+          !has_errors?
+        end
+
+        # Returns all error messages
+        #
+        # @return [Array<ValidationMessage>]
+        def errors
+          @messages.select(&:error?)
+        end
+
+        # Returns all warning messages
+        #
+        # @return [Array<ValidationMessage>]
+        def warnings
+          @messages.select(&:warning?)
+        end
+
+        # Returns all info messages
+        #
+        # @return [Array<ValidationMessage>]
+        def info
+          @messages.select(&:info?)
+        end
+
+        # Returns messages filtered by severity
+        #
+        # @param severity [Symbol] The severity to filter by
+        # @return [Array<ValidationMessage>]
+        def by_severity(severity)
+          @messages.select { |m| m.severity == severity }
+        end
+
+        # Returns messages filtered by category
+        #
+        # @param category [Symbol] The category to filter by
+        # @return [Array<ValidationMessage>]
+        def by_category(category)
+          @messages.select { |m| m.category == category }
+        end
+
+        # Returns messages filtered by entity type
+        #
+        # @param entity_type [Symbol] The entity type to filter by
+        # @return [Array<ValidationMessage>]
+        def by_entity_type(entity_type)
+          @messages.select { |m| m.entity_type == entity_type }
+        end
+
+        # Returns messages grouped by category
+        #
+        # @return [Hash<Symbol, Array<ValidationMessage>>]
+        def grouped_by_category
+          @messages.group_by(&:category)
+        end
+
+        # Returns messages grouped by severity
+        #
+        # @return [Hash<Symbol, Array<ValidationMessage>>]
+        def grouped_by_severity
+          @messages.group_by(&:severity)
+        end
+
+        # Returns messages grouped by entity type
+        #
+        # @return [Hash<Symbol, Array<ValidationMessage>>]
+        def grouped_by_entity_type
+          @messages.group_by(&:entity_type)
+        end
+
+        # Returns summary statistics
+        #
+        # @return [Hash]
+        def statistics
+          {
+            total: @messages.size,
+            errors: errors.size,
+            warnings: warnings.size,
+            info: info.size,
+            by_category: grouped_by_category.transform_values(&:size),
+            by_entity_type: grouped_by_entity_type.transform_values(&:size),
+          }
+        end
+
+        # Returns a summary string
+        #
+        # @return [String]
+        def summary
+          stats = statistics
+          [
+            "Total Messages: #{stats[:total]}",
+            "Errors: #{stats[:errors]}",
+            "Warnings: #{stats[:warnings]}",
+            "Info: #{stats[:info]}",
+          ].join("\n")
+        end
+
+        # Merges another result into this one
+        #
+        # @param other [ValidationResult] The result to merge
+        # @return [self]
+        def merge!(other)
+          @messages.concat(other.messages)
+          self
+        end
+
+        # Returns a hash representation
+        #
+        # @return [Hash]
+        def to_h
+          {
+            statistics: statistics,
+            messages: @messages.map(&:to_h),
+          }
+        end
+
+        # Returns a JSON representation
+        #
+        # @return [String]
+        def to_json(*)
+          require "json"
+          to_h.to_json(*)
+        end
+      end
+    end
+  end
+end

data/lib/ea/qea/validation/validator_registry.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Validation
+      # Registry for managing validators using the registry pattern
+      # Allows dynamic registration and retrieval of validators
+      #
+      # @example Registering and using validators
+      #   registry = ValidatorRegistry.new
+      #   registry.register(:package, PackageValidator)
+      #   registry.register(:class, ClassValidator)
+      #
+      #   validator = registry.get(:package)
+      #   result = validator.new(context).validate
+      class ValidatorRegistry
+        def initialize
+          @validators = {}
+        end
+
+        # Registers a validator class
+        #
+        # @param name [Symbol] Validator name/key
+        # @param validator_class [Class] Validator class (must inherit from
+        #   BaseValidator)
+        # @raise [ArgumentError] if validator_class is not a BaseValidator
+        # @return [void]
+        def register(name, validator_class)
+          unless validator_class.is_a?(Class)
+            raise ArgumentError,
+                  "Expected a Class, got #{validator_class.class}"
+          end
+
+          @validators[name] = validator_class
+        end
+
+        # Retrieves a validator class by name
+        #
+        # @param name [Symbol] Validator name/key
+        # @return [Class, nil] Validator class or nil if not found
+        def get(name)
+          @validators[name]
+        end
+
+        # Retrieves a validator class by name, raising an error if not found
+        #
+        # @param name [Symbol] Validator name/key
+        # @return [Class]
+        # @raise [KeyError] if validator not found
+        def fetch(name)
+          @validators.fetch(name) do
+            raise KeyError, "Validator '#{name}' not registered"
+          end
+        end
+
+        # Checks if a validator is registered
+        #
+        # @param name [Symbol] Validator name/key
+        # @return [Boolean]
+        def registered?(name)
+          @validators.key?(name)
+        end
+
+        # Returns all registered validator names
+        #
+        # @return [Array<Symbol>]
+        def names
+          @validators.keys
+        end
+
+        # Returns all registered validators
+        #
+        # @return [Hash<Symbol, Class>]
+        def all
+          @validators.dup
+        end
+
+        # Unregisters a validator
+        #
+        # @param name [Symbol] Validator name/key
+        # @return [Class, nil] The unregistered validator class
+        def unregister(name)
+          @validators.delete(name)
+        end
+
+        # Clears all registered validators
+        #
+        # @return [void]
+        def clear
+          @validators.clear
+        end
+
+        # Creates a validator instance
+        #
+        # @param name [Symbol] Validator name/key
+        # @param context [Hash] Validation context (must include :result key)
+        # @return [BaseValidator] Validator instance
+        # @raise [KeyError] if validator not found
+        def create(name, context = {})
+          result = context[:result] || ValidationResult.new
+          fetch(name).new(result: result, context: context)
+        end
+
+        # Runs a validator and returns the result
+        #
+        # @param name [Symbol] Validator name/key
+        # @param context [Hash] Validation context (must include :result key)
+        # @return [ValidationResult]
+        # @raise [KeyError] if validator not found
+        def validate(name, context = {})
+          validator = create(name, context)
+          validator.call
+          validator.result
+        end
+
+        # Runs multiple validators and merges their results
+        #
+        # @param names [Array<Symbol>] Validator names/keys
+        # @param context [Hash] Validation context
+        # @return [ValidationResult] Merged validation result
+        def validate_all(names, context = {})
+          result = context[:result] || ValidationResult.new
+          context[:result] = result
+
+          names.each do |name|
+            validate(name, context)
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/ea/qea/validation.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Validation
+      autoload :ValidationMessage, "ea/qea/validation/validation_message"
+      autoload :ValidationResult, "ea/qea/validation/validation_result"
+      autoload :BaseValidator, "ea/qea/validation/base_validator"
+      autoload :ValidatorRegistry, "ea/qea/validation/validator_registry"
+      autoload :AssociationValidator,
+               "ea/qea/validation/association_validator"
+      autoload :AttributeValidator, "ea/qea/validation/attribute_validator"
+      autoload :ClassValidator, "ea/qea/validation/class_validator"
+      autoload :DiagramValidator, "ea/qea/validation/diagram_validator"
+      autoload :OperationValidator, "ea/qea/validation/operation_validator"
+      autoload :PackageValidator, "ea/qea/validation/package_validator"
+      autoload :ReferentialIntegrityValidator,
+               "ea/qea/validation/database/referential_integrity_validator"
+      autoload :OrphanValidator,
+               "ea/qea/validation/database/orphan_validator"
+      autoload :CircularReferenceValidator,
+               "ea/qea/validation/database/circular_reference_validator"
+      autoload :Database, "ea/qea/validation/database"
+      autoload :Formatters, "ea/qea/validation/formatters"
+      autoload :ValidationEngine, "ea/qea/validation/validation_engine"
+    end
+  end
+end

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

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Verification
+      # Holds comparison results between XMI and QEA documents
+      class ComparisonResult
+        attr_reader :matches, :differences, :xmi_only, :qea_only,
+                    :property_differences
+
+        def initialize # rubocop:disable Metrics/MethodLength
+          @matches = {
+            packages: 0,
+            classes: 0,
+            enums: 0,
+            data_types: 0,
+            associations: 0,
+            attributes: 0,
+            operations: 0,
+          }
+          @differences = []
+          @xmi_only = {
+            packages: [],
+            classes: [],
+            enums: [],
+            data_types: [],
+            associations: [],
+          }
+          @qea_only = {
+            packages: [],
+            classes: [],
+            enums: [],
+            data_types: [],
+            associations: [],
+          }
+          @property_differences = []
+        end
+
+        # Record matched elements
+        #
+        # @param type [Symbol] Element type (:packages, :classes, etc.)
+        # @param count [Integer] Number of matches
+        def add_matches(type, count)
+          @matches[type] = count
+        end
+
+        # Record XMI-only elements
+        #
+        # @param type [Symbol] Element type
+        # @param elements [Array<String>] Element names/paths
+        def add_xmi_only(type, elements)
+          @xmi_only[type] = elements
+        end
+
+        # Record QEA-only elements
+        #
+        # @param type [Symbol] Element type
+        # @param elements [Array<String>] Element names/paths
+        def add_qea_only(type, elements)
+          @qea_only[type] = elements
+        end
+
+        # Record a difference
+        #
+        # @param description [String] Difference description
+        def add_difference(description)
+          @differences << description
+        end
+
+        # Record property-level difference
+        #
+        # @param element_type [Symbol] Element type
+        # @param element_name [String] Element name
+        # @param differences [Array<String>] List of property differences
+        def add_property_difference(element_type, element_name, differences)
+          @property_differences << {
+            type: element_type,
+            name: element_name,
+            differences: differences,
+          }
+        end
+
+        # Check if documents are equivalent
+        # QEA is considered equivalent if it has >= information compared to XMI
+        #
+        # @return [Boolean] True if equivalent
+        def equivalent?
+          # No critical XMI-only elements (some are acceptable)
+          critical_xmi_only = xmi_only[:classes].any? ||
+            xmi_only[:packages].any?
+
+          # No property differences that indicate information loss
+          critical_property_diffs = property_differences.any? do |diff|
+            diff[:differences].any? { |d| d.include?("QEA has fewer") }
+          end
+
+          !critical_xmi_only && !critical_property_diffs
+        end
+
+        # Generate human-readable summary
+        #
+        # @return [String] Summary text
+        def summary # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          lines = []
+          lines << "=== Verification Summary ==="
+          lines << ""
+
+          # Matches
+          lines << "Matched Elements:"
+          matches.each do |type, count|
+            next if count.zero?
+
+            lines << "  ✓ #{type.to_s.capitalize}: #{count}"
+          end
+          lines << ""
+
+          # XMI-only elements
+          if xmi_only.values.any?(&:any?)
+            lines << "XMI-Only Elements (missing in QEA):"
+            xmi_only.each do |type, elements|
+              next if elements.empty?
+
+              lines << "  ✗ #{type.to_s.capitalize}: #{elements.size}"
+              elements.first(5).each do |elem|
+                lines << "    - #{elem}"
+              end
+              if elements.size > 5
+                lines << "    ... and #{elements.size - 5} more"
+              end
+            end
+            lines << ""
+          end
+
+          # QEA-only elements (acceptable, shows QEA richness)
+          if qea_only.values.any?(&:any?)
+            lines << "QEA-Only Elements (additional in QEA - acceptable):"
+            qea_only.each do |type, elements|
+              next if elements.empty?
+
+              lines << "  + #{type.to_s.capitalize}: #{elements.size}"
+            end
+            lines << ""
+          end
+
+          # Property differences
+          if property_differences.any?
+            lines << "Property Differences:"
+            property_differences.first(10).each do |diff|
+              lines << "  #{diff[:type]}: #{diff[:name]}"
+              diff[:differences].each do |d|
+                lines << "    - #{d}"
+              end
+            end
+            if property_differences.size > 10
+              lines << "  ... and #{property_differences.size - 10} more"
+            end
+            lines << ""
+          end
+
+          # Result
+          lines << "Result: " \
+                   "#{equivalent? ? '✓ EQUIVALENT' : '✗ NOT EQUIVALENT'}"
+          lines << ""
+
+          lines << if equivalent?
+                     "QEA contains all XMI information (possibly more)."
+                   else
+                     "Information loss detected - " \
+                       "QEA missing critical elements."
+                   end
+
+          lines.join("\n")
+        end
+
+        # Generate detailed report
+        #
+        # @return [Hash] Detailed report data
+        def to_report
+          {
+            equivalent: equivalent?,
+            matches: matches,
+            xmi_only: xmi_only,
+            qea_only: qea_only,
+            property_differences: property_differences,
+            summary: summary,
+          }
+        end
+
+        # Generate statistics
+        #
+        # @return [Hash] Statistics about the comparison
+        def statistics
+          {
+            total_matches: matches.values.sum,
+            total_xmi_only: xmi_only.values.sum(&:size),
+            total_qea_only: qea_only.values.sum(&:size),
+            total_property_diffs: property_differences.size,
+            equivalent: equivalent?,
+          }
+        end
+
+        # Check if there are any issues
+        #
+        # @return [Boolean] True if there are issues
+        def has_issues?
+          !equivalent?
+        end
+
+        # Get critical issues (information loss)
+        #
+        # @return [Array<String>] List of critical issues
+        def critical_issues # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          issues = []
+
+          # Missing packages
+          if xmi_only[:packages].any?
+            issues << "Missing #{xmi_only[:packages].size} packages in QEA"
+          end
+
+          # Missing classes
+          if xmi_only[:classes].any?
+            issues << "Missing #{xmi_only[:classes].size} classes in QEA"
+          end
+
+          # Property differences with information loss
+          property_differences.each do |diff|
+            diff[:differences].each do |d|
+              next unless d.include?("QEA has fewer")
+
+              issues << "#{diff[:name]}: #{d}"
+            end
+          end
+
+          issues
+        end
+
+        # Get acceptable differences (QEA has more)
+        #
+        # @return [Array<String>] List of acceptable differences
+        def acceptable_differences # rubocop:disable Metrics/MethodLength
+          acceptable = []
+
+          # QEA-only elements
+          qea_only.each do |type, elements|
+            next if elements.empty?
+
+            acceptable << "QEA has #{elements.size} additional #{type}"
+          end
+
+          # Property differences where QEA has more
+          property_differences.each do |diff|
+            diff[:differences].each do |d|
+              next unless d.include?("QEA has more")
+
+              acceptable << "#{diff[:name]}: #{d}"
+            end
+          end
+
+          acceptable
+        end
+      end
+    end
+  end
+end