svg_conform 0.1.1 → 0.1.3

data/lib/svg_conform/requirements/style_requirement.rb

@@ -43,6 +43,18 @@ module SvgConform
         check_style_properties(style_value, node, context)
       end
 
+      def validate_sax_element(element, context)
+        style_value = element.raw_attributes["style"]
+        return unless style_value
+        return if style_value.strip.empty?
+
+        # 1. Check for malformed style syntax
+        check_malformed_syntax(style_value, element, context)
+
+        # 2. Check for allowed/disallowed properties and validate their values
+        check_style_properties(style_value, element, context)
+      end
+
       private
 
       def check_malformed_syntax(style_value, node, context)

data/lib/svg_conform/requirements/viewbox_required_requirement.rb

@@ -83,6 +83,78 @@ module SvgConform
         )
       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"]
+
+        if viewbox.nil? || viewbox.empty?
+          context.add_error(
+            requirement_id: id,
+            message: "SVG root element must have a viewBox attribute",
+            node: element,
+            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"]
+
+          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,
+              severity: :error,
+              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")
+        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,
+            severity: :error,
+            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_id: id,
+          message: "viewBox width and height must be positive values",
+          node: element,
+          severity: :error,
+          data: {
+            viewbox_value: viewbox,
+            width: width,
+            height: height,
+          },
+        )
+      end
+
       private
 
       def valid_number?(str)

data/lib/svg_conform/sax_document.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+require_relative "sax_validation_handler"
+
+module SvgConform
+  # SAX-based document for streaming validation
+  # Provides high-performance validation for large SVG files
+  # without loading entire DOM tree into memory
+  class SaxDocument
+    attr_reader :file_path, :content
+
+    def self.from_file(file_path)
+      new(File.read(file_path), file_path)
+    end
+
+    def self.from_content(content)
+      new(content, nil)
+    end
+
+    def initialize(content, file_path = nil)
+      @content = content
+      @file_path = file_path
+    end
+
+    # Validate using SAX streaming parser
+    def validate_with_profile(profile)
+      handler = SaxValidationHandler.new(profile)
+      parser = Nokogiri::XML::SAX::Parser.new(handler)
+
+      begin
+        parser.parse(@content)
+      rescue StandardError => e
+        # Handle parse errors
+        handler.add_parse_error(e)
+      end
+
+      handler.result
+    end
+
+    # For compatibility - convert to DOM when needed
+    def to_dom
+      Document.from_content(@content)
+    end
+  end
+end

