svg_conform 0.1.10 → 0.1.11

data/spec/svg_conform/validation_context_spec.rb

@@ -0,0 +1,305 @@
+# frozen_string_literal: true
+
+RSpec.describe SvgConform::ValidationContext do
+  let(:document) { nil }
+  let(:profile) { instance_double(SvgConform::Profile) }
+  let(:context) { described_class.new(document, profile) }
+
+  describe "#state_for" do
+    # Create test requirement with nested State class
+    let(:requirement_with_state) do
+      req_class = Class.new(SvgConform::Requirements::BaseRequirement) do
+        def id
+          "test_requirement"
+        end
+      end
+
+      # Define State class as a proper constant
+      req_class.const_set(:State, Class.new do
+        attr_accessor :collected_items
+
+        def initialize
+          @collected_items = []
+        end
+      end)
+
+      req_class.new
+    end
+
+    it "creates a fresh State instance on first access" do
+      state = context.state_for(requirement_with_state)
+      expect(state).to be_a(requirement_with_state.class::State)
+      expect(state.collected_items).to eq([])
+    end
+
+    it "returns the same State instance on subsequent accesses for same requirement class" do
+      state1 = context.state_for(requirement_with_state)
+      state1.collected_items << "item1"
+      state2 = context.state_for(requirement_with_state)
+      expect(state2).to be(state1)
+      expect(state2.collected_items).to eq(["item1"])
+    end
+
+    it "creates separate State instances for different requirement classes" do
+      req1_class = Class.new(SvgConform::Requirements::BaseRequirement) do
+        def id
+          "req1"
+        end
+      end
+      req1_class.const_set(:State, Class.new do
+        attr_accessor :data
+
+        def initialize
+          @data = []
+        end
+      end)
+
+      req2_class = Class.new(SvgConform::Requirements::BaseRequirement) do
+        def id
+          "req2"
+        end
+      end
+      req2_class.const_set(:State, Class.new do
+        attr_accessor :items
+
+        def initialize
+          @items = []
+        end
+      end)
+
+      req1 = req1_class.new
+      req2 = req2_class.new
+
+      state1 = context.state_for(req1)
+      state2 = context.state_for(req1)
+      state3 = context.state_for(req2)
+
+      expect(state1).to be(state2)
+      expect(state1).not_to be(state3)
+      expect(state2).not_to be(state3)
+    end
+
+    it "uses requirement class as key, not instance" do
+      req1_instance1 = requirement_with_state
+      req1_instance2 = requirement_with_state.class.new
+
+      state1 = context.state_for(req1_instance1)
+      state1.collected_items << "from_instance1"
+
+      state2 = context.state_for(req1_instance2)
+
+      # Both instances of the same requirement class should share state
+      expect(state1).to be(state2)
+      expect(state2.collected_items).to eq(["from_instance1"])
+    end
+
+    context "with requirement that lacks nested State class" do
+      let(:requirement_without_state) do
+        Class.new(SvgConform::Requirements::BaseRequirement) do
+          def id
+            "no_state_requirement"
+          end
+        end.new
+      end
+
+      it "raises an error when State class is not defined" do
+        expect do
+          context.state_for(requirement_without_state)
+        end.to raise_error(NameError, /uninitialized constant.*State/)
+      end
+    end
+  end
+
+  describe "state lifecycle" do
+    let(:requirement_class) do
+      req_class = Class.new(SvgConform::Requirements::BaseRequirement) do
+        def id
+          "counter_requirement"
+        end
+      end
+
+      req_class.const_set(:State, Class.new do
+        attr_accessor :counter
+
+        def initialize
+          @counter = 0
+        end
+      end)
+
+      req_class
+    end
+
+    it "creates fresh state for each validation context instance" do
+      requirement = requirement_class.new
+
+      context1 = described_class.new(nil, profile)
+      state1 = context1.state_for(requirement)
+      state1.counter = 42
+
+      context2 = described_class.new(nil, profile)
+      state2 = context2.state_for(requirement)
+
+      # Different contexts should have different state instances
+      expect(state1).not_to be(state2)
+      expect(state2.counter).to eq(0)
+    end
+
+    it "prevents state pollution across validations" do
+      requirement = requirement_class.new
+
+      # First validation
+      context1 = described_class.new(nil, profile)
+      state1 = context1.state_for(requirement)
+      state1.counter = 100
+
+      # Second validation with same profile
+      context2 = described_class.new(nil, profile)
+      state2 = context2.state_for(requirement)
+
+      # State should be fresh, not polluted by first validation
+      expect(state2.counter).to eq(0)
+    end
+  end
+
+  describe "#node_structurally_invalid?" do
+    it "returns false for nodes not marked as structurally invalid" do
+      # In SAX mode (document = nil), simple objects return nil from node_id generator
+      node = Object.new
+      expect(context.node_structurally_invalid?(node)).to be false
+    end
+  end
+
+  describe "#mark_node_structurally_invalid" do
+    it "marks a node as structurally invalid" do
+      # Use a node-like object with a stable path_id for tracking
+      node = Object.new
+      def node.path_id
+        "test_node_1"
+      end
+
+      context.mark_node_structurally_invalid(node)
+      # After marking, the node should be tracked as structurally invalid
+      expect(context.node_structurally_invalid?(node)).to be true
+    end
+  end
+
+  describe "#register_id" do
+    it "registers an ID in the reference manifest" do
+      context.register_id("test_id", element_name: "svg", line_number: 1,
+                                     column_number: 1)
+      expect(context.id_defined?("test_id")).to be true
+    end
+  end
+
+  describe "#register_reference" do
+    it "registers a reference in the manifest" do
+      # Use a concrete reference type
+      reference = SvgConform::References::InternalFragmentReference.new(
+        value: "#target",
+        element_name: "use",
+        attribute_name: "href",
+        line_number: 1,
+        column_number: 1,
+      )
+
+      context.register_reference(reference)
+      # Verify reference was added - the manifest should now track this reference
+      expect(context.reference_manifest).to be_a(SvgConform::References::ReferenceManifest)
+    end
+  end
+
+  describe "#id_defined?" do
+    it "returns false for undefined IDs" do
+      expect(context.id_defined?("nonexistent")).to be false
+    end
+
+    it "returns true for registered IDs" do
+      context.register_id("test_id", element_name: "svg")
+      expect(context.id_defined?("test_id")).to be true
+    end
+  end
+
+  describe "#add_error" do
+    it "adds an error to the context" do
+      node = Object.new
+      context.add_error(
+        node: node,
+        message: "test error",
+        requirement_id: "test",
+      )
+
+      expect(context.has_errors?).to be true
+      expect(context.errors.first.message).to eq("test error")
+    end
+  end
+
+  describe "#add_warning" do
+    it "adds a warning to the context" do
+      node = Object.new
+      context.add_warning(
+        rule: "test_rule",
+        node: node,
+        message: "test warning",
+      )
+
+      expect(context.has_warnings?).to be true
+      expect(context.warnings.first.message).to eq("test warning")
+    end
+  end
+
+  describe "#add_notice" do
+    it "adds a notice to the context" do
+      node = Object.new
+      context.add_notice(
+        rule: "test_rule",
+        node: node,
+        message: "test notice",
+      )
+
+      expect(context.infos.first.message).to eq("test notice")
+    end
+  end
+
+  describe "#has_errors?" do
+    it "returns false when no errors" do
+      expect(context.has_errors?).to be false
+    end
+
+    it "returns true when errors are added" do
+      node = Object.new
+      context.add_error(node: node, message: "error", requirement_id: "test")
+      expect(context.has_errors?).to be true
+    end
+  end
+
+  describe "#has_warnings?" do
+    it "returns false when no warnings" do
+      expect(context.has_warnings?).to be false
+    end
+
+    it "returns true when warnings are added" do
+      node = Object.new
+      context.add_warning(rule: "test", node: node, message: "warning")
+      expect(context.has_warnings?).to be true
+    end
+  end
+
+  describe "#add_fix" do
+    it "stores fix in fixes array" do
+      fix = -> { "some action" }
+      context.add_fix(fix)
+      expect(context.fixes).to eq([fix])
+    end
+  end
+
+  describe "#has_fixes?" do
+    it "returns false when no fixes" do
+      expect(context.has_fixes?).to be false
+    end
+
+    it "returns true when fixes are added" do
+      context.add_fix(-> { "action" })
+      expect(context.has_fixes?).to be true
+    end
+  end
+end

