svg_conform 0.1.6 → 0.1.8

data/lib/svg_conform/remediations/namespace_remediation.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "base_remediation"
+require "set"
 
 module SvgConform
   module Remediations
@@ -105,6 +106,11 @@ module SvgConform
           remove_node(node)
         end
 
+        # Clean up unused namespace declarations
+        # Note: Moxml/Nokogiri don't support removing namespace declarations directly,
+        # so we mark the document for post-processing during serialization
+        cleanup_unused_namespace_declarations(document)
+
         changes
       end
 
@@ -146,6 +152,61 @@ module SvgConform
         # Same logic as find_namespace_uri_for_prefix
         find_namespace_uri_for_prefix(node, prefix)
       end
+
+      def cleanup_unused_namespace_declarations(document)
+        # Find which namespace prefixes are still in use
+        used_prefixes = find_used_namespace_prefixes(document)
+
+        # Get the root element
+        root = document.respond_to?(:root) ? document.root : document
+        return unless root.respond_to?(:namespace_definitions)
+
+        # Get disallowed namespace prefixes
+        disallowed_prefixes = root.namespace_definitions.filter_map do |ns|
+          prefix = ns.respond_to?(:prefix) ? ns.prefix : nil
+          # Extract namespace URI from Moxml::Namespace object
+          uri = ns.respond_to?(:uri) ? ns.uri : nil
+          next if prefix.nil? || prefix.empty? # Skip default namespace
+          next if allowed_namespaces.include?(uri) # Keep allowed namespaces
+
+          next if used_prefixes.include?(prefix) # Keep prefixes still in use
+
+          prefix
+        end
+
+        # Store the prefixes to remove on the document for later serialization
+        # Try to store on Document wrapper first, fallback to moxml_document
+        target = document.respond_to?(:instance_variable_set) ? document : root.document
+        target&.instance_variable_set(:@unused_namespace_prefixes,
+                                      disallowed_prefixes)
+      end
+
+      def find_used_namespace_prefixes(document)
+        used_prefixes = Set.new(["xml"]) # xml prefix is always reserved
+
+        document.traverse do |node|
+          next unless node.respond_to?(:name)
+
+          # Check element name for namespace prefix
+          if node.name.include?(":")
+            prefix = node.name.split(":").first
+            used_prefixes << prefix
+          end
+
+          # Check attributes for namespace prefixes
+          if node.respond_to?(:attributes)
+            node.attributes.each do |attr|
+              attr_name = attr.respond_to?(:name) ? attr.name : attr.to_s
+              if attr_name.include?(":")
+                prefix = attr_name.split(":").first
+                used_prefixes << prefix
+              end
+            end
+          end
+        end
+
+        used_prefixes
+      end
     end
   end
 end

data/lib/svg_conform/requirements/base_requirement.rb

@@ -1,9 +1,15 @@
 # frozen_string_literal: true
 
+require_relative "../node_helpers"
+require_relative "../interfaces/requirement_interface"
+
 module SvgConform
   module Requirements
     # Base class for all validation requirements
     class BaseRequirement < Lutaml::Model::Serializable