data/lib/svg_conform/sax_validation_handler.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+require_relative "element_proxy"
+require_relative "validation_context"
+require_relative "validation_result"
+
+module SvgConform
+  # SAX event handler for streaming SVG validation
+  # Processes XML events and dispatches to requirements
+  class SaxValidationHandler < Nokogiri::XML::SAX::Document
+    attr_reader :result, :context
+
+    def initialize(profile)
+      @profile = profile
+      @element_stack = [] # Track parent-child hierarchy
+      @path_stack = [] # Current element path
+      @position_counters = [] # Stack of sibling counters per level
+      @parse_errors = []
+      @result = nil # Will be set in end_document
+
+      # Create validation context (without document reference for SAX)
+      @context = create_sax_context
+
+      # Classify requirements into immediate vs deferred
+      @immediate_requirements = []
+      @deferred_requirements = []
+      classify_requirements
+    end
+
+    # SAX Event: Document start
+    def start_document
+      # Initialize root level counters
+      @position_counters.push({})
+    end
+
+    # SAX Event: Element start tag
+    def start_element(name, attributes = [])
+      attrs = Hash[attributes]
+
+      # Calculate position among siblings at current level
+      current_counters = @position_counters.last || {}
+      current_counters[name] ||= 0
+      current_counters[name] += 1
+      position = current_counters[name]
+
+      # Build element proxy
+      element = ElementProxy.new(
+        name: name,
+        attributes: attrs,
+        position: position,
+        path: @path_stack.dup,
+        parent: @element_stack.last,
+      )
+
+      # Push to stacks
+      @element_stack.push(element)
+      @path_stack.push("#{name}[#{position}]")
+      @position_counters.push({}) # New level for this element's children
+
+      # Validate with immediate requirements
+      @immediate_requirements.each do |req|
+        req.validate_sax_element(element, @context)
+      end
+
+      # Deferred requirements may need to collect data
+      @deferred_requirements.each do |req|
+        if req.respond_to?(:collect_sax_data)
+          req.collect_sax_data(element,
+                               @context)
+        end
+      end
+    end
+
+    # SAX Event: Element end tag
+    def end_element(_name)
+      @element_stack.pop
+      @path_stack.pop
+      @position_counters.pop
+    end
+
+    # SAX Event: Text content
+    def characters(string)
+      return if @element_stack.empty?
+
+      @element_stack.last.text_content << string
+    end
+
+    # SAX Event: Document complete
+    def end_document
+      # Run deferred validation
+      @deferred_requirements.each do |req|
+        req.validate_sax_complete(@context)
+      end
+
+      # Create result
+      @result = ValidationResult.new(nil, @profile, @context)
+    end
+
+    # SAX Event: Parse error
+    def error(error_message)
+      @parse_errors << error_message
+    end
+
+    # SAX Event: Warning
+    def warning(warning_message)
+      # Can log warnings if needed
+    end
+
+    # Handle parse errors
+    def add_parse_error(error)
+      @context.add_error(
+        node: nil,
+        message: "Parse error: #{error.message}",
+        requirement_id: "parse_error",
+        severity: :error,
+      )
+    end
+
+    # Get result (will be nil until end_document called)
+    def result
+      @result || create_incomplete_result
+    end
+
+    private
+
+    def create_incomplete_result
+      # Return result even if parsing incomplete
+      ValidationResult.new(nil, @profile, @context)
+    end
+
+    # Create a SAX-compatible validation context
+    def create_sax_context
+      # Create context without triggering DOM operations
+      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(:@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
+      context
+    end
+
+    # Classify requirements based on validation needs
+    def classify_requirements
+      return unless @profile.requirements
+
+      @profile.requirements.each do |req|
+        if req.respond_to?(:needs_deferred_validation?) && req.needs_deferred_validation?
+          @deferred_requirements << req
+        else
+          @immediate_requirements << req
+        end
+      end
+    end
+  end
+end

data/lib/svg_conform/validation_context.rb

@@ -17,6 +17,8 @@ module SvgConform
       @infos = []
       @data = {}
       @structurally_invalid_node_ids = Set.new
+      @node_id_cache = {}
+      @cache_populated = false
     end
 
     # Mark a node as structurally invalid (e.g., invalid parent-child relationship)
@@ -24,6 +26,8 @@ module SvgConform
     # Also marks all descendants as invalid since they'll be removed with the parent
     def mark_node_structurally_invalid(node)
       node_id = generate_node_id(node)
+      return if node_id.nil? # Safety check
+
       @structurally_invalid_node_ids.add(node_id)
 
       # Mark all descendants as invalid too
@@ -32,10 +36,14 @@ module SvgConform
 
     # Mark all descendants of a node as structurally invalid
     def mark_descendants_invalid(node)
-      return unless node.respond_to?(:children)
+      # 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 = generate_node_id(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)
@@ -45,6 +53,8 @@ module SvgConform
     # Check if a node is structurally invalid
     def node_structurally_invalid?(node)
       node_id = generate_node_id(node)
+      return false if node_id.nil? # Safety check
+
       @structurally_invalid_node_ids.include?(node_id)
     end
 
@@ -120,16 +130,90 @@ requirement_id: nil, severity: nil, fix: nil, data: {})
 
     # Generate a unique identifier for a node based on its path
     # Builds a stable path by walking up the parent chain
+    # OPTIMIZED: Lazy cache population - populate entire cache on first call
     def generate_node_id(node)
       return nil unless node.respond_to?(:name)
 
