svg_conform 0.1.10 → 0.1.11

data/lib/svg_conform/sax_validation_handler.rb

@@ -8,21 +8,39 @@ require_relative "validation/structural_invalidity_tracker"
 require_relative "validation/node_id_manager"
 require_relative "validation_result"
 require_relative "references"
+require_relative "classification_cache"
 
 module SvgConform
   # SAX event handler for streaming SVG validation
   # Processes XML events and dispatches to requirements
+  #
+  # == Requirement classification
+  #
+  # The handler classifies requirements into two categories:
+  #
+  # 1. Immediate validation requirements (14) - validate during parsing
+  #    - These requirements implement +validate_sax_element+ and validate
+  #      each element as it is encountered
+  #    - No state is maintained between elements
+  #
+  # 2. Deferred validation requirements (3) - collect data, validate at end
+  #    - These requirements implement +collect_sax_data+ and +validate_sax_complete+
+  #    - State is stored in requirement-specific State classes via +context.state_for+
+  #    - Validation happens after parsing is complete, when all data is available
+  #
+  # == State management
+  #
+  # Each handler instance has its own cache and fresh requirement instances,
+  # ensuring no state leakage between validations.
+  #
+  # Profile reuse for multiple validations:
+  # - Profile is created once with requirement instances (configuration from YAML)
+  # - Each validation creates a fresh SaxValidationHandler with fresh ValidationContext
+  # - ValidationContext creates fresh State instances for deferred requirements
+  # - No state pollution occurs across validations
   class SaxValidationHandler < Nokogiri::XML::SAX::Document
     attr_reader :result, :context
 
-    # Class-level cache for requirement classifications by profile class
-    @classification_cache = {}
-    @classification_cache_mutex = Mutex.new
-
-    class << self
-      attr_reader :classification_cache, :classification_cache_mutex
-    end
-
     def initialize(profile)
       @profile = profile
       @element_stack = [] # Track parent-child hierarchy
@@ -31,18 +49,23 @@ module SvgConform
       @parse_errors = []
       @result = nil # Will be set in end_document
 
+      # Create instance-level cache (no shared state between handlers)
+      @classification_cache = ClassificationCache.new
+
+      # Use profile requirements directly (config is stateless)
+      # Validation state lives in context, not in requirements
+      @requirements = @profile.requirements || []
+
       # Create validation context (without document reference for SAX)
       @context = create_sax_context
 
-      # Classify requirements into immediate vs deferred (use cache if available)
+      # Classify requirements into immediate vs deferred (use instance cache)
       @immediate_requirements, @deferred_requirements = classify_requirements_with_cache
     end
 
     # SAX Event: Document start
     def start_document
-      # Reset state in requirements that maintain state across validations
-      reset_stateful_requirements
-
+      # No need to reset state - each validation has fresh requirement instances
       # Initialize root level counters
       @position_counters.push({})
     end
@@ -158,37 +181,21 @@ module SvgConform
       context.instance_variable_set(:@reference_manifest,
                                     trackers[:reference_manifest])
       context.instance_variable_set(:@fixes, [])
-      context.instance_variable_set(:@data, {})
+      context.instance_variable_set(:@state_registry, {})
       context
     end
 
-    # Classify requirements based on validation needs (with caching)
+    # Classify requirements based on validation needs (with instance-level caching)
     def classify_requirements_with_cache
-      profile_key = @profile.class.name
-      profile_requirements = @profile.requirements
-
-      # Check cache first (thread-safe)
-      @immediate_requirements = []
-      @deferred_requirements = []
+      profile_key = @profile.name || @profile.object_id.to_s
 
-      classified = self.class.classification_cache_mutex.synchronize do
-        self.class.classification_cache[profile_key]
-      end
-
-      if classified
-        @immediate_requirements = classified[:immediate].map do |req_class|
-          # Find the actual instance from profile requirements
-          profile_requirements.find { |r| r.is_a?(req_class) }
-        end.compact
-        @deferred_requirements = classified[:deferred].map do |req_class|
-          profile_requirements.find { |r| r.is_a?(req_class) }
-        end.compact
-      else
-        # Classify and cache
+      # Use instance-level cache (no mutexes needed - per-handler isolation)
+      @classification_cache.fetch(profile_key) do
+        # Classify by requirement classes
         immediate_classes = []
         deferred_classes = []
 