+      include SvgConform::NodeHelpers
+      include SvgConform::Interfaces::RequirementInterface
+
       attribute :id, :string
       attribute :description, :string
       attribute :type, :string, polymorphic_class: true, default: -> {
@@ -65,48 +71,8 @@ module SvgConform
         true
       end
 
-      # Helper method to check if a node is an element
-      def element?(node)
-        node.respond_to?(:name) && !node.name.nil?
-      end
-
-      # Helper method to check if a node is text
-      def text?(node)
-        node.respond_to?(:text?) && node.text?
-      end
-
-      # Helper method to get attribute value
-      def get_attribute(node, name)
-        return nil unless node.respond_to?(:attribute)
-
-        attr = node.attribute(name)
-        attr&.value
-      end
-
-      # Helper method to set attribute value
-      def set_attribute(node, name, value)
-        return false unless node.respond_to?(:set_attribute)
-
-        node.set_attribute(name, value)
-        true
-      end
-
-      # Helper method to remove attribute
-      def remove_attribute(node, name)
-        return false unless node.respond_to?(:remove_attribute)
-
-        node.remove_attribute(name)
-        true
-      end
-
-      # Helper method to check if attribute exists
-      def has_attribute?(node, name)
-        return false unless node.respond_to?(:attribute)
-
-        !node.attribute(name).nil?
-      end
-
       # Helper method to get all attributes
+      # Note: Other attribute helpers are included via NodeHelpers module
       def get_attributes(node)
         return {} unless node.respond_to?(:attributes)
 
@@ -117,6 +83,20 @@ module SvgConform
         end
       end
 
+      # Shared helper for skipping attribute validation on structurally invalid nodes
+      # Used by both DOM and SAX validation
+      def skip_attribute_validation?(node_or_element, context)
+        # For DOM mode, also check if it's an element
+        return true if element?(node_or_element) && context.node_structurally_invalid?(node_or_element)
+
+        # For SAX mode (ElementProxy always has this method)
+        if node_or_element.respond_to?(:path_id)
+          return context.node_structurally_invalid?(node_or_element)
+        end
+
+        false
+      end
+
       def to_s
         "#{@id}: #{@description}"
       end

data/lib/svg_conform/requirements/color_restrictions_requirement.rb

@@ -26,70 +26,30 @@ module SvgConform
       def check(node, context)
         return unless element?(node)
 
-        # Skip attribute validation for structurally invalid nodes (e.g., wrong parent-child)
-        return if context.node_structurally_invalid?(node)
-
-        # Check color-related attributes
-        color_attributes = %w[fill stroke color stop-color flood-color
-                              lighting-color]
-
-        color_attributes.each do |attr_name|
-          value = get_attribute(node, attr_name)
-          next if value.nil? || value.empty?
-
-          next if valid_color?(value)
-
-          context.add_error(
-            requirement_id: id,
-            message: "Color '#{value}' in attribute '#{attr_name}' is not allowed in this profile",
-            node: node,
-            severity: :error,
-            data: {
-              attribute: attr_name,
-              value: value,
-              element: node.name,
-            },
-          )
-        end
-
-        # Check style attribute for color properties
-        style_value = get_attribute(node, "style")
-        return unless style_value
-
-        styles = parse_style(style_value)
-        color_properties = %w[fill stroke color stop-color flood-color
-                              lighting-color]
-
-        color_properties.each do |prop|
-          value = styles[prop]
-          next if value.nil? || value.empty?
-
-          next if valid_color?(value)
-
-          context.add_error(
-            requirement_id: id,
-            message: "Color '#{value}' in style property '#{prop}' is not allowed in this profile",
-            node: node,
-            severity: :error,
-            data: {
-              attribute: prop,
-              value: value,
-              element: node.name,
-            },
-          )
-        end
+        validate_colors(node, context)
       end
 
       def validate_sax_element(element, context)
+        # ElementProxy always represents an element, so no element? check needed
+        validate_colors(element, context)
+      end
+
+      private
+
+      # Shared validation logic for both DOM and SAX modes
+      def validate_colors(node_or_element, context)
         # Skip attribute validation for structurally invalid nodes
-        return if context.node_structurally_invalid?(element)
+        return if skip_attribute_validation?(node_or_element, context)
+
+        # Get element name
+        element_name = node_or_element.name
 
         # Check color-related attributes
         color_attributes = %w[fill stroke color stop-color flood-color
                               lighting-color]
 
         color_attributes.each do |attr_name|
-          value = element.raw_attributes[attr_name]
+          value = get_attribute(node_or_element, attr_name)
           next if value.nil? || value.empty?
 
           next if valid_color?(value)
@@ -97,18 +57,18 @@ module SvgConform
           context.add_error(
             requirement_id: id,
             message: "Color '#{value}' in attribute '#{attr_name}' is not allowed in this profile",
-            node: element,
+            node: node_or_element,
             severity: :error,
             data: {
               attribute: attr_name,
               value: value,
-              element: element.name,
+              element: element_name,
             },
           )
         end
 
         # Check style attribute for color properties
-        style_value = element.raw_attributes["style"]
+        style_value = get_attribute(node_or_element, "style")
         return unless style_value
 
         styles = parse_style(style_value)
@@ -124,19 +84,17 @@ module SvgConform
           context.add_error(
             requirement_id: id,
             message: "Color '#{value}' in style property '#{prop}' is not allowed in this profile",
-            node: element,
+            node: node_or_element,
             severity: :error,
             data: {
               attribute: prop,
               value: value,
-              element: element.name,
+              element: element_name,
             },
           )
         end
       end
 
-      private
-
       def valid_color?(color)
         # First check if threshold-based validation is enabled
         if black_and_white_threshold

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