svg_conform 0.1.7 → 0.1.8

data/lib/svg_conform/requirements/font_family_requirement.rb

@@ -27,49 +27,39 @@ module SvgConform
       def check(node, context)
         return unless element?(node)
 
-        # Check font-family attribute only (not style properties)
-        # Style properties are handled by StylePromotionRequirement to avoid duplication
-        font_family = get_attribute(node, "font-family")
-        return unless font_family
-
-        if svgcheck_compatibility
-          check_font_family_svgcheck_mode(node, context, font_family,
-                                          "font-family")
-        elsif !valid_font_family?(font_family)
-          context.add_error(
-            requirement_id: id,
-            message: "Font family '#{font_family}' is not allowed in this profile",
-            node: node,
-            severity: :error,
-            data: { attribute: "font-family", value: font_family },
-          )
-        end
+        validate_font_family(node, context)
       end
 
       def validate_sax_element(element, context)
-        # Skip if parent is structurally invalid
+        # Skip if parent is structurally invalid (SAX-specific: DOM handles this via should_check_node?)
         return if element.parent && context.node_structurally_invalid?(element.parent)
 
-        # Check font-family attribute only
-        font_family = element.raw_attributes["font-family"]
+        validate_font_family(element, context)
+      end
+
+      private
+
+      # Shared validation logic for both DOM and SAX modes
+      def validate_font_family(node_or_element, context)
+        # Check font-family attribute only (not style properties)
+        # Style properties are handled by StylePromotionRequirement to avoid duplication
+        font_family = get_attribute(node_or_element, "font-family")
         return unless font_family
 
         if svgcheck_compatibility