data/spec/svg_conform_spec.rb

@@ -29,4 +29,160 @@ RSpec.describe SvgConform do
     expect(css_profile).not_to be_nil
     expect(css_profile.requirements).not_to be_empty
   end
+
+  describe "profile switching without state leakage" do
+    let(:svg_with_invalid_ref) do
+      <<~SVG
+        <?xml version="1.0" encoding="UTF-8"?>
+        <svg xmlns="http://www.w3.org/2000/svg" version="1.2" viewBox="0 0 100 100">
+          <defs>
+            <rect id="valid-rect" width="10" height="10"/>
+          </defs>
+          <use href="#valid-rect" x="10" y="10"/>
+          <use href="#invalid-rect" x="20" y="20"/>
+        </svg>
+      SVG
+    end
+
+    it "maintains consistent validation results when switching between profiles" do
+      validator = SvgConform::Validator.new(mode: :sax)
+
+      # First validation with metanorma profile
+      profile_meta = SvgConform::Profiles.get("metanorma")
+      result_meta1 = validator.validate(svg_with_invalid_ref,
+                                        profile: profile_meta)
+      first_meta_count = result_meta1.errors.count
+
+      # Validation with svg_1_2_rfc profile
+      profile_rfc = SvgConform::Profiles.get("svg_1_2_rfc")
+      result_rfc1 = validator.validate(svg_with_invalid_ref,
+                                       profile: profile_rfc)
+      first_rfc_count = result_rfc1.errors.count
+
+      # Second validation with metanorma profile (should match first)
+      result_meta2 = validator.validate(svg_with_invalid_ref,
+                                        profile: profile_meta)
+      second_meta_count = result_meta2.errors.count
+
+      # Second validation with svg_1_2_rfc profile (should match first)
+      result_rfc2 = validator.validate(svg_with_invalid_ref,
+                                       profile: profile_rfc)
+      second_rfc_count = result_rfc2.errors.count
+
+      # Verify consistency - no state leakage between profiles
+      expect(first_meta_count).to eq(second_meta_count),
+                                  "metanorma profile should return consistent results (#{first_meta_count} vs #{second_meta_count})"
+
+      expect(first_rfc_count).to eq(second_rfc_count),
+                                 "svg_1_2_rfc profile should return consistent results (#{first_rfc_count} vs #{second_rfc_count})"
+    end
+
+    it "properly resets requirement state between validations" do
+      # This test specifically verifies that requirement state is reset
+      # by validating the same content multiple times
+      validator = SvgConform::Validator.new(mode: :sax)
+      profile = SvgConform::Profiles.get("svg_1_2_rfc")
+
+      results = []
+      3.times do
+        result = validator.validate(svg_with_invalid_ref, profile: profile)
+        results << result.errors.count
+      end
+
+      # All runs should produce the same error count
+      expect(results.uniq.size).to eq(1),
+                                   "All validation runs should produce identical results: #{results.inspect}"
+    end
+
+    it "handles interleaved profile validations correctly" do
+      validator = SvgConform::Validator.new(mode: :sax)
+
+      profile_meta = SvgConform::Profiles.get("metanorma")
+      profile_rfc = SvgConform::Profiles.get("svg_1_2_rfc")
+
+      # Interleave validations
+      results = []
+      results << [:meta,
+                  validator.validate(svg_with_invalid_ref,
+                                     profile: profile_meta).errors.count]
+      results << [:rfc,
+                  validator.validate(svg_with_invalid_ref,
+                                     profile: profile_rfc).errors.count]
+      results << [:meta,
+                  validator.validate(svg_with_invalid_ref,
+                                     profile: profile_meta).errors.count]
+      results << [:rfc,
+                  validator.validate(svg_with_invalid_ref,
+                                     profile: profile_rfc).errors.count]
+      results << [:meta,
+                  validator.validate(svg_with_invalid_ref,
+                                     profile: profile_meta).errors.count]
+
+      # Extract counts by profile
+      meta_counts = results.select { |type, _| type == :meta }.map(&:last)
+      rfc_counts = results.select { |type, _| type == :rfc }.map(&:last)
+
+      # Each profile should produce consistent results
+      expect(meta_counts.uniq.size).to eq(1),
+                                       "metanorma validations should be consistent: #{meta_counts.inspect}"
+      expect(rfc_counts.uniq.size).to eq(1),
+                                      "svg_1_2_rfc validations should be consistent: #{rfc_counts.inspect}"
+    end
+
+    it "returns different error counts for profiles with different requirements" do
+      # Real-world SVG with style attributes that violate svg_1_2_rfc but not metanorma
+      svg_with_styles = <<~SVG
+        <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>
+      SVG
+
+      validator = SvgConform::Validator.new(mode: :sax)
+
+      # Validate with metanorma (should have 0 errors - more permissive)
+      profile_meta = SvgConform::Profiles.get("metanorma")
+      result_meta = validator.validate(svg_with_styles, profile: profile_meta)
+      meta_errors = result_meta.errors.count
+
+      # Validate with svg_1_2_rfc (should have errors - stricter requirements)
+      profile_rfc = SvgConform::Profiles.get("svg_1_2_rfc")
+      result_rfc = validator.validate(svg_with_styles, profile: profile_rfc)
+      rfc_errors = result_rfc.errors.count
+
+      # Profiles should return different results
+      expect(meta_errors).to eq(0), "metanorma profile should allow this SVG"
+      expect(rfc_errors).to be > 0,
+                            "svg_1_2_rfc profile should detect violations"
+
+      # Verify consistency when repeating
+      result_rfc2 = validator.validate(svg_with_styles, profile: profile_rfc)
+      expect(result_rfc2.errors.count).to eq(rfc_errors),
+                                          "svg_1_2_rfc should return same error count on repeat (no state leakage)"
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: svg_conform
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 0.1.11
 platform: ruby
 authors:
 - Ribose
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-23 00:00:00.000000000 Z
+date: 2026-01-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -115,6 +115,7 @@ files:
 - exe/svg_conform
 - lib/svg_conform.rb
 - lib/svg_conform/batch_report.rb
