svg_conform 0.1.1 → 0.1.2

data/lib/svg_conform/fast_document_analyzer.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module SvgConform
+  # Fast document analyzer that pre-computes node relationships and IDs
+  # in a single pass to avoid repeated expensive traversals
+  # 
+  # IMPORTANT: Stores paths indexed by the path itself (not object_id)
+  # since node object_ids change between traversals
+  class FastDocumentAnalyzer
+    attr_reader :path_cache
+    
+    def initialize(document)
+      @document = document
+      @path_cache = {}
+      
+      analyze_document
+    end
+    
+    # Get cached path-based ID for a node by computing its path once
+    def get_node_id(node)
+      return nil unless node.respond_to?(:name) && node.name
+      
+      # Compute path for this node (fast with forward traversal counting)
+      path = compute_path_forward(node)
+      path
+    end
+    
+    private
+    
+    def analyze_document
+      # Pre-populate cache is not needed since we compute on demand
+      # The optimization comes from forward-counting siblings instead of backward
+    end
+    
+    def compute_path_forward(node)
+      path_parts = []
+      current = node
+      
+      while current
+        if current.respond_to?(:name) && current.name
+          # Count position among siblings by iterating forward from parent
+          position = calculate_position_fast(current)
+          path_parts.unshift("#{current.name}[#{position}]")
+        end
+        
+        break unless current.respond_to?(:parent)
+        
+        begin
+          current = current.parent
+        rescue NoMethodError
+          break
+        end
+        
+        break unless current
+      end
+      
+      "/#{path_parts.join('/')}"
+    end
+    
+    def calculate_position_fast(node)
+      return 1 unless node.respond_to?(:parent)
+      
+      parent = begin
+        node.parent
+      rescue NoMethodError
+        nil
+      end
+      
+      return 1 unless parent && parent.respond_to?(:children)
+      
+      # Count this node's position among siblings with same name
+      position = 0
+      parent.children.each do |child|
+        next unless child.respond_to?(:name) && child.name == node.name
+        position += 1
+        break if child.object_id == node.object_id
+      end
+      
+      position
+    end
+  end
+end

data/lib/svg_conform/node_index_builder.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module SvgConform
+  # Builds an index of node positions in single forward pass
+  # Replicates the exact logic of backward sibling traversal but computed forward
+  class NodeIndexBuilder
+    def initialize(document)
+      @node_positions = {}
+      build_index(document.root) if document.root
+    end
+
+    # Get position of node among its siblings with same name
+    def get_position(node)
+      @node_positions[node]
+    end
+
+    private
+
+    # Build position index by traversing forward but tracking as if counting backward
+    # This matches the original logic: position = count of (previous siblings with same name) + 1
+    def build_index(node, parent_child_counter = nil)
+      return unless node.respond_to?(:name) && node.name
+
+      # If this is root or we don't have parent's counter, create new counter
+      if parent_child_counter.nil?
+        # This is the root - position is always 1
+        @node_positions[node] = 1
+      else
+        # Increment counter for this node name
+        parent_child_counter[node.name] ||= 0
+        parent_child_counter[node.name] += 1
+        @node_positions[node] = parent_child_counter[node.name]
+      end
+
+      # Process children with a fresh counter for this parent's children
+      if node.respond_to?(:children)
+        # Create new counter for children of this node
+        child_counter = {}
+        node.children.each do |child|
+          # Only process nodes with name (skip text nodes, etc.)
+          next unless child.respond_to?(:name) && child.name
+          build_index(child, child_counter)
+        end
+      end
+    end
+  end
+end

data/lib/svg_conform/requirements/allowed_elements_requirement.rb

@@ -120,6 +120,75 @@ module SvgConform
         end
       end
 