-        profile_requirements.each do |req|
+        @requirements.each do |req|
           if req.respond_to?(:needs_deferred_validation?) && req.needs_deferred_validation?
             deferred_classes << req.class
           else
@@ -196,45 +203,22 @@ module SvgConform
           end
         end
 
-        # Store in cache
-        self.class.classification_cache_mutex.synchronize do
-          self.class.classification_cache[profile_key] = {
-            immediate: immediate_classes,
-            deferred: deferred_classes,
-          }
-        end
-
-        @immediate_requirements = profile_requirements.select do |req|
-          immediate_classes.include?(req.class)
-        end
-        @deferred_requirements = profile_requirements.select do |req|
-          deferred_classes.include?(req.class)
-        end
+        # Cache the classification by class
+        { immediate: immediate_classes, deferred: deferred_classes }
       end
 
-      [@immediate_requirements, @deferred_requirements]
-    end
-
-    # Classify requirements based on validation needs
-    def classify_requirements
-      return unless @profile&.requirements
+      # Map back to actual requirement instances from @requirements
+      classified = @classification_cache.fetch(profile_key) { {} }
 
-      @profile.requirements.each do |req|
-        if req.respond_to?(:needs_deferred_validation?) && req.needs_deferred_validation?
-          @deferred_requirements << req
-        else
-          @immediate_requirements << req
-        end
+      immediate = classified[:immediate].flat_map do |req_class|
+        @requirements.select { |r| r.is_a?(req_class) }
       end
-    end
 
-    # Reset state in requirements that maintain state
-    def reset_stateful_requirements
-      return unless @profile&.requirements
-
-      @profile.requirements.each do |req|
-        req.reset_state if req.respond_to?(:reset_state)
+      deferred = classified[:deferred].flat_map do |req_class|
+        @requirements.select { |r| r.is_a?(req_class) }
       end
+
+      [immediate, deferred]
     end
   end
 end

data/lib/svg_conform/validation_context.rb

@@ -23,18 +23,56 @@ module SvgConform
   # - StructuralInvalidityTracker: tracks structurally invalid nodes
   # - NodeIdManager: handles node ID generation for both SAX and DOM modes
   # - ReferenceManifest: tracks ID definitions and references
+  # - State Registry: manages requirement-specific state for deferred validation
   #
-  # == Usage
+  # == Validation modes
+  #
+  # === DOM validation (remediation mode)
   #
-  # In DOM validation (remediation mode):
   #   context = ValidationContext.new(document, profile)
   #   requirement.validate_document(document, context)
   #
-  # In SAX validation (streaming mode):
+  # === SAX validation (streaming mode)
+  #
   #   context = ValidationContext.new(nil, profile)
   #   requirement.validate_sax_element(element, context)
   #
-  # == Error Reporting
+  # == State management for deferred validation
+  #
+  # Requirements that need deferred validation (collecting data during SAX parsing
+  # and validating at document end) use requirement-specific State classes:
+  #
+  #   class MyRequirement < BaseRequirement
+  #     class State
+  #       attr_accessor :collected_items
+  #
+  #       def initialize
+  #         @collected_items = []
+  #       end
+  #     end
+  #
+  #     def collect_sax_data(element, context)
+  #       state = context.state_for(self)
+  #       state.collected_items << extract_from(element)
+  #     end
+  #
+  #     def validate_sax_complete(context)
+  #       state = context.state_for(self)
+  #       # Validate state.collected_items
+  #     end
+  #   end
+  #
+  # The +state_for+ method:
+  # - Returns a State instance specific to the requirement class
+  # - Creates the State instance on first access (lazy initialization)
+  # - Maintains one State instance per requirement class per validation
+  # - Prevents state pollution when reusing profiles across validations
+  #
+  # Each validation gets a fresh ValidationContext with a fresh state registry,
+  # ensuring that reusing the same Profile for multiple validations doesn't leak
+  # state between validations.
+  #
+  # == Error reporting
   #
   #   context.add_error(
   #     requirement_id: id,
@@ -44,13 +82,13 @@ module SvgConform
   #     fix: -> { remove_element(node) }
   #   )
   #
