svg_conform 0.1.4 → 0.1.5

data/spec/svg_conform/references/integration_spec.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Reference Manifest Integration" do
+  let(:validator) { SvgConform::Validator.new(profile: "metanorma") }
+
+  describe "complete reference manifest generation" do
+    let(:svg_content) do
+      <<~SVG
+        <svg xmlns="http://www.w3.org/2000/svg" version="1.2" baseProfile="tiny" viewBox="0 0 100 100">
+          <rect id="rect-1" x="0" y="0" width="100" height="100"/>
+          <circle id="circle-1" cx="50" cy="50" r="25"/>
+          <use href="#rect-1"/>
+          <use href="#missing-element"/>
+          <a href="urn:ietf:rfc:7996">RFC 7996</a>
+          <a href="https://www.example.com">Example</a>
+          <image href="data:image/png;base64,iVBORw0KGgo=" x="0" y="0" width="10" height="10"/>
+          <image href="./other.svg#fragment" x="0" y="0" width="10" height="10"/>
+        </svg>
+      SVG
+    end
+
+    it "builds complete manifest with IDs and references" do
+      result = validator.validate(svg_content)
+      manifest = result.reference_manifest
+
+      # Check IDs are collected
+      expect(manifest.available_ids.size).to eq(2)
+      expect(manifest.id_defined?("rect-1")).to be true
+      expect(manifest.id_defined?("circle-1")).to be true
+
+      # Check references are collected
+      expect(manifest.internal_references.size).to eq(3) # 2 uses + 1 data URI
+      expect(manifest.external_references.size).to eq(3) # 1 urn + 1 https + 1 relative
+
+      # Check statistics
+      stats = manifest.statistics
+      expect(stats[:total_ids]).to eq(2)
+      expect(stats[:total_references]).to eq(6)
+      expect(stats[:unresolved_internal]).to eq(1)
+    end
+
+    it "identifies unresolved internal references" do
+      result = validator.validate(svg_content)
+      manifest = result.reference_manifest
+
+      unresolved = manifest.unresolved_internal_references
+      expect(unresolved.size).to eq(1)
+      expect(unresolved.first.value).to eq("#missing-element")
+    end
+
+    it "groups references by type" do
+      result = validator.validate(svg_content)
+      manifest = result.reference_manifest
+
+      by_type = manifest.references_by_type
+      expect(by_type["InternalFragmentReference"].size).to eq(2) # 2 uses
+      expect(by_type["UrnReference"].size).to eq(1)
+      expect(by_type["ExternalUrlReference"].size).to eq(1)
+      expect(by_type["DataUriReference"].size).to eq(1)
+      expect(by_type["RelativePathReference"].size).to eq(1)
+    end
+
+    it "validates internal references but not external ones" do
+      result = validator.validate(svg_content)
+
+      # Should have errors for unresolved internal reference
+      internal_ref_errors = result.errors.select do |e|
+        e.message.include?("missing-element")
+      end
+      expect(internal_ref_errors).not_to be_empty
+
+      # Should NOT have errors for external references
+      external_ref_errors = result.errors.select do |e|
+        e.message.include?("urn:") || e.message.include?("https://")
+      end
+      expect(external_ref_errors).to be_empty
+    end
+  end
+
+  describe "ValidationResult convenience methods" do
+    let(:svg_content) do
+      <<~SVG
+        <svg xmlns="http://www.w3.org/2000/svg" version="1.2" baseProfile="tiny" viewBox="0 0 100 100">
+          <rect id="target"/>
+          <use href="#target"/>
+          <a href="urn:test">Test</a>
+        </svg>
+      SVG
+    end
+
+    it "provides convenient accessors" do
+      result = validator.validate(svg_content)
+
+      expect(result.available_ids.size).to eq(1)
+      expect(result.internal_references.size).to eq(1)
+      expect(result.external_references.size).to eq(1)
+      expect(result.has_external_references?).to be true
+      expect(result.unresolved_internal_references).to be_empty
+    end
+
+    it "exports manifest in different formats" do
+      result = validator.validate(svg_content)
+
+      yaml_export = result.export_manifest(format: :yaml)
+      expect(yaml_export).to be_a(String)
+      expect(yaml_export).to include("target")
+
+      json_export = result.export_manifest(format: :json)
+      expect(json_export).to be_a(String)
+      parsed = JSON.parse(json_export)
+      expect(parsed["available_ids"]).to be_an(Array)
+    end
+  end
+
+  describe "cross-document reference scenario" do
+    let(:svg_with_external_fragment) do
+      <<~SVG
+        <svg xmlns="http://www.w3.org/2000/svg" version="1.2" baseProfile="tiny" viewBox="0 0 100 100">
+          <rect id="local-element"/>
+          <use href="#local-element"/>
+          <use href="other-doc.svg#external-element"/>
+        </svg>
+      SVG
+    end
+
+    it "classifies external fragment references correctly" do
+      result = validator.validate(svg_with_external_fragment)
+      manifest = result.reference_manifest
+
+      # Local fragment should be internal
+      expect(manifest.internal_references.size).to eq(1)
+      expect(manifest.internal_references.first.value).to eq("#local-element")
+
+      # External fragment should be external (requires consumer validation)
+      expect(manifest.external_references.size).to eq(1)
+      external_ref = manifest.external_references.first
+      expect(external_ref).to be_a(SvgConform::References::RelativePathReference)
+      expect(external_ref.has_fragment?).to be true
+      expect(external_ref.fragment_component).to eq("external-element")
+    end
+  end
+
+  describe "reference statistics and querying" do
+    let(:complex_svg) do
+      <<~SVG
+        <svg xmlns="http://www.w3.org/2000/svg" version="1.2" baseProfile="tiny" viewBox="0 0 100 100">
+          <defs>
+            <linearGradient id="grad1">
+              <stop offset="0%" stop-color="red"/>
+            </linearGradient>
+            <clipPath id="clip1">
+              <rect x="0" y="0" width="50" height="50"/>
+            </clipPath>
+          </defs>
+          <rect id="rect1" fill="url(#grad1)" clip-path="url(#clip1)"/>
+          <use href="#rect1"/>
+          <use href="#rect1"/>
+          <a href="https://example.com">Link</a>
+        </svg>
+      SVG
+    end
+
+    it "tracks multiple references to same ID" do
+      result = validator.validate(complex_svg)
+      manifest = result.reference_manifest
+
+      rect1_refs = manifest.references_to_id("rect1")
+      expect(rect1_refs.size).to eq(2)
+    end
+
+    it "provides accurate statistics" do
+      result = validator.validate(complex_svg)
+      stats = result.reference_statistics
+
+      expect(stats[:total_ids]).to eq(3) # grad1, clip1, rect1
+      expect(stats[:internal_references]).to eq(2) # 2 uses
+      expect(stats[:external_references]).to eq(1) # 1 https
+      expect(stats[:unresolved_internal]).to eq(0)
+    end
+  end
+
+  describe "to_h includes reference manifest" do
+    let(:svg_content) do
+      <<~SVG
+        <svg xmlns="http://www.w3.org/2000/svg" version="1.2" baseProfile="tiny" viewBox="0 0 100 100">
+          <rect id="test"/>
+          <a href="urn:test">Test</a>
+        </svg>
+      SVG
+    end
+
+    it "includes manifest in hash representation" do
+      result = validator.validate(svg_content)
+      hash = result.to_h
+
+      expect(hash).to have_key(:reference_manifest)
+      manifest_data = hash[:reference_manifest]
+      expect(manifest_data).to have_key(:available_ids)
+      expect(manifest_data).to have_key(:internal_references)
+      expect(manifest_data).to have_key(:external_references)
+      expect(manifest_data).to have_key(:statistics)
+    end
+  end
+end

