lutaml 0.9.43 → 0.10.0

data/lib/lutaml/qea/validation/validation_message.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Qea
+    module Validation
+      # Represents a single validation message with severity, category, and
+      # context information
+      #
+      # @example Creating an error message
+      #   message = ValidationMessage.new(
+      #     severity: :error,
+      #     category: :missing_reference,
+      #     entity_type: :association,
+      #     entity_id: "FA86EB3B-198A-4141-83F6-DE9FACC76425",
+      #     entity_name: "Association_1",
+      #     field: "member_end",
+      #     reference: "GPLR_Compression",
+      #     message: "member_end references non-existent class",
+      #     location: "Package::SubPackage"
+      #   )
+      class ValidationMessage
+        # Severity levels for validation messages
+        module Severity
+          ERROR = :error     # Breaks integrity, must fix
+          WARNING = :warning # May cause issues, should review
+          INFO = :info       # Informational, may be intentional
+        end
+
+        # Categories of validation issues
+        module Category
+          MISSING_REFERENCE = :missing_reference
+          ORPHANED = :orphaned
+          DUPLICATE = :duplicate
+          INVALID_TYPE = :invalid_type
+          CIRCULAR_REFERENCE = :circular_reference
+          MISSING_REQUIRED = :missing_required
+          CONSTRAINT_VIOLATION = :constraint_violation
+        end
+
+        attr_reader :severity, :category, :entity_type, :entity_id,
+                    :entity_name, :field, :reference, :message, :location,
+                    :context
+
+        # Creates a new validation message
+        #
+        # @param severity [Symbol] Message severity (:error, :warning, :info)
+        # @param category [Symbol] Category of the issue
+        # @param entity_type [Symbol] Type of entity (e.g., :class,
+        #   :association)
+        # @param entity_id [String] XMI ID or database ID of the entity
+        # @param entity_name [String] Human-readable name of the entity
+        # @param field [String, nil] Field with the issue
+        # @param reference [String, nil] What it's trying to reference
+        # @param message [String] Human-readable description
+        # @param location [String, nil] Package path or context
+        # @param context [Hash] Additional context information
+        def initialize( # rubocop:disable Metrics/ParameterLists
+          severity:,
+          category:,
+          entity_type:,
+          entity_id:,
+          entity_name:,
+          message:,
+          field: nil,
+          reference: nil,
+          location: nil,
+          context: {}
+        )
+          @severity = severity
+          @category = category
+          @entity_type = entity_type
+          @entity_id = entity_id
+          @entity_name = entity_name
+          @field = field
+          @reference = reference
+          @message = message
+          @location = location
+          @context = context
+        end
+
+        # Checks if this is an error message
+        #
+        # @return [Boolean]
+        def error?
+          severity == Severity::ERROR
+        end
+
+        # Checks if this is a warning message
+        #
+        # @return [Boolean]
+        def warning?
+          severity == Severity::WARNING
+        end
+
+        # Checks if this is an info message
+        #
+        # @return [Boolean]
+        def info?
+          severity == Severity::INFO
+        end
+
+        # Returns a formatted string representation of the message
+        #
+        # @return [String]
+        def to_s # rubocop:disable Metrics/AbcSize
+          parts = []
+          parts << "#{entity_type.to_s.capitalize} '#{entity_name}'"
+          parts << "{#{entity_id}}"
+          parts << "└─ #{message}"
+          parts << "└─ Field: #{field}" if field
+          parts << "└─ Reference: #{reference}" if reference
+          parts << "└─ Location: #{location}" if location
+          parts.join("\n")
+        end
+
+        # Returns a hash representation of the message
+        #
+        # @return [Hash]
+        def to_h # rubocop:disable Metrics/MethodLength
+          {
+            severity: severity,
+            category: category,
+            entity_type: entity_type,
+            entity_id: entity_id,
+            entity_name: entity_name,
+            field: field,
+            reference: reference,
+            message: message,
+            location: location,
+            context: context,
+          }.compact
+        end
+
+        # Returns a JSON representation of the message
+        #
+        # @return [String]
+        def to_json(*args)
+          require "json"
+          to_h.to_json(*args)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require_relative "validation_message"
+
+module Lutaml
+  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(*args)
+          require "json"
+          to_h.to_json(*args)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Lutaml
+  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