-  # == Node ID Tracking
+  # == Node ID tracking
   #
   # The context generates unique node IDs for tracking:
   # - SAX mode: uses pre-computed path_id from ElementProxy
   # - DOM mode: uses DocumentAnalyzer with forward-counting algorithm
   #
-  # == Structural Invalidity
+  # == Structural invalidity
   #
   # Requirements can mark nodes as structurally invalid (e.g., invalid
   # parent-child relationships). Other requirements should skip
@@ -58,7 +96,6 @@ module SvgConform
   #
   #   context.mark_node_structurally_invalid(node)
   #   context.node_structurally_invalid?(node) # => true
-  #
   class ValidationContext
     # The document being validated (nil in SAX mode)
     attr_reader :document
@@ -101,7 +138,13 @@ module SvgConform
       @reference_manifest = trackers[:reference_manifest]
 
       @fixes = []
-      @data = {}
+      @state_registry = {} # Maps requirement class => state instance
+    end
+
+    # Get or create state for a requirement
+    # Each requirement gets its own state instance, preventing state pollution
+    def state_for(requirement)
+      @state_registry[requirement.class] ||= requirement.class::State.new
     end
 
     # Mark a node as structurally invalid (e.g., invalid parent-child relationship)
@@ -164,14 +207,6 @@ requirement_id: nil, severity: nil, fix: nil, data: {})
       (@error_tracker.errors + @error_tracker.warnings).count(&:fixable?)
     end
 
-    def set_data(key, value)
-      @data[key] = value
-    end
-
-    def get_data(key)
-      @data[key]
-    end
-
     # Register an ID definition
     def register_id(id_value, element_name:, line_number: nil,
 column_number: nil)

data/lib/svg_conform/version.rb

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

data/spec/fixtures/svg_1_2_rfc/expected_errors/ietf_test_violations.yml

@@ -0,0 +1,47 @@
+# Expected errors for IETF-test.svg validation against svg_1_2_rfc profile
+# Based on diagnostic results from script/diagnose_dom_mode.rb
+
+description: "IETF-test.svg from metanorma-standoc - contains rgb(0,0,0) colors and style properties that should be promoted"
+
+# Total errors expected: 18
+total_errors: 18
+
+# Errors by requirement
+requirements:
+  color_restrictions:
+    total: 3
+    errors:
+      - message: "Color 'rgb(0,0,0)' in style property 'stroke' is not allowed in this profile"
+        count: 2
+      - message: "Color 'rgb(0,0,0)' in style property 'fill' is not allowed in this profile"
+        count: 1
+
+  style_promotion:
+    total: 15
+    errors:
+      - message: "Style property 'stroke' can be promoted to attribute"
+        count: 4
+      - message: "Style property 'stroke-width' can be promoted to attribute"
+        count: 2
+      - message: "Style property 'fill' can be promoted to attribute"
+        count: 6
+      - message: "Style property 'font-family' can be promoted to attribute"
+        count: 1
+      - message: "Style property 'font-size' can be promoted to attribute"
+        count: 1
+
+# Remediation expectations
+# Note: Remediation promotes styles to attributes (e.g., stroke="black") rather than
+# modifying the style attribute content (e.g., style="stroke:black")
+remediation:
+  before_errors: 18
+  after_errors: 1
+  expected_changes: 18
+  expected_remediations:
+    - color_conversion
+    - style_promotion
+  # After remediation, expect attributes like stroke="black" instead of style="stroke:rgb(0,0,0)"
+  expected_attributes:
+    - stroke: 4  # Promoted from style
+    - stroke-width: 2  # Promoted from style
+    - fill: 6  # Promoted from style (some were already fill="none")

data/spec/fixtures/svg_1_2_rfc/inputs/ietf_test_violations.svg