data/spec/svg_conform/references/reference_classifier_spec.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe SvgConform::References::ReferenceClassifier do
+  describe ".classify" do
+    it "classifies internal fragment references" do
+      ref = described_class.classify(
+        "#element-id",
+        element_name: "use",
+        attribute_name: "href",
+        line_number: 10,
+      )
+
+      expect(ref).to be_a(SvgConform::References::InternalFragmentReference)
+      expect(ref.value).to eq("#element-id")
+      expect(ref.internally_validatable?).to be true
+      expect(ref.requires_consumer_validation?).to be false
+      expect(ref.target_id).to eq("element-id")
+    end
+
+    it "classifies URN references" do
+      ref = described_class.classify(
+        "urn:ietf:rfc:7996",
+        element_name: "a",
+        attribute_name: "href",
+        line_number: 42,
+      )
+
+      expect(ref).to be_a(SvgConform::References::UrnReference)
+      expect(ref.value).to eq("urn:ietf:rfc:7996")
+      expect(ref.internally_validatable?).to be false
+      expect(ref.requires_consumer_validation?).to be true
+      expect(ref.namespace).to eq("ietf")
+    end
+
+    it "classifies external URL references (http)" do
+      ref = described_class.classify(
+        "http://www.example.com/resource",
+        element_name: "a",
+        attribute_name: "href",
+      )
+
+      expect(ref).to be_a(SvgConform::References::ExternalUrlReference)
+      expect(ref.requires_consumer_validation?).to be true
+      expect(ref.protocol).to eq("http")
+    end
+
+    it "classifies external URL references (https)" do
+      ref = described_class.classify(
+        "https://www.example.com/resource",
+        element_name: "a",
+        attribute_name: "href",
+      )
+
+      expect(ref).to be_a(SvgConform::References::ExternalUrlReference)
+      expect(ref.requires_consumer_validation?).to be true
+      expect(ref.protocol).to eq("https")
+    end
+
+    it "classifies data URI references" do
+      ref = described_class.classify(
+        "data:image/png;base64,iVBORw0KGgo=",
+        element_name: "image",
+        attribute_name: "href",
+      )
+
+      expect(ref).to be_a(SvgConform::References::DataUriReference)
+      expect(ref.internally_validatable?).to be true
+      expect(ref.media_type).to eq("image/png")
+    end
+
+    it "classifies relative path references starting with ./" do
+      ref = described_class.classify(
+        "./other-doc.svg#element",
+        element_name: "use",
+        attribute_name: "href",
+      )
+
+      expect(ref).to be_a(SvgConform::References::RelativePathReference)
+      expect(ref.requires_consumer_validation?).to be true
+      expect(ref.has_fragment?).to be true
+      expect(ref.path_component).to eq("./other-doc.svg")
+      expect(ref.fragment_component).to eq("element")
+    end
+
+    it "classifies relative path references starting with /" do
+      ref = described_class.classify(
+        "/absolute/path.svg",
+        element_name: "use",
+        attribute_name: "href",
+      )
+
+      expect(ref).to be_a(SvgConform::References::RelativePathReference)
+      expect(ref.requires_consumer_validation?).to be true
+    end
+
+    it "classifies bare paths as relative references" do
+      ref = described_class.classify(
+        "other-doc.svg",
+        element_name: "use",
+        attribute_name: "href",
+      )
+
+      expect(ref).to be_a(SvgConform::References::RelativePathReference)
+      expect(ref.requires_consumer_validation?).to be true
+    end
+
+    it "returns nil for nil value" do
+      ref = described_class.classify(
+        nil,
+        element_name: "use",
+        attribute_name: "href",
+      )
+
+      expect(ref).to be_nil
+    end
+
+    it "returns nil for empty value" do
+      ref = described_class.classify(
+        "",
+        element_name: "use",
+        attribute_name: "href",
+      )
+
+      expect(ref).to be_nil
+    end
+
+    it "captures line and column information" do
+      ref = described_class.classify(
+        "#element-id",
+        element_name: "use",
+        attribute_name: "href",
+        line_number: 42,
+        column_number: 15,
+      )
+
+      expect(ref.line_number).to eq(42)
+      expect(ref.column_number).to eq(15)
+    end
+  end
+end

