svg_conform 0.1.0

data/examples/demo.rb

@@ -0,0 +1,116 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Demo script showing SvgConform capabilities
+require_relative "../lib/svg_conform"
+
+puts "SvgConform Demo"
+puts "=" * 50
+
+# Test with actual fixture files
+fixtures_dir = File.join(__dir__, "..", "spec", "fixtures", "svgcheck",
+                         "inputs")
+test_files = ["viewBox-height.svg", "colors.svg", "IETF-test.svg", "good.svg"]
+
+validator = SvgConform::Validator.new
+
+# Show available profiles
+puts "\n1. Available Profiles:"
+puts "-" * 30
+
+SvgConform::Profiles.available_profiles.each do |name|
+  profile = SvgConform::Profiles.get(name)
+  puts "#{name}: #{profile.description} (#{profile.requirement_count} requirements, #{profile.remediation_count} remediations)"
+end
+
+# Test each profile with sample files
+test_files.each do |filename|
+  file_path = File.join(fixtures_dir, filename)
+  next unless File.exist?(file_path)
+
+  puts "\n#{'=' * 60}"
+  puts "Testing file: #{filename}"
+  puts "=" * 60
+
+  # Read and display the SVG content
+  svg_content = File.read(file_path)
+  puts "\nSVG Content:"
+  puts svg_content
+  puts
+
+  # Test each profile
+  SvgConform::Profiles.available_profiles.each do |profile_name|
+    puts "\n#{profile_name.to_s.upcase} Profile Results:"
+    puts "-" * 40
+
+    begin
+      result = validator.validate_file(file_path, profile: profile_name)
+
+      puts "Status: #{result.valid? ? 'VALID ✓' : 'INVALID ✗'}"
+      puts "Errors: #{result.error_count}"
+      puts "Warnings: #{result.warning_count}"
+
+      if result.has_errors?
+        puts "\nErrors:"
+        result.errors.each_with_index do |error, i|
+          puts "  #{i + 1}. #{error.message} (#{error.requirement_id})"
+        end
+      end
+
+      if result.has_warnings?
+        puts "\nWarnings:"
+        result.warnings.each_with_index do |warning, i|
+          puts "  #{i + 1}. #{warning.message} (#{warning.requirement_id})"
+        end
+      end
+
+      # Test remediation if available
+      if result.fixable?
+        puts "\nApplying fixes (#{result.fixable_count} available)..."
+
+        # Apply fixes using the ValidationResult's built-in fix method
+        result.apply_fixes
+
+        if result.fixed?
+          puts "✓ Fixes applied successfully!"
+          puts "Fixed SVG preview (first 200 chars):"
+          fixed_content = result.fixed_document.to_xml
+          puts fixed_content[0..200] + (fixed_content.length > 200 ? "..." : "")
+
+          # Re-validate the fixed document
+          fixed_result = validator.validate(fixed_content,
+                                            profile: profile_name)
+          puts "\nRe-validation: #{fixed_result.valid? ? 'VALID ✓' : 'INVALID ✗'}"
+          puts "Remaining errors: #{fixed_result.error_count}"
+        else
+          puts "✗ Could not apply fixes"
+        end
+      end
+    rescue StandardError => e
+      puts "ERROR: #{e.message}"
+    end
+  end
+end
+
+# Performance test
+puts "\n#{'=' * 60}"
+puts "Performance Test"
+puts "=" * 60
+
+require "benchmark"
+test_file = File.join(fixtures_dir, "good.svg")
+
+if File.exist?(test_file)
+  time = Benchmark.realtime do
+    100.times do
+      validator.validate_file(test_file, profile: :svg_1_2_rfc)
+    end
+  end
+
+  puts "Validated #{test_file} 100 times in #{time.round(3)} seconds"
+  puts "Average: #{(time * 1000 / 100).round(2)}ms per validation"
+else
+  puts "Performance test skipped - test file not found"
+end
+
+puts "\nDemo completed!"

data/examples/requirements_demo.rb

