ea 0.1.0 → 0.1.4

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

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+module Ea
+  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/ea/qea/validation/formatters.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Validation
+      module Formatters
+        autoload :TextFormatter, "ea/qea/validation/formatters/text_formatter"
+        autoload :JsonFormatter, "ea/qea/validation/formatters/json_formatter"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Ea
+  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
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Validation
+      # Validates package structure and hierarchy
+      class PackageValidator < BaseValidator
+        def validate
+          validate_parent_references
+          validate_duplicate_names
+          validate_circular_hierarchy
+        end
+
+        private
+
+        def validate_parent_references # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          packages.each do |package|
+            next if package.root?
+
+            unless parent_exists?(package.parent_id)
+              package_path = resolve_package_path(package.package_id)
+              result.add_error(
+                category: :missing_reference,
+                entity_type: :package,
+                entity_id: package.package_id.to_s,
+                entity_name: package.name,
+                field: "parent_id",
+                reference: package.parent_id.to_s,
+                message: "Parent package #{package.parent_id} does not exist",
+                location: package_path,
+              )
+            end
+          end
+        end
+
+        def validate_duplicate_names # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          packages_by_parent = packages.group_by(&:parent_id)
+
+          packages_by_parent.each do |parent_id, sibling_packages|
+            names = sibling_packages.map(&:name)
+            duplicates = names.select { |name| names.count(name) > 1 }.uniq
+
+            duplicates.each do |dup_name|
+              dup_packages = sibling_packages.select { |p| p.name == dup_name }
+              dup_packages.each do |package|
+                package_path = resolve_package_path(package.package_id)
+                parent_path = if parent_id
+                                resolve_package_path(parent_id)
+                              else
+                                "Root"
+                              end
+                result.add_warning(
+                  category: :duplicate,
+                  entity_type: :package,
+                  entity_id: package.package_id.to_s,
+                  entity_name: package.name,
+                  field: "name",
+                  message: "Duplicate package name '#{dup_name}' " \
+                           "in parent #{parent_path}",
+                  location: package_path,
+                )
+              end
+            end
+          end
+        end
+
+        def validate_circular_hierarchy # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          packages.each do |package|
+            next if package.root?
+
+            path = [package.package_id]
+            current_id = package.parent_id
+
+            while current_id && !current_id.zero?
+              if path.include?(current_id)
+                package_path = resolve_package_path(package.package_id)
+                result.add_error(
+                  category: :circular_reference,
+                  entity_type: :package,
+                  entity_id: package.package_id.to_s,
+                  entity_name: package.name,
+                  field: "parent_id",
+                  message: "Circular package hierarchy detected: " \
+                           "#{path.join(' -> ')} -> #{current_id}",
+                  location: package_path,
+                )
+                break
+              end
+
+              path << current_id
+              parent = packages.find { |p| p.package_id == current_id }
+              break unless parent
+
+              current_id = parent.parent_id
+            end
+          end
+        end
+
+        def packages
+          @packages ||= context[:db_packages] || []
+        end
+
+        def parent_exists?(parent_id)
+          return true if parent_id.nil? || parent_id.zero?
+
+          packages.any? { |p| p.package_id == parent_id }
+        end
+      end
+    end
+  end
+end