@@ -0,0 +1,28 @@
+<svg xmlns="http://www.w3.org/2000/svg" fill-rule="evenodd" preserveAspectRatio="xMidYMid" version="1.1" viewBox="0 0 28000 21000">
+  <g class="Drawing" id="Straight_Connector_42">
+    <g>
+      <g style="stroke:rgb(0,0,0);stroke-width:88;fill:none">
+	<path d="M 4264,13886 L 4264,17273" style="fill:none" />
+  </g></g></g>
+  <g class="Drawing" id="Straight_Connector_33">
+    <g>
+      <g style="stroke:rgb(0,0,0);stroke-width:88;fill:none">
+	<path d="M 20355,10711 L 20351,13886" style="fill:none" />
+  </g></g></g>
+    <g class="Drawing">
+      <g>
+	<g style="stroke:none;fill:none">
+	  <rect height="3490" width="25184" x="1512" y="340" />
+	</g>
+      <g style="font-family:Arial embedded;font-size:1552px;font-weight:400">
+	<g style="stroke:none;fill:rgb(0,0,0)">
+	  <text>
+	    <tspan x="4733 5855 6718 7582 8446 8877 9741 10605 11036 12074 12853 13716 14580 15443 15960 16307 17171 17602 18724 19071 19935 20799 21315 22179 " y="2482">
+	      Updated Scenario Diagram
+	    </tspan>
+	  </text>
+	</g>
+      </g>
+      </g>
+    </g>
+</svg>

data/spec/spec_helper.rb

@@ -24,11 +24,6 @@ RSpec.configure do |config|
       SvgConform::Requirements::AllowedElementsRequirement.configuration_validation_cache.clear
     end
 
-    # Clear SaxValidationHandler classification cache
-    if defined?(SvgConform::SaxValidationHandler)
-      SvgConform::SaxValidationHandler.classification_cache.clear
-    end
-
     # Clear ProfileCompiler compile cache
     if defined?(SvgConform::ProfileCompiler)
       SvgConform::ProfileCompiler.compile_cache.clear

data/spec/svg_conform/profiles/svg_1_2_rfc_profile_spec.rb

@@ -8,6 +8,26 @@ RSpec.describe "SVG 1.2 RFC Profile" do
   let(:svg_1_2_rfc_profile_path) { "config/profiles/svg_1_2_rfc.yml" }
   let(:fixtures_base_dir) { "spec/fixtures" }
 
+  # Helper module for grouping and analyzing errors (namespaced to avoid global pollution)
+  module SpecHelpers
+    def self.group_errors_by_requirement(validation_result)
+      validation_result.errors.each_with_object({}) do |error, hash|
+        req_id = error.requirement_id || "unknown"
+        hash[req_id] ||= []
+        hash[req_id] << error
+      end
+    end
+
+    def self.count_style_properties(style_errors)
+      style_errors.each_with_object({}) do |error, hash|
+        if error.message =~ /Style property '([-\w]+)' can be promoted/
+          hash[$1] ||= 0
+          hash[$1] += 1
+        end
+      end
+    end
+  end
+
   describe "profile loading" do
     it "loads the SVG 1.2 RFC profile successfully" do
       profile = SvgConform::Profile.load_from_file(svg_1_2_rfc_profile_path)
@@ -197,4 +217,134 @@ RSpec.describe "SVG 1.2 RFC Profile" do
       puts "Comprehensive test: #{initial_result.errors.count} → #{final_result.errors.count} violations"
     end
   end