@@ -0,0 +1,240 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/svg_conform"
+
+# Demo script showing the new requirements and remediations system
+class RequirementsDemo
+  def run
+    puts "=== SvgConform Requirements & Remediations Demo ==="
+    puts
+
+    # Demo 1: Load profile from YAML
+    demo_yaml_profile_loading
+
+    # Demo 2: Validate with requirements
+    demo_requirements_validation
+
+    # Demo 3: Apply remediations
+    demo_remediations
+
+    # Demo 4: Lucid fix scenario
+    demo_lucid_fix
+  end
+
+  private
+
+  def demo_yaml_profile_loading
+    puts "1. Loading Profiles from YAML Configuration"
+    puts "=" * 50
+
+    begin
+      # Load IETF profile from YAML
+      svg_1_2_rfc_profile = SvgConform::ProfileRegistry.load_profile("svg_1_2_rfc")
+      puts "✓ Loaded IETF profile: #{svg_1_2_rfc_profile.name}"
+      puts "  Description: #{svg_1_2_rfc_profile.description}"
+      puts "  Requirements: #{svg_1_2_rfc_profile.requirement_count}"
+      puts "  Remediations: #{svg_1_2_rfc_profile.remediation_count}"
+      puts
+
+      # Load Lucid fix profile
+      lucid_profile = SvgConform::ProfileRegistry.load_profile("lucid_fix")
+      puts "✓ Loaded Lucid Fix profile: #{lucid_profile.name}"
+      puts "  Description: #{lucid_profile.description}"
+      puts "  Requirements: #{lucid_profile.requirement_count}"
+      puts "  Remediations: #{lucid_profile.remediation_count}"
+      puts
+
+      # List available profiles
+      available = SvgConform::ProfileRegistry.available_profiles
+      puts "Available profiles: #{available.join(', ')}"
+      puts
+    rescue StandardError => e
+      puts "✗ Error loading profiles: #{e.message}"
+      puts "  This is expected if the requirement classes don't exist yet"
+      puts
+    end
+  end
+
+  def demo_requirements_validation
+    puts "2. Requirements-based Validation"
+    puts "=" * 50
+
+    # Create a test SVG with invalid use element
+    invalid_svg = <<~SVG
+      <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">
+        <defs>
+          <circle id="valid-circle" cx="10" cy="10" r="5"/>
+        </defs>
+        <use href="#invalid-id"/>
+        <use href="#valid-circle"/>
+        <rect fill="red" width="50" height="50"/>
+      </svg>
+    SVG
+
+    puts "Test SVG with invalid use element:"
+    puts invalid_svg
+    puts
+
+    # Create a simple profile with requirements
+    profile = SvgConform::Profile.new(:test_requirements,
+                                      "Test Requirements Profile")
+
+    begin
+      # Add invalid ID references requirement
+      requirement = SvgConform::Requirements::InvalidIdReferencesRequirement.new
+      profile.add_requirement(requirement)
+
+      # Validate
+      document = SvgConform::Document.new(invalid_svg)
+      result = profile.validate(document)
+
+      puts "Validation Results:"
+      puts "  Valid: #{result.valid?}"
+      puts "  Errors: #{result.error_count}"
+      puts "  Warnings: #{result.warning_count}"
+      puts
+
+      if result.errors.any?
+        puts "Errors found:"
+        result.errors.each_with_index do |error, i|
+          puts "  #{i + 1}. #{error.message}"
+          puts "     Node: #{error.node.name}" if error.node
+          puts "     Data: #{error.data}" if error.data.any?
+        end
+        puts
+      end
+    rescue StandardError => e
+      puts "✗ Error during validation: #{e.message}"
+      puts "  This is expected if the requirement classes don't exist yet"
+      puts
+    end
+  end
+
+  def demo_remediations
+    puts "3. Applying Remediations"
+    puts "=" * 50
+
+    # Create test SVG with issues
+    problematic_svg = <<~SVG
+      <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">
+        <defs>
+          <circle id="circle1" cx="10" cy="10" r="5"/>
+        </defs>
+        <use href="#missing-id"/>
+        <use href="#circle1"/>
+        <use href="#another-missing"/>
+      </svg>
+    SVG
+
+    puts "Original SVG with invalid use elements:"
+    puts problematic_svg
+    puts
+
+    begin
+      # Create profile with requirements and remediations
+      profile = SvgConform::Profile.new(:test_remediations,
+                                        "Test Remediations Profile")
+
+      # Add requirement
+      requirement = SvgConform::Requirements::InvalidIdReferencesRequirement.new
+      profile.add_requirement(requirement)
+
+      # Add remediation
+      remediation = SvgConform::Remediations::InvalidIdReferencesRemediation.new
+      profile.add_remediation(remediation)
+
+      # Validate first
+      document = SvgConform::Document.new(problematic_svg)
+      result = profile.validate(document)
+
+      puts "Validation found #{result.error_count} errors"
+
+      if result.errors.any?
+        # Debug: Show requirement IDs
+        puts "Failed requirement IDs: #{result.failed_requirements.map(&:requirement_id)}"
+        puts "Available remediations: #{profile.remediations.map do |r|
+          "#{r.id} (targets: #{r.target_requirements})"
+        end}"
+        puts
+
+        # Apply remediations
+        engine = SvgConform::RemediationEngine.new(profile)
+        remediation_results = engine.apply_remediations(document, result)
+
+        puts "Applied #{remediation_results.size} remediations"
+        puts "Summary: #{engine.summary}"
+        puts
+
+        puts "Fixed SVG:"
+        puts document.to_xml
+        puts
+      end
+    rescue StandardError => e
+      puts "✗ Error during remediation: #{e.message}"
+      puts "  This is expected if the remediation classes don't exist yet"
+      puts
+    end
+  end
+
+  def demo_lucid_fix
+    puts "4. Lucid SVG Fix Scenario"
+    puts "=" * 50
+
+    # Simulate a Lucid-generated SVG with invalid use elements
+    lucid_svg = <<~SVG
+      <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 200 100">
+        <defs>
+          <g id="shape1">
+            <rect width="20" height="20" fill="blue"/>
+          </g>
+        </defs>
+        <g>
+          <use xlink:href="#shape1" x="10" y="10"/>
+          <use xlink:href="#nonexistent1" x="50" y="10"/>
+          <use xlink:href="#nonexistent2" x="90" y="10"/>
+          <text x="10" y="50">Valid content</text>
+        </g>
+      </svg>
+    SVG
+
+    puts "Lucid-style SVG with invalid use elements:"
+    puts lucid_svg
+    puts
+
+    begin
+      # Load the Lucid fix profile
+      profile = SvgConform::ProfileRegistry.load_profile("lucid_fix")
+
+      # Process the SVG
+      document = SvgConform::Document.new(lucid_svg)
+      result = profile.validate(document)
+
+      puts "Found #{result.error_count} invalid use elements"
+
+      if result.errors.any?
+        # Apply the Lucid fix
+        engine = SvgConform::RemediationEngine.new(profile)
+        engine.apply_remediations(document, result)
+
+        puts "Applied Lucid fix remediations"
+        puts "Summary: #{engine.summary}"
+        puts
+
+        puts "Fixed SVG (invalid use elements removed):"
+        puts document.to_xml
+        puts
+      end
+    rescue StandardError => e
+      puts "✗ Error during Lucid fix: #{e.message}"
+      puts "  This is expected if the profile/classes don't exist yet"
+      puts
+    end
+  end
+end
+
+# Run the demo
+if __FILE__ == $PROGRAM_NAME
+  demo = RequirementsDemo.new
+  demo.run
+end

