svg_conform 0.1.1 → 0.1.3

data/examples/readme_usage.rb

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Working example based on README.adoc Ruby API usage section
+require_relative "../lib/svg_conform"
+
+puts "=" * 60
+puts "README Ruby API Usage Example"
+puts "=" * 60
+puts
+
+# Sample SVG content with some issues
+svg_content = <<~SVG
+  <svg xmlns="http://www.w3.org/2000/svg" width="100" height="100">
+    <rect fill="red" width="50" height="50"/>
+    <circle fill="blue" cx="75" cy="75" r="20"/>
+  </svg>
+SVG
+
+puts "Test SVG content:"
+puts svg_content
+puts
+
+# Load a profile and validate
+profile = SvgConform::Profiles.get(:svg_1_2_rfc)
+document = SvgConform::Document.new(svg_content)
+result = profile.validate(document)
+
+puts "Validation Results:"
+puts "Valid: #{result.valid?}"
+puts "Errors: #{result.errors.count}"
+puts "Warnings: #{result.warnings.count}"
+puts
+
+if result.errors.any?
+  puts "Error details:"
+  result.errors.each_with_index do |error, i|
+    puts "  #{i + 1}. [#{error.requirement_id}] #{error.message}"
+  end
+  puts
+end
+
+# Apply remediations to fix issues
+if !result.valid? && profile.remediation_count.positive?
+  puts "Applying remediations (profile has #{profile.remediation_count} remediations)..."
+  changes = profile.apply_remediations(document)
+
+  puts "Applied #{changes.length} remediations"
+  puts
+
+  puts "Fixed SVG:"
+  puts document.to_xml
+  puts
+
+  # Re-validate to confirm fixes
+  result_after = profile.validate(document)
+  puts "Re-validation after fixes:"
+  puts "Valid: #{result_after.valid?}"
+  puts "Errors: #{result_after.errors.count}"
+else
+  puts "Document is already valid or no remediations available"
+end
+
+puts
+puts "=" * 60
+puts "Example complete!"
+puts "=" * 60

data/examples/requirements_demo.rb

@@ -30,7 +30,7 @@ class RequirementsDemo
 
     begin
       # Load IETF profile from YAML
-      svg_1_2_rfc_profile = SvgConform::ProfileRegistry.load_profile("svg_1_2_rfc")
+      svg_1_2_rfc_profile = SvgConform::Profiles.get(:svg_1_2_rfc)
       puts "✓ Loaded IETF profile: #{svg_1_2_rfc_profile.name}"
       puts "  Description: #{svg_1_2_rfc_profile.description}"
       puts "  Requirements: #{svg_1_2_rfc_profile.requirement_count}"
@@ -38,7 +38,7 @@ class RequirementsDemo
       puts
 
       # Load Lucid fix profile
-      lucid_profile = SvgConform::ProfileRegistry.load_profile("lucid_fix")
+      lucid_profile = SvgConform::Profiles.get(:lucid_fix)
       puts "✓ Loaded Lucid Fix profile: #{lucid_profile.name}"
       puts "  Description: #{lucid_profile.description}"
       puts "  Requirements: #{lucid_profile.requirement_count}"
@@ -46,7 +46,7 @@ class RequirementsDemo
       puts
 
       # List available profiles
-      available = SvgConform::ProfileRegistry.available_profiles
+      available = SvgConform::Profiles.available_profiles
       puts "Available profiles: #{available.join(', ')}"
       puts
     rescue StandardError => e
@@ -204,7 +204,7 @@ class RequirementsDemo
 
     begin
       # Load the Lucid fix profile
-      profile = SvgConform::ProfileRegistry.load_profile("lucid_fix")
+      profile = SvgConform::Profiles.get(:lucid_fix)
 
       # Process the SVG
       document = SvgConform::Document.new(lucid_svg)

data/lib/svg_conform/document.rb

@@ -16,6 +16,7 @@ module SvgConform
         @content = content_or_path
       end
 
+      @xpath_cache = {}
       parse_document
     end
 
@@ -36,7 +37,8 @@ module SvgConform
     end
 
     def xpath(path, namespaces = {})
-      @moxml_document.xpath(path, namespaces)
+      cache_key = [path, namespaces].hash
+      @xpath_cache[cache_key] ||= @moxml_document.xpath(path, namespaces)
     end
 
     def traverse(&)
