svg_conform 0.1.0

data/spec/svg_conform/profiles/svg_1_2_rfc_profile_spec.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "canon"
+require "tempfile"
+
+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" }
+
+  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)
+      expect(profile).not_to be_nil
+      expect(profile.name).to eq("svg_1_2_rfc")
+      expect(profile.description).to include("RFC 7996")
+    end
+
+    it "has all expected requirements" do
+      profile = SvgConform::Profile.load_from_file(svg_1_2_rfc_profile_path)
+      requirement_ids = profile.requirements.map(&:id)
+
+      expected_requirements = %w[
+        allowed_elements
+        color_restrictions
+        font_family
+        style
+        namespace_validation
+        namespace_attributes
+        viewbox_required
+        link_validation
+        id_references
+        forbidden_content
+        style_promotion
+      ]
+
+      expect(requirement_ids).to include(*expected_requirements)
+    end
+
+    it "has all expected remediations" do
+      profile = SvgConform::Profile.load_from_file(svg_1_2_rfc_profile_path)
+      remediation_ids = profile.remediations.map(&:id)
+
+      expected_remediations = %w[
+        color_conversion
+        font_family_conversion
+        style_promotion
+        viewbox_generation
+      ]
+
+      expect(remediation_ids).to include(*expected_remediations)
+    end
+  end
+
+  # Test each requirement with its specific fixtures
+  REQUIREMENTS_TO_TEST = %w[
+    allowed_elements
+    color_restrictions
+    font_family
+    forbidden_content
+    id_reference
+    link_validation
+    namespace_attributes
+    namespace
+    no_external_css
+    style
+    style_promotion
+    viewbox_required
+  ].freeze
+
+  FIXTURES_BASE_DIR = "spec/fixtures"
+
+  REQUIREMENTS_TO_TEST.each do |requirement_name|
+    fixtures_dir_path = File.join(FIXTURES_BASE_DIR, requirement_name)
+
+    # Skip if fixture directory doesn't exist
+    next unless Dir.exist?(fixtures_dir_path)
+
+    describe "#{requirement_name} requirement" do
+      # Get all fixture files that have both input and expected repair versions
+      fixture_files = Dir.glob(File.join(fixtures_dir_path,
+                                         "inputs/*.svg")).select do |input_file|
+        basename = File.basename(input_file)
+        File.exist?(File.join(fixtures_dir_path, "repair", basename))
+      end.map do |f|
+        File.basename(f, ".svg")
+      end
+
+      fixture_files.each do |fixture_name|
+        describe "fixture: #{fixture_name}" do
+          let(:fixtures_dir) { File.join(FIXTURES_BASE_DIR, requirement_name) }
+          let(:input_file) do
+            File.join(fixtures_dir, "inputs", "#{fixture_name}.svg")
+          end
+          let(:expected_output_file) do
+            File.join(fixtures_dir, "repair", "#{fixture_name}.svg")
+          end
+
+          it "validates input file and identifies violations" do
+            skip "Input file not found" unless File.exist?(input_file)
+
+            document = SvgConform::Document.from_file(input_file)
+            profile = SvgConform::Profile.load_from_file(svg_1_2_rfc_profile_path)
+
+            validation_result = profile.validate(document)
+
+            # Should have violations for this test case
+            expect(validation_result.valid?).to be false
+            expect(validation_result.errors.count).to be > 0
+
+            puts "Found #{validation_result.errors.count} violations in #{fixture_name}"
+          end
+
+          it "applies available remediations successfully" do
+            skip "Expected repair file not found" unless File.exist?(expected_output_file)
+            skip "Input file not found" unless File.exist?(input_file)
+
+            # Load the document and apply profile remediations
+            document = SvgConform::Document.from_file(input_file)
+            profile = SvgConform::Profile.load_from_file(svg_1_2_rfc_profile_path)
+
+            # Get initial error count
+            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
+
+            # Show remediation progress
+            puts "Remediation results for #{fixture_name}: #{initial_error_count} → #{final_error_count} errors"
+            puts "  Changes applied: #{changes.count}" if changes.any?
+
+            # For requirements with implemented remediations, expect fewer errors
+            requirements_with_remediations = %w[color_restrictions font_family
+                                                viewbox_required]
+
+            if requirements_with_remediations.include?(requirement_name)
+              expect(final_error_count).to be < initial_error_count
+            else
+              # For requirements without remediations, document the current state
+              puts "  Note: No remediations available for #{requirement_name} requirement"
+            end
+          end
+
+          it "maintains XML structure integrity after processing" do
+            skip "Input file not found" unless File.exist?(input_file)
+
+            # Load the document and apply profile remediations
+            document = SvgConform::Document.from_file(input_file)
+            profile = SvgConform::Profile.load_from_file(svg_1_2_rfc_profile_path)
+
+            # Apply all remediations
+            profile.apply_remediations(document)
+
+            # Should still be valid XML
+            expect(document.to_xml).to match(/<svg\s+[^>]*>.*<\/svg>/m)
+
+            # Should maintain root element structure
+            expect(document.root.name).to eq("svg")
+          end
+        end
+      end
+    end
+  end
+
+  describe "comprehensive test" do
+    let(:comprehensive_input) do
+      "spec/fixtures/comprehensive/inputs/multiple_violations.svg"
+    end
+    let(:comprehensive_expected) do
+      "spec/fixtures/comprehensive/repair/multiple_violations.svg"
+    end
+
+    it "handles multiple violations across different requirements" do
+      skip "Comprehensive fixtures not found" unless File.exist?(comprehensive_input)
+
+      document = SvgConform::Document.from_file(comprehensive_input)
+      profile = SvgConform::Profile.load_from_file(svg_1_2_rfc_profile_path)
+
+      # Initial validation should show multiple violations
+      initial_result = profile.validate(document)
+      expect(initial_result.valid?).to be false
+      expect(initial_result.errors.count).to be > 5
+
+      # Apply remediations
+      changes = profile.apply_remediations(document)
+      expect(changes).not_to be_empty
+
+      # Final validation should be much better
+      final_result = profile.validate(document)
+      expect(final_result.errors.count).to be < initial_result.errors.count
+
+      puts "Comprehensive test: #{initial_result.errors.count} → #{final_result.errors.count} violations"
+    end
+  end
+end