data/exe/svg_conform

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/svg_conform"
+
+# Run the Thor CLI
+SvgConform::Cli.start(ARGV)

data/lib/svg_conform/batch_report.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module SvgConform
+  # Result for a single file in batch processing
+  class FileResult < Lutaml::Model::Serializable
+    attribute :filename, :string
+    attribute :original_path, :string
+    attribute :valid_before, :boolean
+    attribute :valid_after, :boolean
+    attribute :errors_before, :integer
+    attribute :errors_after, :integer
+    attribute :remediated_path, :string
+    attribute :status, :string # "valid", "remediated", "failed", "error"
+    attribute :error_message, :string
+
+    yaml do
+      map "filename", to: :filename
+      map "original_path", to: :original_path
+      map "valid_before", to: :valid_before
+      map "valid_after", to: :valid_after
+      map "errors_before", to: :errors_before
+      map "errors_after", to: :errors_after
+      map "remediated_path", to: :remediated_path
+      map "status", to: :status
+      map "error_message", to: :error_message
+    end
+  end
+
+  # Batch validation/remediation report
+  class BatchReport < Lutaml::Model::Serializable
+    attribute :directory, :string
+    attribute :profile, :string
+    attribute :timestamp, :string, default: -> { Time.now.iso8601 }
+    attribute :total_files, :integer
+    attribute :valid_before, :integer
+    attribute :valid_after, :integer
+    attribute :remediated, :integer
+    attribute :failed, :integer
+    attribute :success_rate, :float
+    attribute :files, FileResult, collection: true, default: []
+    attribute :manifest, :hash, default: {}
+
+    yaml do
+      map "directory", to: :directory
+      map "profile", to: :profile
+      map "timestamp", to: :timestamp
+      map "total_files", to: :total_files
+      map "valid_before", to: :valid_before
+      map "valid_after", to: :valid_after
+      map "remediated", to: :remediated
+      map "failed", to: :failed
+      map "success_rate", to: :success_rate
+      map "files", to: :files
+      map "manifest", to: :manifest
+    end
+
+    def calculate_statistics
+      self.total_files = files.length
+      self.valid_before = files.count(&:valid_before)
+      self.valid_after = files.count(&:valid_after)
+      self.remediated = files.count { |f| f.status == "remediated" }
+      self.failed = files.count do |f|
+        ["failed", "error"].include?(f.status)
+      end
+      self.success_rate = total_files.zero? ? 0.0 : (valid_after.to_f / total_files * 100).round(1)
+    end
+  end
+end

