svg_conform 0.1.6 → 0.1.8

data/lib/svg_conform/validation/error_tracker.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module SvgConform
+  module Validation
+    # Tracks validation errors, warnings, and informational messages
+    # Separated from ValidationContext for better separation of concerns
+    #
+    # Note: This class references ValidationContext::ValidationIssue which is
+    # defined in ValidationContext. ValidationContext must be loaded first.
+    class ErrorTracker
+      attr_reader :errors, :warnings, :validity_errors, :infos
+
+      def initialize
+        @errors = []
+        @warnings = []
+        @validity_errors = []
+        @infos = []
+      end
+
+      # Add an error to the context
+      def add_error(node:, message:, rule: nil, requirement: nil,
+                     requirement_id: nil, severity: nil, fix: nil, data: {})
+        # Support both old rule system and new requirements system
+        rule_or_requirement = requirement || rule
+
+        error = ::SvgConform::Errors::ValidationIssue.new(
+          type: :error,
+          rule: rule_or_requirement,
+          node: node,
+          message: message,
+          fix: fix,
+          data: data,
+          requirement_id: requirement_id,
+          severity: severity,
+        )
+
+        # Handle special severity types
+        if severity == :validity_error
+          @validity_errors << error
+        else
+          @errors << error
+        end
+
+        error
+      end
+
+      # Add a warning to the context
+      def add_warning(rule:, node:, message:, fix: nil)
+        warning = ::SvgConform::Errors::ValidationIssue.new(
+          type: :warning,
+          rule: rule,
+          node: node,
+          message: message,
+          fix: fix,
+        )
+        @warnings << warning
+        warning
+      end
+
+      # Add an informational notice to the context
+      def add_notice(rule:, node:, message:, fix: nil, data: {}, type: :info)
+        notice = ::SvgConform::Errors::ValidationIssue.new(
+          type: type,
+          rule: rule,
+          node: node,
+          message: message,
+          fix: fix,
+          data: data,
+        )
+        @infos << notice
+        notice
+      end
+
+      # Check if there are any errors
+      def has_errors?
+        @errors.any?
+      end
+
+      # Check if there are any warnings
+      def has_warnings?
+        @warnings.any?
+      end
+
+      # Check if there are any validity errors
+      def has_validity_errors?
+        @validity_errors.any?
+      end
+
+      # Get total error count (including validity errors)
+      def total_error_count
+        @errors.length + @validity_errors.length
+      end
+
+      # Clear all tracked issues
+      def clear
+        @errors.clear
+        @warnings.clear
+        @validity_errors.clear
+        @infos.clear
+      end
+    end
+  end
+end

data/lib/svg_conform/validation/node_id_manager.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "../document_analyzer"
+
+module SvgConform
+  module Validation
+    # Manages node ID generation for validation contexts
+    # Wraps DocumentAnalyzer for DOM mode and handles ElementProxy for SAX mode
+    class NodeIdManager
+      def initialize(document = nil)
+        @document = document
+        @analyzer = nil # Lazy-loaded, only needed for DOM/remediation mode
+      end
+
+      # Generate a unique identifier for a node based on its path
+      # Uses DocumentAnalyzer for efficient forward-counting algorithm (DOM mode)
+      # For SAX mode, uses the pre-computed path from ElementProxy
+      def generate_node_id(node)
+        # In SAX mode, node may be an ElementProxy with pre-computed path
+        return node.path_id if node.respond_to?(:path_id)
+
+        # Lazy-load the analyzer only when needed (DOM/remediation mode)
+        @analyzer ||= DocumentAnalyzer.new(@document) if @document
+        return nil unless @analyzer
+
+        @analyzer.get_node_id(node)
+      end
+
+      # Check if the manager has a document for DOM-based ID generation
+      def dom_mode?
+        !@document.nil?
+      end
+    end
+  end
+end

data/lib/svg_conform/validation/structural_invalidity_tracker.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "set"
+
+module SvgConform
+  module Validation
+    # Tracks structurally invalid nodes during validation
+    # Separated from ValidationContext for better separation of concerns
+    class StructuralInvalidityTracker
+      def initialize(node_id_generator:)
+        @structurally_invalid_node_ids = Set.new
+        @node_id_generator = node_id_generator
+      end
+
+      # Mark a node as structurally invalid (e.g., invalid parent-child relationship)
+      # Other requirements should skip attribute validation on these nodes
+      # Also marks all descendants as invalid since they'll be removed with the parent
+      def mark_node_structurally_invalid(node)
+        node_id = @node_id_generator.call(node)
+        return if node_id.nil? # Safety check
+
+        @structurally_invalid_node_ids.add(node_id)
+
+        # Mark all descendants as invalid too
+        mark_descendants_invalid(node)
+      end
+
+      # Mark all descendants of a node as structurally invalid
+      def mark_descendants_invalid(node)
+        # In SAX mode, ElementProxy doesn't have children yet
+        # Children will be validated individually and will check parent validity
+        return unless node.respond_to?(:children) && node.children
+
+        node.children.each do |child|
+          child_id = @node_id_generator.call(child)
+          next if child_id.nil? # Skip if can't generate ID
+
+          @structurally_invalid_node_ids.add(child_id)
+          # Recursively mark descendants
+          mark_descendants_invalid(child)
+        end
+      end
+
+      # Check if a node is structurally invalid
+      def node_structurally_invalid?(node)
+        node_id = @node_id_generator.call(node)
+        return false if node_id.nil? # Safety check
+
+        @structurally_invalid_node_ids.include?(node_id)
+      end
+
+      # Clear all tracked invalid nodes
+      def clear
+        @structurally_invalid_node_ids.clear
+      end
+
+      # Get the count of structurally invalid nodes
+      def count
+        @structurally_invalid_node_ids.size
+      end
+    end
+  end
+end