data/spec/svg_conform/profiles/svg_1_2_rfc_with_rdf_profile_spec.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "SVG 1.2 RFC with RDF Profile" do
+  let(:svg_1_2_rfc_with_rdf_profile_path) do
+    "config/profiles/svg_1_2_rfc_with_rdf.yml"
+  end
+
+  describe "profile loading" do
+    it "loads the SVG 1.2 RFC with RDF profile successfully" do
+      profile = SvgConform::Profile.load_from_file(svg_1_2_rfc_with_rdf_profile_path)
+      expect(profile).not_to be_nil
+      expect(profile.name).to eq("svg_1_2_rfc_with_rdf")
+    end
+
+    it "includes all base RFC 7996 requirements" do
+      profile = SvgConform::Profile.load_from_file(svg_1_2_rfc_with_rdf_profile_path)
+      requirement_ids = profile.requirements.map(&:id)
+
+      base_requirements = %w[
+        allowed_elements
+        color_restrictions
+        font_family
+        namespace_validation
+        viewbox_required
+      ]
+
+      expect(requirement_ids).to include(*base_requirements)
+    end
+
+    it "has description indicating RDF metadata support" do
+      profile = SvgConform::Profile.load_from_file(svg_1_2_rfc_with_rdf_profile_path)
+      expect(profile.description).to be_a(String)
+      expect(profile.description.downcase).to match(/rdf|metadata/)
+    end
+  end
+
+  describe "RDF metadata handling" do
+    it "allows RDF metadata elements" do
+      svg_with_rdf = <<~SVG
+        <svg xmlns="http://www.w3.org/2000/svg"
+             xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+             xmlns:dc="http://purl.org/dc/elements/1.1/"
+             viewBox="0 0 100 100">
+          <metadata>
+            <rdf:RDF>
+              <rdf:Description>
+                <dc:title>Test Document</dc:title>
+              </rdf:Description>
+            </rdf:RDF>
+          </metadata>
+          <rect x="10" y="10" width="50" height="50" fill="red"/>
+        </svg>
+      SVG
+
+      document = SvgConform::Document.from_content(svg_with_rdf)
+      profile = SvgConform::Profile.load_from_file(svg_1_2_rfc_with_rdf_profile_path)
+
+      result = profile.validate(document)
+      expect(result).to respond_to(:valid?)
+    end
+  end
+
+  describe "validation" do
+    it "maintains all SVG 1.2 RFC compliance checks" do
+      svg_content = <<~SVG
+        <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">
+          <rect x="10" y="10" width="50" height="50" fill="red"/>
+        </svg>
+      SVG
+
+      document = SvgConform::Document.from_content(svg_content)
+      profile = SvgConform::Profile.load_from_file(svg_1_2_rfc_with_rdf_profile_path)
+
+      result = profile.validate(document)
+      expect(result).to respond_to(:valid?)
+      expect(result).to respond_to(:errors)
+    end
+  end
+end