+
+  describe "IETF-test.svg (issue #75)" do
+    let(:ietf_test_file) do
+      "spec/fixtures/svg_1_2_rfc/inputs/ietf_test_violations.svg"
+    end
+
+    before do
+      skip "IETF-test fixture not found" unless File.exist?(ietf_test_file)
+    end
+
+    it "validates IETF-test.svg and detects expected violations" do
+      document = SvgConform::Document.from_file(ietf_test_file)
+      profile = SvgConform::Profile.load_from_file(svg_1_2_rfc_profile_path)
+      validation_result = profile.validate(document)
+      errors_by_requirement = SpecHelpers.group_errors_by_requirement(validation_result)
+
+      # Should detect violations
+      expect(validation_result.valid?).to be false
+
+      # Should have exactly 18 errors (3 color + 15 style promotion)
+      expect(validation_result.errors.count).to eq(18)
+
+      # Check color_restrictions errors
+      color_errors = errors_by_requirement["color_restrictions"] || []
+      expect(color_errors.count).to eq(3)
+
+      # Check style_promotion errors
+      style_errors = errors_by_requirement["style_promotion"] || []
+      expect(style_errors.count).to eq(15)
+
+      puts "IETF-test.svg validation: #{validation_result.errors.count} errors detected"
+      puts "  Color errors: #{color_errors.count}"
+      puts "  Style promotion errors: #{style_errors.count}"
+    end
+
+    it "validates IETF-test.svg color violations in detail" do
+      document = SvgConform::Document.from_file(ietf_test_file)
+      profile = SvgConform::Profile.load_from_file(svg_1_2_rfc_profile_path)
+      validation_result = profile.validate(document)
+      errors_by_requirement = SpecHelpers.group_errors_by_requirement(validation_result)
+      color_errors = errors_by_requirement["color_restrictions"] || []
+
+      color_stroke_errors = color_errors.select do |e|
+        e.message.include?("stroke")
+      end
+      color_fill_errors = color_errors.select { |e| e.message.include?("fill") }
+
+      expect(color_stroke_errors.count).to eq(2)
+      expect(color_fill_errors.count).to eq(1)
+    end
+
+    it "validates IETF-test.svg style promotion violations in detail" do
+      document = SvgConform::Document.from_file(ietf_test_file)
+      profile = SvgConform::Profile.load_from_file(svg_1_2_rfc_profile_path)
+      validation_result = profile.validate(document)
+      errors_by_requirement = SpecHelpers.group_errors_by_requirement(validation_result)
+      style_errors = errors_by_requirement["style_promotion"] || []
+      style_props = SpecHelpers.count_style_properties(style_errors)
+
+      expect(style_props["stroke"]).to eq(4)
+      expect(style_props["stroke-width"]).to eq(2)
+      expect(style_props["fill"]).to eq(6)
+      expect(style_props["font-family"]).to eq(1)
+      expect(style_props["font-size"]).to eq(1)
+    end
+
+    it "applies remediations to IETF-test.svg and reduces errors" do
+      document = SvgConform::Document.from_file(ietf_test_file)
+      profile = SvgConform::Profile.load_from_file(svg_1_2_rfc_profile_path)
+      initial_result = profile.validate(document)
+      initial_error_count = initial_result.errors.count
+
+      # Apply all remediations
+      changes = profile.apply_remediations(document)
+
+      # Get final error count
+      final_result = profile.validate(document)
+      final_error_count = final_result.errors.count
+
+      # Verify remediation was applied
+      expect(changes.count).to be > 0
+
+      # Verify errors were reduced
+      expect(final_error_count).to be < initial_error_count
+
+      # Verify specific error reduction
+      expect(initial_error_count).to eq(18)
+      expect(final_error_count).to eq(1)
+
+      # Verify specific remediations were applied
+      color_changes = changes.select do |c|
+        c[:type] == :attribute_modified || c[:message]&.include?("color")
+      end
+      style_promotion_changes = changes.select do |c|
+        c[:type] == :style_promotion || c[:message]&.include?("promoted")
+      end
+
+      expect(color_changes.count).to be > 0
+      expect(style_promotion_changes.count).to be > 0
+
+      puts "IETF-test.svg remediation: #{initial_error_count} → #{final_error_count} errors"
+      puts "  Total changes: #{changes.count}"
+      puts "    - Color conversion: #{color_changes.count}"
+      puts "    - Style promotion: #{style_promotion_changes.count}"
+    end
+
+    it "produces valid XML after remediation" do
+      document = SvgConform::Document.from_file(ietf_test_file)
+      profile = SvgConform::Profile.load_from_file(svg_1_2_rfc_profile_path)
+
+      # Apply remediations
+      profile.apply_remediations(document)
+
+      # Should still be valid XML
+      xml = document.to_xml
+      expect(xml).to match(/<svg\s+[^>]*>.*<\/svg>/m)
+
+      # Should maintain root element structure
+      expect(document.root.name).to eq("svg")
+
+      # Check for promoted stroke attributes (from style promotion)
+      expect(xml).to include('stroke="black"')
+
+      # Check for stroke-width attributes (from style promotion)
+      expect(xml).to include('stroke-width="88"')
+
+      # Check for fill attributes (from both color conversion and style promotion)
+      expect(xml).to include('fill="black"').or(include('fill="none"'))
+    end
+  end
 end