-          check_font_family_svgcheck_mode(element, context, font_family,
+          check_font_family_svgcheck_mode(node_or_element, context, font_family,
                                           "font-family")
         elsif !valid_font_family?(font_family)
           context.add_error(
             requirement_id: id,
             message: "Font family '#{font_family}' is not allowed in this profile",
-            node: element,
+            node: node_or_element,
             severity: :error,
             data: { attribute: "font-family", value: font_family },
           )
         end
       end
 
-      private
-
       def check_font_family_svgcheck_mode(node, context, font_family_value,
 attribute_name)
         # Check if the font family value is valid according to svgcheck

data/lib/svg_conform/requirements/no_external_css_requirement.rb

@@ -57,7 +57,7 @@ module SvgConform
 
         # Validate collected style elements
         @collected_style_elements.each do |element|
-          check_style_element_sax(element, context)
+          check_style_element(element, context)
         end
 
         # Reset for next validation
@@ -79,17 +79,22 @@ module SvgConform
           # Style elements handled in deferred validation (need text content)
           # Already collected in collect_sax_data
         when "link"
-          check_link_element_sax(element, context) if check_link_elements
+          check_link_element(element, context) if check_link_elements
         else
-          check_style_attribute_sax(element, context) if check_style_attributes
+          check_style_attribute(element, context) if check_style_attributes
         end
       end
 
       private
 
-      def check_style_element(node, context)
+      def check_style_element(node_or_element, context)
         # Check for @import rules in style elements
-        content = node.text || ""
+        # Handle both DOM nodes (node.text) and SAX elements (element.text_content)
+        content = if node_or_element.respond_to?(:text_content)
+                    node_or_element.text_content
+                  else
+                    node_or_element.text || ""
+                  end
 
         if content =~ /@import\s+url\s*\(\s*['"]?([^'")\s]+)['"]?\s*\)/i
           url = ::Regexp.last_match(1)
@@ -97,7 +102,7 @@ module SvgConform
             context.add_error(
               requirement_id: id,
               message: "External CSS import not allowed: #{url}",
-              node: node,
+              node: node_or_element,
               severity: :error,
             )
           end
@@ -111,14 +116,14 @@ module SvgConform
         context.add_error(
           requirement_id: id,
           message: "External CSS import not allowed: #{url}",
-          node: node,
+          node: node_or_element,
           severity: :error,
         )
       end
 
-      def check_link_element(node, context)
-        rel = get_attribute(node, "rel")
-        href = get_attribute(node, "href")
+      def check_link_element(node_or_element, context)
+        rel = get_attribute(node_or_element, "rel")
+        href = get_attribute(node_or_element, "href")
 
         return unless rel&.downcase == "stylesheet" && href
 
@@ -127,13 +132,13 @@ module SvgConform
         context.add_error(
           requirement_id: id,
           message: "External CSS link not allowed: #{href}",
-          node: node,
+          node: node_or_element,
           severity: :error,
         )
       end
 
-      def check_style_attribute(node, context)
-        style_value = get_attribute(node, "style")
+      def check_style_attribute(node_or_element, context)
+        style_value = get_attribute(node_or_element, "style")
         return unless style_value
 
         # Check for url() references in style attributes
@@ -145,70 +150,7 @@ module SvgConform
         context.add_error(
           requirement_id: id,
           message: "External URL reference in style attribute not allowed: #{url}",
-          node: node,
-          severity: :error,
-        )
-      end
-
-      def check_style_element_sax(element, context)
-        # Check for @import rules in style elements
-        content = element.text_content
-
-        if content =~ /@import\s+url\s*\(\s*['"]?([^'")\s]+)['"]?\s*\)/i
-          url = ::Regexp.last_match(1)
-          unless allowed_url?(url)
-            context.add_error(
-              requirement_id: id,
-              message: "External CSS import not allowed: #{url}",
-              node: element,
-              severity: :error,
-            )
-          end
-        end
-
-        return unless content =~ /@import\s+['"]([^'"]+)['"]/i
-
-        url = ::Regexp.last_match(1)
-        return if allowed_url?(url)
-
-        context.add_error(
-          requirement_id: id,
-          message: "External CSS import not allowed: #{url}",
-          node: element,
-          severity: :error,
-        )
-      end
-
-      def check_link_element_sax(element, context)
-        rel = element.raw_attributes["rel"]
-        href = element.raw_attributes["href"]
-
-        return unless rel&.downcase == "stylesheet" && href
-
-        return if allowed_url?(href)
-
-        context.add_error(
-          requirement_id: id,
-          message: "External CSS link not allowed: #{href}",
-          node: element,
-          severity: :error,
-        )
-      end
-
-      def check_style_attribute_sax(element, context)
-        style_value = element.raw_attributes["style"]
-        return unless style_value
-
-        # Check for url() references in style attributes
-        return unless style_value =~ /url\s*\(\s*['"]?([^'")\s]+)['"]?\s*\)/i
-
-        url = ::Regexp.last_match(1)
-        return if allowed_url?(url)
-
-        context.add_error(
-          requirement_id: id,
-          message: "External URL reference in style attribute not allowed: #{url}",
-          node: element,
+          node: node_or_element,
           severity: :error,
         )
       end

data/lib/svg_conform/requirements/viewbox_required_requirement.rb

@@ -18,96 +18,41 @@ module SvgConform
         root = document.root
         return unless root&.name == "svg"
 
-        viewbox = get_attribute(root, "viewBox")
-
-        if viewbox.nil? || viewbox.empty?
-          context.add_error(
-            requirement: self,
-            node: root,
-            message: "SVG root element must have a viewBox attribute",
-            data: { missing_attribute: "viewBox" },
-          )
-
-          # Add informational message about calculated viewBox if width/height are present
-          width = get_attribute(root, "width")
-          height = get_attribute(root, "height")
-
-          if width && height && valid_number?(width) && valid_number?(height)
-            calculated_viewbox = "0 0 #{width.to_f} #{height.to_f}"
-            context.add_error(
-              requirement: self,
-              node: root,
-              message: "Trying to put in the attribute with value '#{calculated_viewbox}'",
-              data: {
-                calculated_viewbox: calculated_viewbox,
-                source_width: width,
-                source_height: height,
-              },
-            )
-          end
-          return
-        end
-
-        # Validate viewBox format (should be "min-x min-y width height")
-        # Also accept comma-separated with parentheses like "(0, 0, 100, 100)" (svgcheck is lenient)
-        normalized_viewbox = viewbox.strip.gsub(/[(),]/, " ").squeeze(" ")
-        parts = normalized_viewbox.strip.split(/\s+/)
-        unless parts.length == 4 && parts.all? { |part| valid_number?(part) }
-          context.add_error(
-            requirement: self,
-            node: root,
-            message: "viewBox attribute must contain four numeric values (min-x min-y width height)",
-            data: {
-              viewbox_value: viewbox,
-              parsed_parts: parts,
-            },
-          )
-          return
-        end
-
-        # Check that width and height are positive
-        width = parts[2].to_f
-        height = parts[3].to_f
-
-        return unless width <= 0 || height <= 0
-
-        context.add_error(
-          requirement: self,
-          node: root,
-          message: "viewBox width and height must be positive values",
-          data: {
-            viewbox_value: viewbox,
-            width: width,
-            height: height,
-          },
-        )
+        validate_viewbox(root, context)
       end
 
       def validate_sax_element(element, context)
         # Only check the root SVG element
         return unless element.name == "svg" && element.parent.nil?
 
-        viewbox = element.raw_attributes["viewBox"]
+        validate_viewbox(element, context)
+      end
+
+      private
+
+      # Shared validation logic for both DOM and SAX modes
+      def validate_viewbox(svg_root, context)
+        viewbox = get_attribute(svg_root, "viewBox")
 
         if viewbox.nil? || viewbox.empty?
           context.add_error(
             requirement_id: id,
             message: "SVG root element must have a viewBox attribute",
-            node: element,
+            node: svg_root,
             severity: :error,
             data: { missing_attribute: "viewBox" },
           )
 
           # Add informational message about calculated viewBox if width/height are present
-          width = element.raw_attributes["width"]
-          height = element.raw_attributes["height"]
+          width = get_attribute(svg_root, "width")
+          height = get_attribute(svg_root, "height")
 
           if width && height && valid_number?(width) && valid_number?(height)
             calculated_viewbox = "0 0 #{width.to_f} #{height.to_f}"
             context.add_error(
               requirement_id: id,
               message: "Trying to put in the attribute with value '#{calculated_viewbox}'",
-              node: element,
+              node: svg_root,
               severity: :error,
               data: {
                 calculated_viewbox: calculated_viewbox,
@@ -120,13 +65,14 @@ module SvgConform
         end
 
         # Validate viewBox format (should be "min-x min-y width height")
+        # Also accept comma-separated with parentheses like "(0, 0, 100, 100)" (svgcheck is lenient)
         normalized_viewbox = viewbox.strip.gsub(/[(),]/, " ").squeeze(" ")
         parts = normalized_viewbox.strip.split(/\s+/)
         unless parts.length == 4 && parts.all? { |part| valid_number?(part) }
           context.add_error(
             requirement_id: id,
             message: "viewBox attribute must contain four numeric values (min-x min-y width height)",
-            node: element,
+            node: svg_root,
             severity: :error,
             data: {
               viewbox_value: viewbox,
@@ -145,7 +91,7 @@ module SvgConform
         context.add_error(
           requirement_id: id,
           message: "viewBox width and height must be positive values",
-          node: element,
+          node: svg_root,
           severity: :error,
           data: {
             viewbox_value: viewbox,
@@ -155,8 +101,6 @@ module SvgConform
         )
       end
 
-      private
-
       def valid_number?(str)
         Float(str)
         true

data/lib/svg_conform/sax_validation_handler.rb

@@ -3,6 +3,9 @@
 require "nokogiri"
 require_relative "element_proxy"
 require_relative "validation_context"
+require_relative "validation/error_tracker"
+require_relative "validation/structural_invalidity_tracker"
+require_relative "validation/node_id_manager"
 require_relative "validation_result"
 require_relative "references"
 
@@ -139,14 +142,19 @@ module SvgConform
       context = ValidationContext.allocate
       context.instance_variable_set(:@document, nil)
       context.instance_variable_set(:@profile, @profile)
-      context.instance_variable_set(:@errors, [])
-      context.instance_variable_set(:@warnings, [])
-      context.instance_variable_set(:@validity_errors, [])
-      context.instance_variable_set(:@infos, [])
+      context.instance_variable_set(:@error_tracker, Validation::ErrorTracker.new)
+      context.instance_variable_set(:@fixes, [])
       context.instance_variable_set(:@data, {})
-      context.instance_variable_set(:@structurally_invalid_node_ids, Set.new)
-      context.instance_variable_set(:@node_id_cache, {})
-      context.instance_variable_set(:@cache_populated, true) # Skip population for SAX
+      # Create NodeIdManager without a document (SAX mode)
+      node_id_manager = Validation::NodeIdManager.new(nil)
+      context.instance_variable_set(:@node_id_manager, node_id_manager)
+      # Create StructuralInvalidityTracker with a node ID generator
+      context.instance_variable_set(:@structural_invalidity_tracker,
+                                    Validation::StructuralInvalidityTracker.new(
+                                      node_id_generator: ->(node) {
+                                        node_id_manager.generate_node_id(node)
+                                      },
+                                    ))
       context.instance_variable_set(:@reference_manifest,
                                     References::ReferenceManifest.new(source_document: nil))
       context

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