data/spec/svg_conform/remediations/color_remediation_spec.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "canon"
+
+RSpec.describe SvgConform::Remediations::ColorRemediation do
+  let(:fixtures_dir) { "spec/fixtures/color" }
+
+  # Get all fixture files that have both input and expected repair versions
+  fixture_files = Dir.glob("spec/fixtures/color/inputs/*.svg").select do |input_file|
+    basename = File.basename(input_file)
+    File.exist?("spec/fixtures/color/repair/#{basename}")
+  end.map do |f|
+    File.basename(f, ".svg")
+  end
+
+  fixture_files.each do |fixture_name|
+    describe "fixture: #{fixture_name}" do
+      let(:input_file) { "spec/fixtures/color/inputs/#{fixture_name}.svg" }
+      let(:expected_output_file) do
+        "spec/fixtures/color/repair/#{fixture_name}.svg"
+      end
+
+      it "applies remediation and produces expected output" do
+        skip "Input file not found" unless File.exist?(input_file)
+        skip "Expected output file not found" unless File.exist?(expected_output_file)
+
+        document = SvgConform::Document.from_file(input_file)
+        remediation = described_class.new(
+          id: "color_fix",
+          description: "Test color remediation",
+        )
+
+        # Apply the remediation (remediations need context parameter)
+        context = SvgConform::ValidationContext.new(document, nil)
+        changes = remediation.apply(document, context)
+
+        # Verify changes were made
+        expect(changes).to be_an(Array)
+        puts "Applied #{changes.count} changes in #{fixture_name}" if changes.any?
+
+        # Get the remediated XML
+        actual_xml = document.to_xml
+        expected_xml = File.read(expected_output_file)
+
+        # Use canon matcher for XML equivalence
+        expect(actual_xml).to be_analogous_with(expected_xml)
+      end
+
+      it "produces valid XML after remediation" do
+        skip "Input file not found" unless File.exist?(input_file)
+
+        document = SvgConform::Document.from_file(input_file)
+        remediation = described_class.new(
+          id: "color_fix",
+          description: "Test color remediation",
+        )
+
+        # Apply the remediation (remediations need context parameter)
+        context = SvgConform::ValidationContext.new(document, nil)
+        remediation.apply(document, context)
+
+        # Get the remediated XML
+        actual_xml = document.to_xml
+
+        # Basic XML validity check
+        expect(actual_xml).to include("<svg")
+        expect(actual_xml).to include("</svg>")
+        expect do
+          SvgConform::Document.from_content(actual_xml)
+        end.not_to raise_error
+      end
+    end
+  end
+
+  describe "configuration" do
+    it "can be instantiated with basic parameters" do
+      remediation = described_class.new(
+        id: "test_color_fix",
+        description: "Test remediation",
+      )
+
+      expect(remediation).to be_a(described_class)
+    end
+
+    it "responds to apply method" do
+      remediation = described_class.new(
+        id: "test_color_fix",
+        description: "Test remediation",
+      )
+
+      expect(remediation).to respond_to(:apply)
+    end
+  end
+end