data/lib/svg_conform/cli.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "thor"
+require "json"
+require "yaml"
+require "paint"
+require_relative "commands/check"
+require_relative "commands/svgcheck"
+require_relative "commands/profiles"
+
+module SvgConform
+  # Thor-based CLI for SvgConform with svgcheck-like functionality
+  class Cli < Thor
+    def initialize(*args)
+      super
+    end
+
+    desc "check [*FILES]",
+         "Check SVG file(s) validity (single file, multiple files, or directory)"
+    long_desc <<~DESC
+      Check SVG file validity against a profile.
+
+      MODES:
+      1. Single file: svg_conform check file.svg -p PROFILE
+      2. Multiple files: svg_conform check *.svg -p PROFILE
+      3. Directory: svg_conform check --directory PATH -p PROFILE
+
+      By default, only validates without creating remediated files.
+      Use --fix to enable automatic remediation.
+
+      REMEDIATION OUTPUT:
+      - Single file: Uses --fix-output (default: FILE.fixed.svg)
+      - Multiple files: Requires --output-dir or --in-place
+      - Directory: Requires --output-dir or --in-place
+
+      REPORT FORMATS:
+      - table: Human-readable (default for single file)
+      - json: JSON format using lutaml-model
+      - yaml: YAML format using lutaml-model
+
+      EXAMPLES:
+        svg_conform check file.svg -p metanorma
+        svg_conform check *.svg -p metanorma -f --output-dir fixed/
+        svg_conform check -d images/ -p metanorma --report-format json --report-output report.json
+        svg_conform check -d images/ -p metanorma -f --in-place --force
+    DESC
+    option :directory, aliases: "-d", type: :string,
+                       desc: "Directory to scan recursively for SVG files"
+    option :profile, aliases: "-p", default: "svg_1_2_rfc",
+                     desc: "Profile to validate against"
+    option :format, default: "table", enum: %w[table yaml json],
+                    desc: "Output format (single file mode)"
+    option :fix, aliases: "-f", type: :boolean, default: false,
+                 desc: "Create remediated files"
+    option :output, aliases: "-o", desc: "Output file (single file mode)"
+    option :output_dir, type: :string,
+                        desc: "Output directory for remediated files (multi-file mode)"
+    option :in_place, type: :boolean, default: false,
+                      desc: "Replace original files (requires --force)"
+    option :force, type: :boolean, default: false,
+                   desc: "Confirm destructive operations (required for --in-place)"
+    option :fix_output,
+           desc: "Output file for remediated SVG (single file mode, default: FILE.fixed.svg)"
+    option :report_format, enum: %w[json yaml],
+                           desc: "Batch report format (json or yaml)"
+    option :report_output, type: :string,
+                           desc: "Save detailed batch report to file"
+    option :manifest, type: :string,
+                      desc: "Manifest file path (default: manifest.json with --fix)"
+    option :quiet, aliases: "-q", type: :boolean, default: false,
+                   desc: "Suppress per-file output, show summary only"
+    option :verbose, aliases: "-v", type: :boolean, default: false,
+                     desc: "Show detailed progress"
+    def check(*files)
+      SvgConform::Commands::Check.new(files, options).execute
+    end
+
+    desc "svgcheck SUBCOMMAND",
+         "Svgcheck-related commands (compare, compatibility, generate)"
+    subcommand "svgcheck", Commands::Svgcheck
+
+    desc "profiles", "List available validation profiles"
+    long_desc <<~DESC
+      List all available validation profiles with their descriptions
+      and requirements.
+    DESC
+    option :verbose, aliases: "-v", type: :boolean, default: false,
+                     desc: "Show detailed information"
+    def profiles
+      SvgConform::Commands::Profiles.new(options).execute
+    end
+
+    desc "version", "Show version information"
+    def version
+      puts "SvgConform #{SvgConform::VERSION}"
+    end
+
+    private
+
+    def method_missing(method_name, *_args)
+      puts Paint["Unknown command: #{method_name}", :red]
+      puts
+      help
+      exit 1
+    end
+  end
+end