+      def validate_sax_element(element, context)
+        # Skip foreign namespace elements if configured (let NamespaceRequirement handle them)
+        if skip_foreign_namespaces && foreign_namespace_sax?(element)
+          return
+        end
+
+        element_name = element.name
+
+        # Check if element is explicitly disallowed
+        if disallowed_element?(element_name)
+          context.add_error(
+            requirement_id: id,
+            message: "Element '#{element_name}' is not allowed in this profile",
+            node: element,
+            severity: :error,
+            data: { element: element_name }
+          )
+          return
+        end
+
+        # Check parent-child relationships
+        if check_parent_child && element.parent
+          parent_name = element.parent.name
+          if invalid_parent_child?(parent_name, element_name)
+            context.add_error(
+              requirement_id: id,
+              message: "The element '#{element_name}' is not allowed as a child of '#{parent_name}'",
+              node: element,
+              severity: :error,
+              data: { element: element_name, parent: parent_name }
+            )
+            # Mark node as structurally invalid
+            context.mark_node_structurally_invalid(element)
+            return
+          end
+        end
+
+        # Check if element is in allowed list
+        if element_configs&.any?
+          allowed_elements = element_configs.map(&:tag)
+          unless allowed_elements.include?(element_name)
+            context.add_error(
+              requirement_id: id,
+              message: "Element '#{element_name}' is not allowed in this profile",
+              node: element,
+              severity: :error,
+              data: { element: element_name }
+            )
+            # Mark as structurally invalid
+            context.mark_node_structurally_invalid(element)
+            return
+          end
+        end
+
+        # Validate attributes
+        potential_errors = collect_attribute_errors_sax(element)
+        prioritized_errors = prioritize_errors(potential_errors)
+
+        # Add the prioritized errors to the context
+        prioritized_errors.each do |error|
+          context.add_error(
+            requirement_id: id,
+            message: error[:message],
+            node: element,
+            severity: :error
+          )
+        end
+      end
+
       private
 
       def disallowed_element?(element_name)
@@ -267,6 +336,139 @@ module SvgConform
         errors
       end
 
