lutaml 0.9.43 → 0.10.0

data/lib/lutaml/qea/validation/database/referential_integrity_validator.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require_relative "../base_validator"
+
+module Lutaml
+  module Qea
+    module Validation
+      # Validates referential integrity across all entities
+      class ReferentialIntegrityValidator < BaseValidator
+        def validate
+          validate_all_package_references
+          validate_all_object_references
+          validate_all_connector_references
+        end
+
+        private
+
+        def validate_all_package_references # rubocop:disable Metrics/MethodLength
+          # Check all parent_id references in packages
+          packages.each do |pkg|
+            next if pkg.root?
+
+            unless package_exists?(pkg.parent_id)
+              result.add_error(
+                category: :referential_integrity,
+                entity_type: :package,
+                entity_id: pkg.package_id.to_s,
+                entity_name: pkg.name,
+                field: "parent_id",
+                reference: pkg.parent_id.to_s,
+                message: "Foreign key violation: parent_id #{pkg.parent_id} " \
+                         "not found in t_package",
+              )
+            end
+          end
+        end
+
+        def validate_all_object_references # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength
+          # Check all package_id references in objects
+          objects.each do |obj| # rubocop:disable Metrics/BlockLength
+            next unless obj.package_id
+
+            unless package_exists?(obj.package_id)
+              result.add_error(
+                category: :referential_integrity,
+                entity_type: :class,
+                entity_id: obj.ea_object_id.to_s,
+                entity_name: obj.name,
+                field: "package_id",
+                reference: obj.package_id.to_s,
+                message: "Foreign key violation: package_id " \
+                         "#{obj.package_id} not found in t_package",
+              )
+            end
+
+            # Check classifier references
+            next unless obj.classifier&.positive?
+
+            unless object_exists?(obj.classifier)
+              result.add_warning(
+                category: :referential_integrity,
+                entity_type: :class,
+                entity_id: obj.ea_object_id.to_s,
+                entity_name: obj.name,
+                field: "classifier",
+                reference: obj.classifier.to_s,
+                message: "Classifier object #{obj.classifier} not found",
+              )
+            end
+          end
+        end
+
+        def validate_all_connector_references # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          # Check all object references in connectors
+          connectors.each do |conn|
+            unless object_exists?(conn.start_object_id)
+              result.add_error(
+                category: :referential_integrity,
+                entity_type: :connector,
+                entity_id: conn.connector_id.to_s,
+                entity_name: conn.name || "Unnamed",
+                field: "start_object_id",
+                reference: conn.start_object_id.to_s,
+                message: "Foreign key violation: start_object_id " \
+                         "#{conn.start_object_id} not found in t_object",
+              )
+            end
+
+            unless object_exists?(conn.end_object_id)
+              result.add_error(
+                category: :referential_integrity,
+                entity_type: :connector,
+                entity_id: conn.connector_id.to_s,
+                entity_name: conn.name || "Unnamed",
+                field: "end_object_id",
+                reference: conn.end_object_id.to_s,
+                message: "Foreign key violation: end_object_id " \
+                         "#{conn.end_object_id} not found in t_object",
+              )
+            end
+          end
+        end
+
+        def packages
+          @packages ||= context[:db_packages] || []
+        end
+
+        def objects
+          @objects ||= context[:db_objects] || []
+        end
+
+        def connectors
+          @connectors ||= context[:connectors] || []
+        end
+
+        def package_exists?(package_id)
+          return false unless package_id
+
+          packages.any? { |p| p.package_id == package_id }
+        end
+
+        def object_exists?(object_id)
+          return false unless object_id
+
+          objects.any? { |o| o.ea_object_id == object_id }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative "base_validator"
+
+module Lutaml
+  module Qea
+    module Validation
+      # Validates diagram references and structure
+      class DiagramValidator < BaseValidator
+        def validate
+          validate_package_references
+          validate_diagram_objects
+          validate_diagram_links
+        end
+
+        private
+
+        def validate_package_references # rubocop:disable Metrics/MethodLength
+          diagrams.each do |diagram|
+            next unless diagram.package_id
+
+            unless package_exists?(diagram.package_id)
+              result.add_error(
+                category: :missing_reference,
+                entity_type: :diagram,
+                entity_id: diagram.diagram_id.to_s,
+                entity_name: diagram.name,
+                field: "package_id",
+                reference: diagram.package_id.to_s,
+                message: "Package #{diagram.package_id} does not exist",
+              )
+            end
+          end
+        end
+
+        def validate_diagram_objects # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          diagram_objects.each do |diag_obj|
+            unless object_exists?(diag_obj.ea_object_id)
+              diagram = diagrams.find do |d|
+                d.diagram_id == diag_obj.diagram_id
+              end
+              result.add_warning(
+                category: :missing_reference,
+                entity_type: :diagram_object,
+                entity_id: diag_obj.instance_id.to_s,
+                entity_name: diagram&.name || "Unknown diagram",
+                field: "object_id",
+                reference: diag_obj.ea_object_id.to_s,
+                message: "Diagram object references non-existent " \
+                         "object #{diag_obj.ea_object_id}",
+              )
+            end
+          end
+        end
+
+        def validate_diagram_links # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          diagram_links.each do |diag_link|
+            unless connector_exists?(diag_link.connectorid)
+              diagram = diagrams.find do |d|
+                d.diagram_id == diag_link.diagramid
+              end
+              result.add_warning(
+                category: :missing_reference,
+                entity_type: :diagram_link,
+                entity_id: diag_link.instance_id.to_s,
+                entity_name: diagram&.name || "Unknown diagram",
+                field: "connectorid",
+                reference: diag_link.connectorid.to_s,
+                message: "Diagram link references non-existent " \
+                         "connector #{diag_link.connectorid}",
+              )
+            end
+          end
+        end
+
+        def diagrams
+          @diagrams ||= context[:diagrams] || []
+        end
+
+        def diagram_objects
+          @diagram_objects ||= context[:diagram_objects] || []
+        end
+
+        def diagram_links
+          @diagram_links ||= context[:diagram_links] || []
+        end
+
+        def packages
+          @packages ||= context[:db_packages] || []
+        end
+
+        def objects
+          @objects ||= context[:db_objects] || []
+        end
+
+        def connectors
+          @connectors ||= context[:connectors] || []
+        end
+
+        def package_exists?(package_id)
+          packages.any? { |p| p.package_id == package_id }
+        end
+
+        def object_exists?(object_id)
+          objects.any? { |o| o.ea_object_id == object_id }
+        end
+
+        def connector_exists?(connector_id)
+          connectors.any? { |c| c.connector_id == connector_id }
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/qea/validation/formatters/json_formatter.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Lutaml
+  module Qea
+    module Validation
+      module Formatters
+        # Formats validation results as JSON for machine consumption
+        #
+        # @example Basic usage
+        #   formatter = JsonFormatter.new(result)
+        #   puts formatter.format
+        #
+        # @example Pretty printed
+        #   formatter = JsonFormatter.new(result, pretty: true)
+        #   puts formatter.format
+        class JsonFormatter
+          attr_reader :result, :options
+
+          # Creates a new JSON formatter
+          #
+          # @param result [ValidationResult] The validation result to format
+          # @param options [Hash] Formatting options
+          # @option options [Boolean] :pretty Pretty print JSON (default: false)
+          def initialize(result: nil, **options)
+            @result = result
+            @options = {
+              pretty: false,
+            }.merge(options)
+          end
+
+          # Formats the validation result as JSON
+          #
+          # @return [String] JSON output
+          def format
+            data = build_data
+
+            if options[:pretty]
+              JSON.pretty_generate(data)
+            else
+              JSON.generate(data)
+            end
+          end
+
+          private
+
+          # Builds the data structure for JSON output
+          #
+          # @return [Hash]
+          def build_data
+            {
+              summary: build_summary,
+              messages: build_messages,
+              by_category: build_by_category,
+              by_severity: build_by_severity,
+            }
+          end
+
+          # Builds the summary section
+          #
+          # @return [Hash]
+          def build_summary
+            {
+              valid: result.valid?,
+              total_messages: result.messages.size,
+              error_count: result.errors.size,
+              warning_count: result.warnings.size,
+              info_count: result.info.size,
+            }
+          end
+
+          # Builds the messages array
+          #
+          # @return [Array<Hash>]
+          def build_messages # rubocop:disable Metrics/MethodLength
+            result.messages.map do |message|
+              {
+                severity: message.severity,
+                category: message.category,
+                entity_type: message.entity_type,
+                entity_id: message.entity_id,
+                entity_name: message.entity_name,
+                message: message.message,
+                context: message.context,
+              }
+            end
+          end
+
+          # Builds messages grouped by category
+          #
+          # @return [Hash]
+          def build_by_category
+            result.messages.group_by(&:category).transform_values do |msgs|
+              {
+                count: msgs.size,
+                messages: msgs.map(&:message),
+              }
+            end
+          end
+
+          # Builds messages grouped by severity
+          #
+          # @return [Hash]
+          def build_by_severity
+            {
+              errors: format_severity_group(result.errors),
+              warnings: format_severity_group(result.warnings),
+              info: format_severity_group(result.info),
+            }
+          end
+
+          # Formats a group of messages by severity
+          #
+          # @param messages [Array<ValidationMessage>]
+          # @return [Hash]
+          def format_severity_group(messages) # rubocop:disable Metrics/MethodLength
+            {
+              count: messages.size,
+              by_category: messages
+                .group_by(&:category).transform_values do |msgs|
+                  msgs.map do |msg|
+                    {
+                      entity_type: msg.entity_type,
+                      entity_id: msg.entity_id,
+                      entity_name: msg.entity_name,
+                      message: msg.message,
+                    }
+                  end
+                end,
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/qea/validation/formatters/text_formatter.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Qea
+    module Validation
+      module Formatters
+        # Formats validation results as human-readable text with colors
+        #
+        # @example Basic usage
+        #   formatter = TextFormatter.new(result)
+        #   puts formatter.format
+        #
+        # @example Without color
+        #   formatter = TextFormatter.new(result, color: false)
+        #   puts formatter.format
+        class TextFormatter
+          attr_reader :result, :options
+
+          # Creates a new text formatter
+          #
+          # @param result [ValidationResult] The validation result to format
+          # @param options [Hash] Formatting options
+          # @option options [Boolean] :color Enable colored output
+          # (default: true)
+          # @option options [Boolean] :verbose Show all messages
+          # (default: false)
+          # @option options [Integer] :limit Maximum messages per category
+          def initialize(result: nil, **options)
+            @result = result
+            @options = {
+              color: true,
+              verbose: false,
+              limit: nil,
+            }.merge(options)
+          end
+
+          # Formats the validation result as text
+          #
+          # @return [String] Formatted text output
+          def format # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+            lines = []
+            lines << header
+            lines << ""
+            lines << summary
+            lines << ""
+
+            if result.has_errors?
+              lines << section_header("ERRORS", result.errors.size)
+              lines << format_messages(result.errors)
+              lines << ""
+            end
+
+            if result.has_warnings?
+              lines << section_header("WARNINGS", result.warnings.size)
+              lines << format_messages(result.warnings)
+              lines << ""
+            end
+
+            if result.has_info? && options[:verbose]
+              lines << section_header("INFO", result.info.size)
+              lines << format_messages(result.info)
+              lines << ""
+            end
+
+            lines << footer
+            lines.join("\n")
+          end
+
+          private
+
+          # Formats the header
+          #
+          # @return [String]
+          def header
+            line = "=" * 80
+            title = "QEA VALIDATION REPORT"
+            if options[:color]
+              "#{line}\n#{colorize(title, :cyan, bold: true)}\n#{line}"
+            else
+              "#{line}\n#{title}\n#{line}"
+            end
+          end
+
+          # Formats the summary
+          #
+          # @return [String]
+          def summary # rubocop:disable Metrics/AbcSize
+            status = if result.valid?
+                       colorize("✓ VALID", :green, bold: true)
+                     elsif result.has_errors?
+                       colorize("✗ INVALID", :red, bold: true)
+                     else
+                       colorize("⚠ WARNINGS", :yellow, bold: true)
+                     end
+
+            [
+              "Status: #{status}",
+              "",
+              "Messages:",
+              "  Errors:   #{colorize(result.errors.size.to_s, :red)}",
+              "  Warnings: #{colorize(result.warnings.size.to_s, :yellow)}",
+              "  Info:     #{result.info.size}",
+            ].join("\n")
+          end
+
+          # Formats a section header
+          #
+          # @param title [String] Section title
+          # @param count [Integer] Message count
+          # @return [String]
+          def section_header(title, count)
+            color = case title
+                    when "ERRORS" then :red
+                    when "WARNINGS" then :yellow
+                    else :cyan
+                    end
+
+            colorize("#{title} (#{count}):", color, bold: true)
+          end
+
+          # Formats messages grouped by category
+          #
+          # @param messages [Array<ValidationMessage>] Messages to format
+          # @return [String]
+          def format_messages(messages) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+            lines = []
+            messages_to_show = apply_limit(messages)
+
+            messages_to_show.group_by(&:category).each do |category, msgs|
+              category_name = format_category(category)
+              lines << colorize("  #{category_name} (#{msgs.size}):", :cyan)
+              lines << ""
+
+              msgs.each do |msg|
+                lines << format_message(msg)
+                lines << ""
+              end
+            end
+
+            if options[:limit] && messages.size > options[:limit]
+              remaining = messages.size - options[:limit]
+              lines << colorize(
+                "  ... and #{remaining} more (use --verbose to see all)",
+                :yellow,
+              )
+            end
+
+            lines.join("\n")
+          end
+
+          # Formats a single message
+          #
+          # @param message [ValidationMessage] Message to format
+          # @return [String]
+          def format_message(message)
+            icon = severity_icon(message.severity)
+            entity_info = if message.entity_name
+                            "#{message.entity_type}:#{message.entity_name}"
+                          else
+                            message.entity_type.to_s
+                          end
+
+            [
+              "    #{icon} #{colorize(entity_info, :blue)}",
+              "      #{message.message}",
+              "      ID: #{message.entity_id}",
+            ].join("\n")
+          end
+
+          # Formats the footer
+          #
+          # @return [String]
+          def footer
+            "=" * 80
+          end
+
+          # Applies message limit
+          #
+          # @param messages [Array<ValidationMessage>]
+          # @return [Array<ValidationMessage>]
+          def apply_limit(messages)
+            return messages unless options[:limit]
+
+            messages.first(options[:limit])
+          end
+
+          # Formats a category name
+          #
+          # @param category [Symbol] Category symbol
+          # @return [String]
+          def format_category(category)
+            category.to_s.split("_").map(&:capitalize).join(" ")
+          end
+
+          # Returns an icon for the severity level
+          #
+          # @param severity [Symbol] Severity level
+          # @return [String]
+          def severity_icon(severity)
+            case severity
+            when :error then colorize("✗", :red)
+            when :warning then colorize("⚠", :yellow)
+            when :info then colorize("ℹ", :blue)
+            else "•"
+            end
+          end
+
+          # Colorizes text if color is enabled
+          #
+          # @param text [String] Text to colorize
+          # @param color [Symbol] Color name
+          # @param bold [Boolean] Make text bold
+          # @return [String]
+          def colorize(text, color = nil, bold: false) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
+            return text unless options[:color]
+
+            codes = []
+            codes << 1 if bold
+
+            codes << case color
+                     when :red then 31
+                     when :green then 32
+                     when :yellow then 33
+                     when :blue then 34
+                     when :cyan then 36
+                     else 0
+                     end
+
+            "\e[#{codes.join(';')}m#{text}\e[0m"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative "base_validator"
+
+module Lutaml
+  module Qea
+    module Validation
+      # Validates operation references and structure
+      class OperationValidator < BaseValidator
+        def validate
+          validate_parent_object_references
+          validate_return_types
+        end
+
+        private
+
+        def validate_parent_object_references # rubocop:disable Metrics/MethodLength
+          operations.each do |op|
+            unless reference_exists?("t_object", "ea_object_id",
+                                     op.ea_object_id)
+              result.add_error(
+                category: :missing_reference,
+                entity_type: :operation,
+                entity_id: op.operationid.to_s,
+                entity_name: op.name,
+                field: "ea_object_id",
+                reference: op.ea_object_id.to_s,
+                message: "Parent object #{op.ea_object_id} does not exist",
+              )
+            end
+          end
+        end
+
+        def validate_return_types # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          operations.each do |op|
+            next unless op.classifier && !op.classifier.empty?
+
+            # Classifier can be either an object name or a primitive type
+            next if primitive_type?(op.classifier)
+            next if classifier_exists?(op.classifier)
+
+            parent = database&.objects&.all&.find do |o|
+              o.ea_object_id == op.ea_object_id
+            end
+            result.add_warning(
+              category: :missing_reference,
+              entity_type: :operation,
+              entity_id: op.operationid.to_s,
+              entity_name: "#{parent&.name}.#{op.name}()",
+              field: "classifier",
+              reference: op.classifier,
+              message: "Return type '#{op.classifier}' not found",
+            )
+          end
+        end
+
+        def operations
+          @operations ||= context[:operations] || []
+        end
+
+        def classifier_exists?(classifier_id)
+          return false unless database
+
+          # Classifier field contains object_id, not name
+          database.objects.all.any? do |o|
+            o.ea_object_id.to_s == classifier_id.to_s
+          end
+        end
+
+        def primitive_type?(type_name)
+          primitives = %w[
+            Integer String Boolean Float Double Long Short Byte Char
+            Date Time DateTime Decimal void Object Any
+            int string bool float double long short byte char
+          ]
+          primitives.include?(type_name)
+        end
+      end
+    end
+  end
+end