-      # Build path by walking up parent chain
+      # Populate cache for ALL nodes on first access
+      unless @cache_populated
+        populate_node_id_cache
+        @cache_populated = true
+      end
+
+      # Try cache lookup first
+      cached_id = @node_id_cache[node]
+      return cached_id if cached_id
+
+      # Fall back to building path if node not in cache
+      # (happens when different traversals create different wrapper objects)
+      build_node_path(node)
+    end
+
+    private
+
+    # Populate cache for all nodes using document.traverse with parent tracking
+    def populate_node_id_cache
+      parent_stack = []
+      counter_stack = [{}] # Stack of {element_name => count} hashes
+
+      @document.traverse do |node|
+        next unless node.respond_to?(:name) && node.name
+
+        # Detect parent changes by checking node.parent
+        current_parent = node.respond_to?(:parent) ? node.parent : nil
+
+        # Adjust stack based on actual parent
+        while parent_stack.size.positive? && !parent_stack.last.equal?(current_parent)
+          parent_stack.pop
+          counter_stack.pop
+        end
+
+        # If we have a new parent level, push it
+        if current_parent && (parent_stack.empty? || !parent_stack.last.equal?(current_parent))
+          parent_stack.push(current_parent)
+          counter_stack.push({})
+        end
+
+        # Increment counter at current level
+        current_counters = counter_stack.last || {}
+        current_counters[node.name] ||= 0
+        current_counters[node.name] += 1
+
+        # Build path using original backward logic (for correctness)
+        @node_id_cache[node] = build_node_path(node)
+      end
+    end
+
+    # Traverse tree, building paths with forward position counters
+    def traverse_with_forward_counting(node, path_parts, sibling_counters)
+      return unless node.respond_to?(:name) && node.name
+
+      # Increment counter for this node name at current level
+      sibling_counters[node.name] ||= 0
+      sibling_counters[node.name] += 1
+      position = sibling_counters[node.name]
+
+      # Build and cache path
+      current_path = path_parts + ["#{node.name}[#{position}]"]
+      @node_id_cache[node] = "/#{current_path.join('/')}"
+
+      # Traverse children with fresh counters
+      if node.respond_to?(:children)
+        child_counters = {}
+        node.children.each do |child|
+          traverse_with_forward_counting(child, current_path, child_counters)
+        end
+      end
+    end
+
+    # Build path-based ID for a node (original logic, unchanged)
+    def build_node_path(node)
       path_parts = []
       current = node
 
       while current
         if current.respond_to?(:name) && current.name
-          # Count previous siblings of the same type for position
+          # Count previous siblings of the same type for position (ORIGINAL LOGIC)
           position = 1
           if current.respond_to?(:previous_sibling)
             sibling = current.previous_sibling

data/lib/svg_conform/validator.rb

@@ -9,6 +9,7 @@ module SvgConform
       @options = {
         fix: false,
         strict: false,
+        mode: :sax, # Testing SAX mode
       }.merge(options)
     end
 
@@ -19,17 +20,31 @@ module SvgConform
               "File not found: #{file_path}"
       end
 
-      document = Document.from_file(file_path)
-      validate_document(document, profile: profile, **options)
+      merged_options = @options.merge(options)
+      mode = determine_mode(file_path, merged_options[:mode])
+
+      case mode
+      when :sax
+        validate_file_sax(file_path, profile: profile, **merged_options)
+      when :dom
+        validate_file_dom(file_path, profile: profile, **merged_options)
+      end
     end
 
     # Validate SVG content string
     def validate(svg_content, profile: :svg_1_2_rfc, **options)
-      document = Document.from_content(svg_content)
-      validate_document(document, profile: profile, **options)
+      merged_options = @options.merge(options)
+      mode = merged_options[:mode] == :sax ? :sax : :dom
+
+      case mode
+      when :sax
+        validate_content_sax(svg_content, profile: profile, **merged_options)
+      when :dom
+        validate_content_dom(svg_content, profile: profile, **merged_options)
+      end
     end
 
-    # Validate a Document object
+    # Validate a Document object (DOM only)
     def validate_document(document, profile: :svg_1_2_rfc, **options)
       merged_options = @options.merge(options)
       profile_obj = resolve_profile(profile)
@@ -64,6 +79,59 @@ module SvgConform
 
     private
 
+    def determine_mode(file_path, requested_mode)
+      case requested_mode
+      when :sax
+        :sax
+      when :dom
+        :dom
+      when :auto
+        # Use SAX for files larger than 1MB
+        file_size = File.size(file_path)
+        file_size > 1_000_000 ? :sax : :dom
+      else
+        :dom
+      end
+    end
+
+    def validate_file_sax(file_path, profile:, **options)
+      profile_obj = resolve_profile(profile)
+      sax_doc = SvgConform::SaxDocument.from_file(file_path)
+      result = sax_doc.validate_with_profile(profile_obj)
+
+      # If fixing is requested, convert to DOM and apply fixes
+      if options[:fix] && result.has_errors?
+        dom_doc = SvgConform::Document.from_file(file_path)
+        result = validate_document(dom_doc, profile: profile_obj, **options)
+      end
+
+      result
+    end
+
+    def validate_file_dom(file_path, profile:, **options)
+      document = SvgConform::Document.from_file(file_path)
+      validate_document(document, profile: profile, **options)
+    end
+
+    def validate_content_sax(content, profile:, **options)
+      profile_obj = resolve_profile(profile)
+      sax_doc = SvgConform::SaxDocument.from_content(content)
+      result = sax_doc.validate_with_profile(profile_obj)
+
+      # If fixing is requested, convert to DOM and apply fixes
+      if options[:fix] && result.has_errors?
+        dom_doc = SvgConform::Document.from_content(content)
+        result = validate_document(dom_doc, profile: profile_obj, **options)
+      end
+
+      result
+    end
+
+    def validate_content_dom(content, profile:, **options)
+      document = SvgConform::Document.from_content(content)
+      validate_document(document, profile: profile, **options)
+    end
+
     def resolve_profile(profile)
       case profile
       when Symbol, String