+      def foreign_namespace_sax?(element)
+        return false unless skip_foreign_namespaces
+
+        # Check if element has a namespace
+        element_namespace = element.namespace
+
+        # No namespace or empty namespace means SVG namespace (default)
+        return false if element_namespace.nil? || element_namespace.empty?
+
+        # Check if namespace is in allowed list
+        effective_allowed_namespaces = allowed_namespaces
+        if allow_rdf_metadata
+          effective_allowed_namespaces = allowed_namespaces + RDF_NAMESPACES
+        end
+
+        return false if effective_allowed_namespaces.empty?
+
+        !effective_allowed_namespaces.include?(element_namespace)
+      end
+
+      def collect_attribute_errors_sax(element)
+        errors = []
+
+        # Always collect global disallowed attributes first
+        errors.concat(collect_global_disallowed_errors_sax(element))
+
+        # Collect element-specific attribute errors if enabled
+        errors.concat(collect_element_attribute_errors_sax(element)) if check_attributes
+
+        errors
+      end
+
+      def collect_element_attribute_errors_sax(element)
+        errors = []
+        element_name = element.name
+
+        return errors unless element_configs&.any?
+
+        element_config = element_configs.find { |config| config.tag == element_name }
+        return errors unless element_config&.attr
+
+        allowed_attrs = []
+        disallowed_attrs = []
+
+        # Parse attributes, separating allowed from disallowed (prefixed with !)
+        element_config.attr.each do |attribute|
+          if attribute.start_with?("!")
+            disallowed_attrs << attribute[1..].downcase
+          else
+            allowed_attrs << attribute.downcase
+          end
+        end
+
+        # Add common attributes that are allowed on all elements
+        common_attrs = %w[id class style xmlns]
+        allowed_attrs = (allowed_attrs + common_attrs).uniq
+
+        # Add global properties
+        global_properties = %w[
+          about base baseprofile d break class content cx cy datatype height href
+          label lang pathlength points preserveaspectratio property r rel resource
+          rev role rotate rx ry space snapshottime transform typeof version width
+          viewbox x x1 x2 y y1 y2 stroke stroke-width stroke-linecap stroke-linejoin
+          stroke-miterlimit stroke-dasharray stroke-dashoffset stroke-opacity
+          vector-effect viewport-fill display viewport-fill-opacity visibility
+          image-rendering color-rendering shape-rendering text-rendering
+          buffered-rendering solid-opacity solid-color color stop-color stop-opacity
+          line-increment text-align display-align font-size font-family font-weight
+          font-style font-variant direction unicode-bidi text-anchor fill fill-rule
+          fill-opacity requiredfeatures requiredformats requiredextensions
+          requiredfonts systemlanguage
+        ]
+        allowed_attrs = (allowed_attrs + global_properties).uniq
+
+        element.attributes.each do |attr|
+          attr_name = attr.name.downcase
+          next if attr_name.start_with?("xmlns:")
+          next if attr_name.start_with?("xml:")
+          next if attr.namespace
+          next if attr_name.start_with?("data-")
+
+          # Check if explicitly disallowed
+          if disallowed_attrs.include?(attr_name)
+            errors << {
+              type: :explicitly_disallowed,
+              attribute: attr_name,
+              message: "Attribute '#{attr_name}' is explicitly disallowed on element '#{element_name}'"
+            }
+            next
+          end
+
+          # Check if not in allowed list
+          next if allowed_attrs.include?(attr_name)
+
+          errors << {
+            type: :not_allowed,
+            attribute: attr_name,
+            message: "Attribute '#{attr_name}' is not allowed on element '#{element_name}'"
+          }
+        end
+
+        errors
+      end
+
+      def collect_global_disallowed_errors_sax(element)
+        errors = []
+
+        return errors unless element_configs&.any?
+
+        global_config = element_configs.find { |config| config.tag == "*" }
+        return errors unless global_config&.attr
+
+        global_disallowed = []
+        global_config.attr.each do |attribute|
+          global_disallowed << attribute[1..].downcase if attribute.start_with?("!")
+        end
+
+        return errors if global_disallowed.empty?
+
+        element.attributes.each do |attr|
+          attr_name = attr.name.downcase
+          next unless global_disallowed.include?(attr_name)
+
+          errors << {
+            type: :globally_disallowed,
+            attribute: attr_name,
+            message: "Attribute '#{attr_name}' is globally disallowed in this profile"
+          }
+        end
+
+        errors
+      end
+
       def prioritize_errors(errors)
         # Group errors by attribute name
         errors_by_attr = errors.group_by { |error| error[:attribute] }

data/lib/svg_conform/requirements/base_requirement.rb

@@ -28,6 +28,33 @@ module SvgConform
         end
       end
 
+      # SAX-based validation methods (NEW for streaming validation)
+
+      # Called for each element during SAX parsing
+      # Override in subclasses for immediate validation
+      def validate_sax_element(element, context)
+        # Default: Empty - subclasses must override for SAX support
+        # Cannot call check() here as it's abstract
+      end
+
+      # Called for each element to collect data for deferred validation
+      # Override in subclasses that need to collect data
+      def collect_sax_data(element, context)
+        # Default: no data collection
+      end
+
+      # Called at end of document for deferred validation
+      # Override in subclasses that need full document data
+      def validate_sax_complete(context)
+        # Default: no deferred validation
+      end
+
+      # Indicates if requirement needs deferred validation
+      # Override to return true for requirements that need forward references
+      def needs_deferred_validation?
+        false
+      end
+
       # Determine if this requirement should check a specific node
       def should_check_node?(node, context = nil)
         return false unless node.respond_to?(:name) && node.respond_to?(:attributes)

data/lib/svg_conform/requirements/color_restrictions_requirement.rb

@@ -80,6 +80,59 @@ module SvgConform
         end
       end
 
+      def validate_sax_element(element, context)
+        # Skip attribute validation for structurally invalid nodes
+        return if context.node_structurally_invalid?(element)
+
+        # 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]
+          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: element,
+            severity: :error,
+            data: {
+              attribute: attr_name,
+              value: value,
+              element: element.name
+            }
+          )
+        end
+
+        # Check style attribute for color properties
+        style_value = element.raw_attributes["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: element,
+            severity: :error,
+            data: {
+              attribute: prop,
+              value: value,
+              element: element.name
+            }
+          )
+        end
+      end
+
       private
 
       def valid_color?(color)