data/spec/svg_conform/references/reference_manifest_spec.rb

@@ -0,0 +1,307 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe SvgConform::References::ReferenceManifest do
+  let(:manifest) { described_class.new(source_document: "test.svg") }
+
+  describe "#initialize" do
+    it "creates an empty manifest" do
+      expect(manifest.source_document).to eq("test.svg")
+      expect(manifest.available_ids).to be_empty
+      expect(manifest.internal_references).to be_empty
+      expect(manifest.external_references).to be_empty
+    end
+  end
+
+  describe "#register_id" do
+    it "registers ID definitions" do
+      manifest.register_id("element-1", element_name: "rect", line_number: 10)
+
+      expect(manifest.available_ids.size).to eq(1)
+      expect(manifest.available_ids.first.id_value).to eq("element-1")
+      expect(manifest.available_ids.first.element_name).to eq("rect")
+      expect(manifest.available_ids.first.line_number).to eq(10)
+    end
+
+    it "registers multiple IDs" do
+      manifest.register_id("id-1", element_name: "rect")
+      manifest.register_id("id-2", element_name: "circle")
+
+      expect(manifest.available_ids.size).to eq(2)
+    end
+  end
+
+  describe "#register_reference" do
+    it "separates internal and external references" do
+      internal_ref = SvgConform::References::InternalFragmentReference.new(
+        value: "#element-1",
+        element_name: "use",
+        attribute_name: "href",
+      )
+
+      external_ref = SvgConform::References::UrnReference.new(
+        value: "urn:test",
+        element_name: "a",
+        attribute_name: "href",
+      )
+
+      manifest.register_reference(internal_ref)
+      manifest.register_reference(external_ref)
+
+      expect(manifest.internal_references.size).to eq(1)
+      expect(manifest.external_references.size).to eq(1)
+    end
+  end
+
+  describe "#id_defined?" do
+    before do
+      manifest.register_id("element-1", element_name: "rect")
+      manifest.register_id("element-2", element_name: "circle")
+    end
+
+    it "returns true for defined IDs" do
+      expect(manifest.id_defined?("element-1")).to be true
+      expect(manifest.id_defined?("element-2")).to be true
+    end
+
+    it "returns false for undefined IDs" do
+      expect(manifest.id_defined?("missing-element")).to be false
+    end
+  end
+
+  describe "#references_to_id" do
+    before do
+      manifest.register_id("target-element", element_name: "rect")
+
+      ref1 = SvgConform::References::InternalFragmentReference.new(
+        value: "#target-element",
+        element_name: "use",
+        attribute_name: "href",
+      )
+
+      ref2 = SvgConform::References::InternalFragmentReference.new(
+        value: "#target-element",
+        element_name: "a",
+        attribute_name: "href",
+      )
+
+      ref3 = SvgConform::References::InternalFragmentReference.new(
+        value: "#other-element",
+        element_name: "use",
+        attribute_name: "href",
+      )
+
+      manifest.register_reference(ref1)
+      manifest.register_reference(ref2)
+      manifest.register_reference(ref3)
+    end
+
+    it "returns all references to a specific ID" do
+      refs = manifest.references_to_id("target-element")
+      expect(refs.size).to eq(2)
+      expect(refs.all? { |r| r.target_id == "target-element" }).to be true
+    end
+
+    it "returns empty array for ID with no references" do
+      refs = manifest.references_to_id("unreferenced-element")
+      expect(refs).to be_empty
+    end
+  end
+
+  describe "#references_by_type" do
+    before do
+      manifest.register_reference(
+        SvgConform::References::InternalFragmentReference.new(
+          value: "#id-1",
+          element_name: "use",
+          attribute_name: "href",
+        ),
+      )
+
+      manifest.register_reference(
+        SvgConform::References::UrnReference.new(
+          value: "urn:test",
+          element_name: "a",
+          attribute_name: "href",
+        ),
+      )
+
+      manifest.register_reference(
+        SvgConform::References::ExternalUrlReference.new(
+          value: "https://example.com",
+          element_name: "a",
+          attribute_name: "href",
+        ),
+      )
+    end
+
+    it "groups references by type" do
+      by_type = manifest.references_by_type
+
+      expect(by_type.keys).to include(
+        "InternalFragmentReference",
+        "UrnReference",
+        "ExternalUrlReference",
+      )
+      expect(by_type["InternalFragmentReference"].size).to eq(1)
+      expect(by_type["UrnReference"].size).to eq(1)
+      expect(by_type["ExternalUrlReference"].size).to eq(1)
+    end
+  end
+
+  describe "#unresolved_internal_references" do
+    before do
+      manifest.register_id("element-1", element_name: "rect")
+
+      ref1 = SvgConform::References::InternalFragmentReference.new(
+        value: "#element-1",
+        element_name: "use",
+        attribute_name: "href",
+      )
+
+      ref2 = SvgConform::References::InternalFragmentReference.new(
+        value: "#missing-element",
+        element_name: "use",
+        attribute_name: "href",
+      )
+
+      ref3 = SvgConform::References::InternalFragmentReference.new(
+        value: "#another-missing",
+        element_name: "use",
+        attribute_name: "href",
+      )
+
+      manifest.register_reference(ref1)
+      manifest.register_reference(ref2)
+      manifest.register_reference(ref3)
+    end
+
+    it "identifies references to non-existent IDs" do
+      unresolved = manifest.unresolved_internal_references
+
+      expect(unresolved.size).to eq(2)
+      expect(unresolved.map(&:value)).to include("#missing-element",
+                                                 "#another-missing")
+      expect(unresolved.map(&:value)).not_to include("#element-1")
+    end
+
+    it "returns empty array when all references are resolved" do
+      manifest2 = described_class.new
+      manifest2.register_id("element-1", element_name: "rect")
+
+      ref = SvgConform::References::InternalFragmentReference.new(
+        value: "#element-1",
+        element_name: "use",
+        attribute_name: "href",
+      )
+      manifest2.register_reference(ref)
+
+      expect(manifest2.unresolved_internal_references).to be_empty
+    end
+  end
+
+  describe "#statistics" do
+    before do
+      manifest.register_id("id-1", element_name: "rect")
+      manifest.register_id("id-2", element_name: "circle")
+
+      manifest.register_reference(
+        SvgConform::References::InternalFragmentReference.new(
+          value: "#id-1",
+          element_name: "use",
+          attribute_name: "href",
+        ),
+      )
+
+      manifest.register_reference(
+        SvgConform::References::InternalFragmentReference.new(
+          value: "#missing",
+          element_name: "use",
+          attribute_name: "href",
+        ),
+      )
+
+      manifest.register_reference(
+        SvgConform::References::UrnReference.new(
+          value: "urn:test",
+          element_name: "a",
+          attribute_name: "href",
+        ),
+      )
+
+      manifest.register_reference(
+        SvgConform::References::ExternalUrlReference.new(
+          value: "https://example.com",
+          element_name: "a",
+          attribute_name: "href",
+        ),
+      )
+    end
+
+    it "provides comprehensive statistics" do
+      stats = manifest.statistics
+
+      expect(stats[:total_ids]).to eq(2)
+      expect(stats[:total_references]).to eq(4)
+      expect(stats[:internal_references]).to eq(2)
+      expect(stats[:external_references]).to eq(2)
+      expect(stats[:unresolved_internal]).to eq(1)
+      expect(stats[:references_by_type]["InternalFragmentReference"]).to eq(2)
+      expect(stats[:references_by_type]["UrnReference"]).to eq(1)
+      expect(stats[:references_by_type]["ExternalUrlReference"]).to eq(1)
+    end
+  end
+
+  describe "#to_h" do
+    before do
+      manifest.register_id("test-id", element_name: "rect", line_number: 5)
+
+      manifest.register_reference(
+        SvgConform::References::InternalFragmentReference.new(
+          value: "#test-id",
+          element_name: "use",
+          attribute_name: "href",
+          line_number: 10,
+        ),
+      )
+    end
+
+    it "exports manifest as hash" do
+      hash = manifest.to_h
+
+      expect(hash[:source_document]).to eq("test.svg")
+      expect(hash[:available_ids]).to be_an(Array)
+      expect(hash[:internal_references]).to be_an(Array)
+      expect(hash[:external_references]).to be_an(Array)
+      expect(hash[:statistics]).to be_a(Hash)
+    end
+  end
+
+  describe "export formats" do
+    before do
+      manifest.register_id("test-id", element_name: "rect")
+      manifest.register_reference(
+        SvgConform::References::UrnReference.new(
+          value: "urn:test",
+          element_name: "a",
+          attribute_name: "href",
+        ),
+      )
+    end
+
+    it "exports as YAML" do
+      yaml = manifest.to_yaml
+      expect(yaml).to be_a(String)
+      expect(yaml).to include("test.svg")
+      expect(yaml).to include("test-id")
+    end
+
+    it "exports as JSON" do
+      json = manifest.to_json
+      expect(json).to be_a(String)
+      parsed = JSON.parse(json)
+      expect(parsed["source_document"]).to eq("test.svg")
+    end
+  end
+end