lutaml 0.10.18 → 0.11.2

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

@@ -1,128 +0,0 @@
-# frozen_string_literal: true
-
-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/database.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Qea
-    module Validation
-      module Database
-      end
-    end
-  end
-end

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

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

@@ -1,137 +0,0 @@
-# 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

@@ -1,235 +0,0 @@
-# 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

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