data/spec/svg_conform/remediations/font_embedding_remediation_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe SvgConform::Remediations::FontEmbeddingRemediation do
+  describe "configuration" do
+    it "can be instantiated with basic parameters" do
+      remediation = described_class.new(
+        id: "font_embedding",
+        description: "Test",
+      )
+      expect(remediation).to respond_to(:apply)
+    end
+
+    it "responds to apply method" do
+      remediation = described_class.new(id: "test", description: "Test")
+      expect(remediation).to respond_to(:apply)
+    end
+  end
+end

data/spec/svg_conform/remediations/font_remediation_spec.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "canon"
+
+RSpec.describe SvgConform::Remediations::FontRemediation do
+  let(:fixtures_dir) { "spec/fixtures/font" }
+
+  # Get all fixture files that have both input and expected repair versions
+  fixture_files = Dir.glob("spec/fixtures/font/inputs/*.svg").select do |input_file|
+    basename = File.basename(input_file)
+    File.exist?("spec/fixtures/font/repair/#{basename}")
+  end.map do |f|
+    File.basename(f, ".svg")
+  end
+
+  fixture_files.each do |fixture_name|
+    describe "fixture: #{fixture_name}" do
+      let(:input_file) { "spec/fixtures/font/inputs/#{fixture_name}.svg" }
+      let(:expected_output_file) do
+        "spec/fixtures/font/repair/#{fixture_name}.svg"
+      end
+
+      it "applies remediation and produces expected output" do
+        skip "Input file not found" unless File.exist?(input_file)
+        skip "Expected output file not found" unless File.exist?(expected_output_file)
+
+        document = SvgConform::Document.from_file(input_file)
+        remediation = described_class.new(
+          id: "font_fix",
+          description: "Test font remediation",
+        )
+
+        # Apply the remediation
+        context = SvgConform::ValidationContext.new(document, nil)
+        changes = remediation.apply(document, context)
+
+        # Verify changes were made
+        expect(changes).to be_an(Array)
+        puts "Applied #{changes.count} changes in #{fixture_name}" if changes.any?
+
+        # Get the remediated XML
+        actual_xml = document.to_xml
+        expected_xml = File.read(expected_output_file)
+
+        # Use canon matcher for XML equivalence
+        expect(actual_xml).to be_analogous_with(expected_xml)
+      end
+
+      it "produces valid XML after remediation" do
+        skip "Input file not found" unless File.exist?(input_file)
+
+        document = SvgConform::Document.from_file(input_file)
+        remediation = described_class.new(
+          id: "font_fix",
+          description: "Test font remediation",
+        )
+
+        # Apply the remediation
+        context = SvgConform::ValidationContext.new(document, nil)
+        remediation.apply(document, context)
+
+        # Get the remediated XML
+        actual_xml = document.to_xml
+
+        # Basic XML validity check
+        expect(actual_xml).to include("<svg")
+        expect(actual_xml).to include("</svg>")
+        expect do
+          SvgConform::Document.from_content(actual_xml)
+        end.not_to raise_error
+      end
+    end
+  end
+
+  describe "configuration" do
+    it "can be instantiated with basic parameters" do
+      remediation = described_class.new(
+        id: "test_font_fix",
+        description: "Test remediation",
+      )
+
+      expect(remediation).to be_a(described_class)
+    end
+
+    it "responds to apply method" do
+      remediation = described_class.new(
+        id: "test_font_fix",
+        description: "Test remediation",
+      )
+
+      expect(remediation).to respond_to(:apply)
+    end
+  end
+end