data/lib/svg_conform/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SvgConform
-  VERSION = "0.1.1"
+  VERSION = "0.1.3"
 end

data/lib/svg_conform.rb

@@ -11,6 +11,7 @@ end
 
 require_relative "svg_conform/version"
 require_relative "svg_conform/document"
+require_relative "svg_conform/sax_document"
 require_relative "svg_conform/validation_context"
 require_relative "svg_conform/validation_result"
 require_relative "svg_conform/profiles"

data/spec/spec_helper.rb

@@ -3,6 +3,9 @@
 require "svg_conform"
 require "canon"
 
+# Load shared examples
+Dir[File.expand_path("support/**/*.rb", __dir__)].each { |f| require f }
+
 RSpec.configure do |config|
   # Enable flags like --only-failures and --next-failure
   config.example_status_persistence_file_path = ".rspec_status"

data/spec/support/shared_examples_for_validation_modes.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# Shared examples for testing both DOM and SAX validation modes
+RSpec.shared_examples "validates in both DOM and SAX modes" do |file_path, profile_name|
+  let(:file_path) { file_path }
+  let(:profile) { profile_name }
+
+  it "produces identical results in DOM and SAX modes" do
+    dom_result = SvgConform::Validator.new(mode: :dom).validate_file(file_path,
+                                                                     profile: profile)
+    sax_result = SvgConform::Validator.new(mode: :sax).validate_file(file_path,
+                                                                     profile: profile)
+
+    expect(sax_result.errors.size).to eq(dom_result.errors.size),
+                                      "SAX mode should produce same error count as DOM mode (DOM: #{dom_result.errors.size}, SAX: #{sax_result.errors.size})"
+
+    expect(sax_result.warnings.size).to eq(dom_result.warnings.size),
+                                        "SAX mode should produce same warning count as DOM mode"
+
+    expect(sax_result.valid?).to eq(dom_result.valid?),
+                                 "SAX mode should have same validity as DOM mode"
+  end
+
+  it "DOM mode validates correctly" do
+    result = SvgConform::Validator.new(mode: :dom).validate_file(file_path,
+                                                                 profile: profile)
+    expect(result).to be_a(SvgConform::ValidationResult)
+  end
+
+  it "SAX mode validates correctly" do
+    result = SvgConform::Validator.new(mode: :sax).validate_file(file_path,
+                                                                 profile: profile)
+    expect(result).to be_a(SvgConform::ValidationResult)
+  end
+
+  describe "performance comparison" do
+    it "SAX mode is faster than or equal to DOM mode" do
+      skip "Performance test - run manually for large files"
+
+      dom_time = Benchmark.realtime do
+        SvgConform::Validator.new(mode: :dom).validate_file(file_path,
+                                                            profile: profile)
+      end
+
+      sax_time = Benchmark.realtime do
+        SvgConform::Validator.new(mode: :sax).validate_file(file_path,
+                                                            profile: profile)
+      end
+
+      expect(sax_time).to be <= dom_time
+    end
+  end
+end
+
+RSpec.shared_examples "validates content in both modes" do |svg_content, profile_name|
+  let(:content) { svg_content }
+  let(:profile) { profile_name }
+
+  it "produces identical results for content validation" do
+    dom_result = SvgConform::Validator.new(mode: :dom).validate(content,
+                                                                profile: profile)
+    sax_result = SvgConform::Validator.new(mode: :sax).validate(content,
+                                                                profile: profile)
+
+    expect(sax_result.errors.size).to eq(dom_result.errors.size),
+                                      "SAX mode should produce same error count as DOM mode (DOM: #{dom_result.errors.size}, SAX: #{sax_result.errors.size})"
+
+    expect(sax_result.valid?).to eq(dom_result.valid?),
+                                 "SAX mode should have same validity as DOM mode"
+  end
+end