+- lib/svg_conform/classification_cache.rb
 - lib/svg_conform/cli.rb
 - lib/svg_conform/commands/check.rb
 - lib/svg_conform/commands/profiles.rb
@@ -241,8 +242,10 @@ files:
 - spec/fixtures/style/repair/basic_violations.svg
 - spec/fixtures/style_promotion/inputs/basic_test.svg
 - spec/fixtures/style_promotion/repair/basic_test.svg
+- spec/fixtures/svg_1_2_rfc/expected_errors/ietf_test_violations.yml
 - spec/fixtures/svg_1_2_rfc/inputs/allowed_elements_violations.svg
 - spec/fixtures/svg_1_2_rfc/inputs/color_restrictions_violations.svg
+- spec/fixtures/svg_1_2_rfc/inputs/ietf_test_violations.svg
 - spec/fixtures/svgcheck/check/DrawBerry-sample-2.svg.code
 - spec/fixtures/svgcheck/check/DrawBerry-sample-2.svg.err
 - spec/fixtures/svgcheck/check/DrawBerry-sample-2.svg.out
@@ -445,6 +448,7 @@ files:
 - spec/svg_conform/requirements/style_promotion_requirement_spec.rb
 - spec/svg_conform/requirements/style_requirement_spec.rb
 - spec/svg_conform/requirements/viewbox_required_requirement_spec.rb
+- spec/svg_conform/validation_context_spec.rb
 - spec/svg_conform/validator_input_types_spec.rb
 - spec/svg_conform_spec.rb
 - spec/svgcheck_compatibility_spec.rb