data/spec/svg_conform/remediations/image_embedding_remediation_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe SvgConform::Remediations::ImageEmbeddingRemediation do
+  describe "configuration" do
+    it "can be instantiated with basic parameters" do
+      remediation = described_class.new(
+        id: "image_embedding",
+        description: "Test",
+      )
+      expect(remediation).to respond_to(:apply)
+    end
+
+    it "responds to apply method" do
+      remediation = described_class.new(id: "test", description: "Test")
+      expect(remediation).to respond_to(:apply)
+    end
+  end
+end

data/spec/svg_conform/remediations/invalid_id_references_remediation_spec.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "canon"
+
+RSpec.describe SvgConform::Remediations::InvalidIdReferencesRemediation do
+  let(:fixtures_dir) { "spec/fixtures/invalid_id_references" }
+
+  # Get all fixture files that have both input and expected repair versions
+  fixture_files = Dir.glob("spec/fixtures/invalid_id_references/inputs/*.svg").select do |input_file|
+    basename = File.basename(input_file)
+    File.exist?("spec/fixtures/invalid_id_references/repair/#{basename}")
+  end.map do |f|
+    File.basename(f, ".svg")
+  end
+
+  fixture_files.each do |fixture_name|
+    describe "fixture: #{fixture_name}" do
+      let(:input_file) do
+        "spec/fixtures/invalid_id_references/inputs/#{fixture_name}.svg"
+      end
+      let(:expected_output_file) do
+        "spec/fixtures/invalid_id_references/repair/#{fixture_name}.svg"
+      end
+
+      it "applies remediation and produces expected output" do
+        skip "Input file not found" unless File.exist?(input_file)
+        skip "Expected output file not found" unless File.exist?(expected_output_file)
+
+        document = SvgConform::Document.from_file(input_file)
+        remediation = described_class.new(
+          id: "invalid_id_references_fix",
+          description: "Test invalid id references remediation",
+        )
+
+        # Apply the remediation
+        context = SvgConform::ValidationContext.new(document, nil)
+        changes = remediation.apply(document, context)
+
+        # Verify changes were made
+        expect(changes).to be_an(Array)
+        puts "Applied #{changes.count} changes in #{fixture_name}" if changes.any?
+
+        # Get the remediated XML
+        actual_xml = document.to_xml
+        expected_xml = File.read(expected_output_file)
+
+        # Use canon matcher for XML equivalence
+        expect(actual_xml).to be_analogous_with(expected_xml)
+      end
+
+      it "produces valid XML after remediation" do
+        skip "Input file not found" unless File.exist?(input_file)
+
+        document = SvgConform::Document.from_file(input_file)
+        remediation = described_class.new(
+          id: "invalid_id_references_fix",
+          description: "Test invalid id references remediation",
+        )
+
+        # Apply the remediation
+        context = SvgConform::ValidationContext.new(document, nil)
+        remediation.apply(document, context)
+
+        # Get the remediated XML
+        actual_xml = document.to_xml
+
+        # Basic XML validity check
+        expect(actual_xml).to include("<svg")
+        expect(actual_xml).to include("</svg>")
+        expect do
+          SvgConform::Document.from_content(actual_xml)
+        end.not_to raise_error
+      end
+    end
+  end
+
+  describe "configuration" do
+    it "can be instantiated with basic parameters" do
+      remediation = described_class.new(
+        id: "test_invalid_id_references_fix",
+        description: "Test remediation",
+      )
+
+      expect(remediation).to be_a(described_class)
+    end
+
+    it "responds to apply method" do
+      remediation = described_class.new(
+        id: "test_invalid_id_references_fix",
+        description: "Test remediation",
+      )
+
+      expect(remediation).to respond_to(:apply)
+    end
+  end
+end