@@ -60,6 +62,10 @@ module SvgConform
       Document.from_content(to_xml)
     end
 
+    def clear_cache
+      @xpath_cache.clear
+    end
+
     def valid_xml?
       !@moxml_document.nil?
     rescue StandardError

data/lib/svg_conform/element_proxy.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module SvgConform
+  # Lightweight attribute representation for SAX parsing
+  class SaxAttribute
+    attr_reader :name, :value
+
+    def initialize(name, value)
+      @name = name
+      @value = value
+    end
+
+    def namespace
+      nil # DOM handles namespaces via XPath; SAX checks attribute names directly
+    end
+  end
+
+  # Lightweight element representation during SAX parsing
+  # Provides a node-like interface for validation requirements
+  # without the overhead of full DOM tree
+  class ElementProxy
+    attr_reader :name, :position, :path, :parent, :raw_attributes
+    attr_accessor :text_content, :child_counters
+
+    def initialize(name:, attributes:, position:, path:, parent:)
+      @name = name
+      @raw_attributes = attributes # Hash of attribute name => value
+      @position = position
+      @path = path # Array of parent path parts
+      @parent = parent
+      @text_content = +"" # Mutable string
+      @child_counters = {} # Track child element positions
+    end
+
+    # Build full path ID for this element
+    def path_id
+      parts = @path + ["#{@name}[#{@position}]"]
+      "/#{parts.join('/')}"
+    end
+
+    # Return attributes as array of SaxAttribute objects (for compatibility)
+    def attributes
+      @raw_attributes.map { |name, value| SaxAttribute.new(name, value) }
+    end
+
+    # Check if this element has a specific attribute
+    def attribute(name)
+      value = @raw_attributes[name] || @raw_attributes[name.to_s]
+      value ? SaxAttribute.new(name, value) : nil
+    end
+
+    # Get attribute value (alias for compatibility)
+    def [](name)
+      @raw_attributes[name] || @raw_attributes[name.to_s]
+    end
+
+    # Check if attribute exists
+    def has_attribute?(name)
+      @raw_attributes.key?(name) || @raw_attributes.key?(name.to_s)
+    end
+
+    # Get namespace from attributes or parent
+    def namespace
+      @raw_attributes["xmlns"] || @parent&.namespace
+    end
+
+    # Check if this is a text node (always false for ElementProxy)
+    def text?
+      false
+    end
+
+    # Support dynamic attribute access
+    def method_missing(method, *_args)
+      if method.to_s.end_with?("?")
+        # Boolean check
+        has_attribute?(method.to_s.chomp("?"))
+      else
+        # Attribute access
+        @attributes[method.to_s] || @attributes[method.to_sym]
+      end
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      @raw_attributes.key?(method.to_s) || @raw_attributes.key?(method.to_sym) || super
+    end
+
+    # For compatibility with validation context
+    def line
+      nil # SAX doesn't provide line numbers easily
+    end
+
+    def column
+      nil
+    end
+
+    # Provide a stable identifier for this element
+    def element_id
+      path_id
+    end
+  end
+end

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)
+      compute_path_forward(node)
+    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.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.equal?(node)
+      end
+
+      position
+    end
+  end
+end

data/lib/svg_conform/node_index_builder.rb

@@ -0,0 +1,48 @@
+# 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,82 @@ module SvgConform
         end
       end
 
+      def validate_sax_element(element, context)
+        # Skip if parent is structurally invalid (matches DOM behavior)
+        if element.parent && context.node_structurally_invalid?(element.parent)
+          # Mark this element as invalid too since it won't be in final document
+          context.mark_node_structurally_invalid(element)
+          return
+        end
+
+        # 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 +343,152 @@ module SvgConform
         errors
       end
 
+      def foreign_namespace_sax?(element)
+        return false unless skip_foreign_namespaces
+
+        # Check if element name has a namespace prefix (e.g., rdf:RDF, cc:Work)
+        if element.name.include?(":")
+          # Element has prefix, it's in a foreign namespace
+          return true
+        end
+
+        # Also check xmlns attribute
+        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 do |config|
+          config.tag == element_name
+        end
+        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:")
+
+          # Skip namespaced attributes (those with colon prefix like inkscape:label)
+          # This matches DOM behavior where XPath skips attributes with namespaces
+          next if attr_name.include?(":") && !attr_name.start_with?("xmlns:")
+
+          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,61 @@ 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)