data/lib/svg_conform/requirements/font_family_requirement.rb

@@ -46,6 +46,24 @@ module SvgConform
         end
       end
 
+      def validate_sax_element(element, context)
+        # Check font-family attribute only
+        font_family = element.raw_attributes["font-family"]
+        return unless font_family
+
+        if svgcheck_compatibility
+          check_font_family_svgcheck_mode(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,
+            severity: :error,
+            data: { attribute: "font-family", value: font_family }
+          )
+        end
+      end
+
       private
 
       def check_font_family_svgcheck_mode(node, context, font_family_value,

data/lib/svg_conform/requirements/forbidden_content_requirement.rb

@@ -55,6 +55,32 @@ module SvgConform
           end
         end
       end
+
+      def validate_sax_element(element, context)
+        # Check if this is a forbidden element
+        if forbidden_elements.include?(element.name)
+          context.add_error(
+            requirement_id: id,
+            message: "Forbidden element '#{element.name}' is not allowed",
+            node: element,
+            severity: :error
+          )
+        end
+
+        # Check for forbidden attributes
+        element.attributes.each do |attr|
+          attr_name = attr.name
+
+          if forbidden_attributes.include?(attr_name)
+            context.add_error(
+              requirement_id: id,
+              message: "Forbidden attribute '#{attr_name}' is not allowed",
+              node: element,
+              severity: :error
+            )
+          end
+        end
+      end
     end
   end
 end

data/lib/svg_conform/requirements/id_reference_requirement.rb

@@ -6,6 +6,102 @@ require "set"
 module SvgConform
   module Requirements
     class IdReferenceRequirement < BaseRequirement
+      def needs_deferred_validation?
+        true
+      end
+
+      def collect_sax_data(element, context)
+        # Initialize collections on first call
+        @collected_ids ||= Set.new
+        @collected_url_refs ||= []
+        @collected_href_refs ||= []
+        @collected_other_refs ||= []
+
+        # Collect IDs
+        id_value = element.raw_attributes["id"]
+        @collected_ids.add(id_value) if id_value && !id_value.empty?
+
+        # Collect url() references
+        url_attributes = %w[fill stroke marker-start marker-mid marker-end clip-path mask filter]
+        url_attributes.each do |attr_name|
+          attr_value = element.raw_attributes[attr_name]
+          next unless attr_value
+
+          url_refs = extract_url_references(attr_value)
+          url_refs.each do |ref_id|
+            @collected_url_refs << [element, ref_id, attr_name]
+          end
+        end
+
+        # Check style attribute for url() references
+        style_attr = element.raw_attributes["style"]
+        if style_attr
+          url_refs = extract_url_references(style_attr)
+          url_refs.each do |ref_id|
+            @collected_url_refs << [element, ref_id, "style"]
+          end
+        end
+
+        # Collect href references
+        href_value = element.raw_attributes["href"] || element.raw_attributes["xlink:href"]
+        if href_value&.start_with?("#")
+          ref_id = href_value[1..]  # Remove #
+          @collected_href_refs << [element, ref_id]
+        end
+
+        # Collect other ID references
+        id_ref_attributes = %w[for aria-labelledby aria-describedby aria-controls aria-owns]
+        id_ref_attributes.each do |attr_name|
+          attr_value = element.raw_attributes[attr_name]
+          next unless attr_value
+
+          ref_ids = attr_value.split(/\s+/)
+          ref_ids.each do |ref_id|
+            next if ref_id.empty?
+            @collected_other_refs << [element, ref_id, attr_name]
+          end
+        end
+      end
+
+      def validate_sax_complete(context)
+        # Validate all collected references
+        @collected_url_refs.each do |element, ref_id, attr_name|
+          next if @collected_ids.include?(ref_id)
+
+          message = if attr_name == "style"
+                      "Reference to undefined ID '#{ref_id}' in style attribute"
+                    else
+                      "Reference to undefined ID '#{ref_id}' in attribute '#{attr_name}'"
+                    end
+
+          context.add_error(
+            node: element,
+            message: message,
+            requirement_id: id
+          )
+        end
+
+        @collected_href_refs.each do |element, ref_id|
+          next if @collected_ids.include?(ref_id)
+
+          context.add_error(
+            node: element,
+            message: "Reference to undefined ID '#{ref_id}' in href attribute",
+            requirement_id: id
+          )
+        end
+
+        @collected_other_refs.each do |element, ref_id, attr_name|
+          next if @collected_ids.include?(ref_id)
+
+          context.add_error(
+            node: element,
+            message: "Reference to undefined ID '#{ref_id}' in #{attr_name} attribute",
+            requirement_id: id
+          )
+        end
+      end
+
       def validate_document(document, context)
         # Collect all IDs in the document
         ids = Set.new

data/lib/svg_conform/requirements/invalid_id_references_requirement.rb

@@ -21,6 +21,97 @@ module SvgConform
         map "strict_mode", to: :strict_mode
       end
 
+      def initialize(*args)
+        super
+        @collected_ids = Set.new
+        @use_element_refs = []  # [element, ref_id, href]
+        @other_refs = []  # [element, ref_id, attr_name, value]
+      end
+
+      def needs_deferred_validation?
+        true
+      end
+
+      def collect_sax_data(element, context)
+        # Initialize collections on first call
+        @collected_ids ||= Set.new
+        @use_element_refs ||= []
+        @other_refs ||= []
+
+        # Collect IDs
+        id_attr = element.raw_attributes["id"]
+        @collected_ids.add(id_attr) if id_attr && !id_attr.empty?
+
+        # Collect use element references
+        if check_use_elements && element.name == "use"
+          href = element.raw_attributes["xlink:href"] || element.raw_attributes["href"]
+          if href&.start_with?("#")
+            ref_id = href[1..]
+            @use_element_refs << [element, ref_id, href] unless ref_id.empty?
+          end
+        end
+
+        # Collect other ID references if enabled
+        if check_other_references
+          id_reference_attributes = %w[clip-path mask filter marker-start marker-mid marker-end fill stroke]
+
+          id_reference_attributes.each do |attr_name|
+            attr_value = element.raw_attributes[attr_name]
+            next unless attr_value&.match?(/^url\(#(.+)\)$/)
+
+            ref_id = Regexp.last_match(1)
+            @other_refs << [element, ref_id, attr_name, attr_value]
+          end
+
+          # Check style attribute
+          style_value = element.raw_attributes["style"]
+          if style_value
+            styles = parse_style(style_value)
+            styles.each do |property, value|
+              next unless value&.match?(/^url\(#(.+)\)$/)
+
+              ref_id = Regexp.last_match(1)
+              @other_refs << [element, ref_id, "style:#{property}", value]
+            end
+          end
+        end
+      end
+
+      def validate_sax_complete(context)
+        # Validate use element references
+        @use_element_refs.each do |element, ref_id, href|
+          next if @collected_ids.include?(ref_id)
+
+          context.add_error(
+            requirement_id: id,
+            node: element,
+            message: "use element references non-existent ID: #{ref_id}",
+            severity: :error,
+            data: { invalid_id: ref_id, href: href }
+          )
+        end
+
+        # Validate other references if enabled
+        @other_refs.each do |element, ref_id, attr_name, value|
+          next if @collected_ids.include?(ref_id)
+
+          message = if attr_name.start_with?("style:")
+                      property = attr_name.split(":", 2)[1]
+                      "style property #{property} references non-existent ID: #{ref_id}"
+                    else
+                      "#{attr_name} references non-existent ID: #{ref_id}"
+                    end
+
+          context.add_error(
+            requirement_id: id,
+            node: element,
+            message: message,
+            severity: :error,
+            data: { invalid_id: ref_id, attribute: attr_name, value: value }
+          )
+        end
+      end
+
       def validate_document(document, context)
         # Collect all existing IDs in the document
         existing_ids = collect_existing_ids(document)