svg_conform 0.1.0

data/lib/svg_conform/commands/svgcheck_compatibility.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "../compatibility/compatibility_analyzer"
+
+module SvgConform
+  module Commands
+    # Command for comparing SvgConform with svgcheck compatibility
+    class SvgcheckCompatibility
+      def initialize(options = {})
+        @options = options
+      end
+
+      def execute
+        validate_options
+
+        analyzer = SvgConform::Compatibility::CompatibilityAnalyzer.new(
+          mode: @options[:mode] || @options["mode"] || "check",
+          profile: @options[:profile] || @options["profile"] || "svg_1_2_rfc_compatible",
+          semantic: @options[:semantic] || @options["semantic"] || false,
+          svgcheck_dir: @options[:svgcheck_dir] || @options["svgcheck_dir"] || "spec/fixtures/svgcheck",
+          file: @options[:file] || @options["file"],
+          output: @options[:output] || @options["output"],
+        )
+
+        analyzer.run_analysis
+      end
+
+      private
+
+      def validate_options
+        mode = @options[:mode] || @options["mode"] || "check"
+        raise "Invalid mode: #{mode}. Must be 'check' or 'repair'" unless %w[
+          check repair
+        ].include?(mode)
+
+        file = @options[:file] || @options["file"]
+        return unless file && !file.match?(/\.(svg|xml)$/i)
+
+        raise "File must have .svg or .xml extension: #{file}"
+      end
+    end
+  end
+end

data/lib/svg_conform/commands/svgcheck_generate.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+
+require "English"
+require "fileutils"
+require "paint"
+require "open3"
+
+module SvgConform
+  module Commands
+    # Generate svgcheck outputs using Open3 for proper process management
+    class SvgcheckGenerate
+      def initialize(svgcheck_repo_path, options)
+        @svgcheck_repo_path = svgcheck_repo_path
+        @options = options
+        @svgcheck_exec = @options[:svgcheck_exec] || "svgcheck"
+        @fixtures_path = @options[:fixtures_path] || "spec/fixtures/svgcheck"
+        @test_dir = File.join(@svgcheck_repo_path, "svgcheck", "Tests")
+        @svgcheck_dir = File.join(@svgcheck_repo_path, "svgcheck")
+        @single_file = @options[:single_file]
+        @force = @options[:force] || false
+        @verbose = @options[:verbose] || false
+        @mode = @options[:mode] || "both" # 'check', 'repair', or 'both'
+
+        # File renaming map: svgcheck filename => our fixture filename
+        @file_rename_map = {
+          "full-tiny.xml" => "full-tiny.svg",
+          "rfc-svg.xml" => "rfc-svg.svg",
+        }
+      end
+
+      def execute
+        puts Paint["🔧 Generating svgcheck outputs...", :blue, :bold]
+        puts Paint["📋 Mode: #{@mode}", :cyan]
+
+        # Ensure output directories exist
+        ensure_output_directories
+
+        if @single_file
+          generate_single_output(@single_file)
+        else
+          generate_all_outputs
+        end
+      end
+
+      private
+
+      def ensure_output_directories
+        case @mode
+        when "check"
+          FileUtils.mkdir_p(File.join(@fixtures_path, "check"))
+        when "repair"
+          FileUtils.mkdir_p(File.join(@fixtures_path, "repair"))
+        when "both"
+          FileUtils.mkdir_p(File.join(@fixtures_path, "check"))
+          FileUtils.mkdir_p(File.join(@fixtures_path, "repair"))
+        end
+      end
+
+      def generate_single_output(filename)
+        test_file_path = File.join(@test_dir, filename)
+
+        unless File.exist?(test_file_path)
+          puts Paint["❌ Test file not found: #{test_file_path}", :red]
+          return false
+        end
+
+        success = true
+
+        case @mode
+        when "check"
+          success = generate_mode_output(filename, "check")
+        when "repair"
+          success = generate_mode_output(filename, "repair")
+        when "both"
+          check_success = generate_mode_output(filename, "check")
+          repair_success = generate_mode_output(filename, "repair")
+          success = check_success && repair_success
+        end
+
+        if success
+          puts Paint["✅ Generated outputs for #{filename}", :green]
+        else
+          puts Paint["❌ Failed to generate outputs for #{filename}", :red]
+        end
+
+        success
+      end
+
+      def generate_mode_output(filename, mode)
+        test_file_path = File.join(@test_dir, filename)
+
+        # Apply file renaming if applicable
+        output_filename = @file_rename_map[filename] || filename
+        base_name = File.basename(output_filename, ".*")
+        extension = File.extname(output_filename)
+
+        # Create mode-specific output directory and base path
+        mode_dir = File.join(@fixtures_path, mode)
+        output_base = File.join(mode_dir, "#{base_name}#{extension}")
+
+        # Check if outputs already exist
+        expected_files = if mode == "repair"
+                           ["#{output_base}.out", "#{output_base}.err",
+                            "#{output_base}.code", "#{output_base}.file"]
+                         else
+                           ["#{output_base}.out", "#{output_base}.err",
+                            "#{output_base}.code"]
+                         end
+
+        if expected_files.any? { |f| File.exist?(f) } && !@force
+          puts Paint["⚠️  #{mode.capitalize} outputs already exist for #{filename} (use --force to overwrite)",
+                     :yellow]
+          return true
+        end
+
+        puts Paint["📄 Generating #{mode} outputs for #{filename}...", :cyan]
+
+        run_svgcheck_mode(test_file_path, output_base, mode)
+      end
+
+      def generate_all_outputs
+        test_files = find_test_files
+
+        if test_files.empty?
+          puts Paint["❌ No test files found in #{@test_dir}", :red]
+          return
+        end
+
+        puts Paint["📊 Found #{test_files.length} test files", :cyan]
+
+        success_count = 0
+        skip_count = 0
+        error_count = 0
+
+        test_files.each do |filename|
+          # Skip problematic files
+          if should_skip_file?(filename)
+            puts Paint["⏭️  Skipping #{filename} (too large or problematic)",
+                       :yellow]
+            skip_count += 1
+            next
+          end
+
+          if generate_single_output(filename)
+            success_count += 1
+          else
+            error_count += 1
+          end
+        end
+
+        puts "\n#{Paint['📈 GENERATION SUMMARY:', :blue, :bold]}"
+        puts "  ✅ Successfully generated: #{Paint[success_count.to_s, :green,
+                                                   :bold]}"
+        puts "  ⏭️  Skipped: #{Paint[skip_count.to_s, :yellow, :bold]}"
+        puts "  ❌ Failed: #{Paint[error_count.to_s, :red, :bold]}"
+        puts "  📁 Output directory: #{Paint[@fixtures_path, :cyan]}"
+
+        case @mode
+        when "check"
+          puts "  📂 Check outputs: #{Paint[File.join(@fixtures_path, 'check'),
+                                            :cyan]}"
+        when "repair"
+          puts "  📂 Repair outputs: #{Paint[File.join(@fixtures_path, 'repair'),
+                                             :cyan]}"
+        when "both"
+          puts "  📂 Check outputs: #{Paint[File.join(@fixtures_path, 'check'),
+                                            :cyan]}"
+          puts "  📂 Repair outputs: #{Paint[File.join(@fixtures_path, 'repair'),
+                                             :cyan]}"
+        end
+      end
+
+      def find_test_files
+        return [] unless Dir.exist?(@test_dir)
+
+        # Find all .svg and .xml files
+        pattern = File.join(@test_dir, "*.{svg,xml}")
+        Dir.glob(pattern).map { |path| File.basename(path) }.sort
+      end
+
+      def should_skip_file?(filename)
+        # Skip files that are known to be problematic
+        skip_patterns = [
+          /^full-tiny\.xml$/, # Too large
+          /^cache_saved/, # Cache directory
+        ]
+
+        skip_patterns.any? { |pattern| filename.match?(pattern) }
+      end
+
+      def run_svgcheck_mode(input_file, output_base, mode)
+        # Check if python3 is available
+        unless command_available?("python3")
+          puts Paint["❌ python3 not found. Please install Python 3.", :red]
+          return false
+        end
+
+        # Check if svgcheck module is available
+        unless Dir.exist?(@svgcheck_dir)
+          puts Paint["❌ svgcheck directory not found: #{@svgcheck_dir}", :red]
+          return false
+        end
+
+        begin
+          # Change to svgcheck directory to run the module
+          original_dir = Dir.pwd
+          Dir.chdir(@svgcheck_dir)
+
+          # Build command based on mode
+          relative_input = File.join("Tests", File.basename(input_file))
+          cmd = if mode == "repair"
+                  ["python3", "run.py", "--repair", relative_input]
+                else
+                  ["python3", "run.py", relative_input] # check mode - no --repair flag
+                end
+
+          puts "  Running #{mode}: #{cmd.join(' ')}" if @verbose
+
+          stdout, stderr, status = Open3.capture3(*cmd)
+
+          # Return to original directory
+          Dir.chdir(original_dir)
+
+          # svgcheck writes validation messages to stderr, save as .out (following existing convention)
+          File.write("#{output_base}.out", stderr)
+
+          # svgcheck writes any other errors to stderr, but we'll keep a separate .err for consistency
+          File.write("#{output_base}.err", "")
+
+          # Write exit code to .code file
+          File.write("#{output_base}.code", status.exitstatus.to_s)
+
+          # For repair mode, svgcheck writes remediated SVG content to stdout
+          # For check mode, stdout should be empty or minimal
+          File.write("#{output_base}.file", stdout) if mode == "repair"
+
+          puts "  #{mode.capitalize} exit status: #{status.exitstatus}" if @verbose
+          puts "  #{mode.capitalize} stdout lines: #{stdout.lines.count}" if @verbose
+          puts "  #{mode.capitalize} stderr lines: #{stderr.lines.count}" if @verbose
+
+          true
+        rescue StandardError => e
+          puts Paint["❌ Error running svgcheck in #{mode} mode: #{e.message}",
+                     :red]
+          # Make sure we return to original directory even on error
+          Dir.chdir(original_dir) if Dir.pwd != original_dir
+          false
+        end
+      end
+
+      # SECURITY: Prevent command injection by using array form of system()
+      # GitHub CodeQL: Uncontrolled command line (CWE-078)
+      # This affects svgcheck generation commands (development use only)
+      def command_available?(command)
+        # Use array form to prevent shell injection
+        system("which", command, out: File::NULL, err: File::NULL) ||
+          system("where", command, out: File::NULL, err: File::NULL) || # Windows
+          File.executable?(command) # Direct path check
+      end
+    end
+  end
+end

data/lib/svg_conform/compatibility/analysis_context.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module SvgConform
+  module Compatibility
+    # Value object representing the context and configuration for compatibility analysis
+    class AnalysisContext
+      attr_reader :mode, :profile, :semantic, :svgcheck_dir, :file, :output_file
+
+      def initialize(options = {})
+        @mode = (options[:mode] || "check").to_sym
+        @profile = options[:profile]&.to_sym || :svg_1_2_rfc_compatible
+        @semantic = options[:semantic] || false
+        @svgcheck_dir = options[:svgcheck_dir] || "spec/fixtures/svgcheck"
+        @file = options[:file]
+        @output_file = options[:output]
+      end
+
+      def single_file_analysis?
+        !@file.nil?
+      end
+
+      def batch_analysis?
+        @file.nil?
+      end
+
+      def check_mode?
+        @mode == :check
+      end
+
+      def repair_mode?
+        @mode == :repair
+      end
+
+      def semantic_analysis?
+        @semantic
+      end
+
+      def file_output?
+        !@output_file.nil?
+      end
+
+      def inputs_dir
+        File.join(@svgcheck_dir, "inputs")
+      end
+
+      def outputs_dir
+        File.join(@svgcheck_dir, @mode.to_s)
+      end
+
+      def input_file_path
+        return nil unless single_file_analysis?
+
+        File.join(inputs_dir, @file)
+      end
+
+      def to_h
+        {
+          mode: @mode,
+          profile: @profile,
+          semantic: @semantic,
+          svgcheck_dir: @svgcheck_dir,
+          file: @file,
+          output_file: @output_file,
+        }
+      end
+    end
+  end
+end

data/lib/svg_conform/compatibility/comparison_result.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module SvgConform
+  module Compatibility
+    # Value object representing the results of a compatibility comparison
+    class ComparisonResult
+      attr_reader :filename, :type, :validation_comparison, :content_comparison,
+                  :xml_equivalence, :svg_conform_result, :svgcheck_result
+
+      def initialize(filename:, type:, **options)
+        @filename = filename
+        @type = type
+        @validation_comparison = options[:validation_comparison]
+        @content_comparison = options[:content_comparison]
+        @xml_equivalence = options[:xml_equivalence]
+        @svg_conform_result = options[:svg_conform_result]
+        @svgcheck_result = options[:svgcheck_result]
+      end
+
+      def semantic_validation?
+        @type == :semantic_validation
+      end
+
+      def semantic_repair?
+        @type == :semantic_repair
+      end
+
+      def basic_validation?
+        @type == :basic_validation
+      end
+
+      def basic_repair?
+        @type == :basic_repair
+      end
+
+      def compatibility_score
+        return 0.0 unless @validation_comparison
+
+        raw_score = @validation_comparison[:compatibility_score] || 0.0
+        raw_score * 100.0
+      end
+
+      def validity_match?
+        return false unless @validation_comparison
+
+        @validation_comparison.dig(:overall_validity, :match) || false
+      end
+
+      def svg_conform_valid?
+        if semantic_validation? || semantic_repair?
+          @validation_comparison&.dig(:overall_validity, :svg_conform) || false
+        else
+          @svg_conform_result&.success? || false
+        end
+      end
+
+      def svgcheck_valid?
+        if semantic_validation? || semantic_repair?
+          @validation_comparison&.dig(:overall_validity, :svgcheck) || false
+        else
+          @svgcheck_result&.valid || false
+        end
+      end
+
+      def content_equivalence_score
+        return 0.0 unless @content_comparison
+
+        raw_score = @content_comparison[:semantic_equivalence] || 0.0
+        raw_score * 100.0
+      end
+
+      def xml_equivalent?
+        return false unless @xml_equivalence
+
+        @xml_equivalence[:xml_equivalent] || false
+      end
+
+      def xml_differences
+        return [] unless @xml_equivalence
+
+        @xml_equivalence[:differences] || []
+      end
+
+      def xml_error
+        return nil unless @xml_equivalence
+
+        @xml_equivalence[:error]
+      end
+
+      def successful_remediation?
+        if semantic_repair?
+          svg_conform_valid?
+        elsif basic_repair?
+          @svg_conform_result&.success? || false
+        else
+          false
+        end
+      end
+
+      def issues_fixed
+        return 0 unless basic_repair?
+
+        @svg_conform_result&.issues_fixed || 0
+      end
+
+      def remediations_applied
+        return 0 unless basic_repair?
+
+        @svg_conform_result&.remediations_applied || 0
+      end
+
+      def error_count
+        if semantic_validation? || semantic_repair?
+          # For semantic results, we'd need to extract from validation_comparison
+          0
+        else
+          # For basic repair mode, count initial validation errors
+          svg_conform_errors = if @svg_conform_result&.initial_validation
+                                 @svg_conform_result.initial_validation.failed_requirements.length
+                               else
+                                 0
+                               end
+
+          svgcheck_errors = @svgcheck_result&.errors&.total_count || 0
+
+          svg_conform_errors + svgcheck_errors
+        end
+      end
+
+      def to_h
+        {
+          filename: @filename,
+          type: @type,
+          compatibility_score: compatibility_score,
+          validity_match: validity_match?,
+          svg_conform_valid: svg_conform_valid?,
+          svgcheck_valid: svgcheck_valid?,
+          content_equivalence_score: content_equivalence_score,
+          xml_equivalent: xml_equivalent?,
+          successful_remediation: successful_remediation?,
+          issues_fixed: issues_fixed,
+          remediations_applied: remediations_applied,
+        }
+      end
+    end
+  end
+end

data/lib/svg_conform/compatibility/compatibility_analyzer.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "analysis_context"
+require_relative "comparison_result"
+require_relative "file_processor"
+require_relative "svg_analysis_engine"
+require_relative "xml_analysis_engine"
+require_relative "report_formatter"
+
+module SvgConform
+  module Compatibility
+    # Main orchestrator for compatibility analysis operations
+    class CompatibilityAnalyzer
+      def initialize(options = {})
+        @context = AnalysisContext.new(options)
+        @file_processor = FileProcessor.new(@context)
+        @svg_engine = SvgAnalysisEngine.new(@context, @file_processor)
+        @xml_engine = XmlAnalysisEngine.new(@context, @file_processor)
+        @formatter = ReportFormatter.new(@context)
+      end
+
+      def run_analysis
+        @file_processor.validate_environment
+
+        if @context.single_file_analysis?
+          run_single_file_analysis
+        else
+          run_batch_analysis
+        end
+      end
+
+      private
+
+      def run_single_file_analysis
+        filename = @context.file
+        result = analyze_single_file(filename)
+
+        if result
+          @formatter.display_single_file_result(result)
+          @formatter.write_output_file(result)
+        end
+
+        result
+      end
+
+      def run_batch_analysis
+        files = @file_processor.discover_files
+        results = []
+
+        files.each do |filename|
+          result = analyze_single_file(filename)
+          results << result if result
+        end
+
+        @formatter.display_batch_results(results)
+        @formatter.write_output_file(results)
+
+        results
+      end
+
+      def analyze_single_file(filename)
+        unless @file_processor.file_exists?(filename)
+          puts "❌ Input file not found: #{filename}"
+          return nil
+        end
+
+        svgcheck_report = @file_processor.parse_svgcheck_outputs(filename)
+        unless svgcheck_report
+          puts "❌ Svgcheck outputs not found for: #{filename}"
+          return nil
+        end
+
+        if @file_processor.xml_file?(filename)
+          @xml_engine.analyze_file(filename, svgcheck_report)
+        else
+          @svg_engine.analyze_file(filename, svgcheck_report)
+        end
+      rescue StandardError => e
+        puts "❌ Error analyzing #{filename}: #{e.message}"
+        puts e.backtrace.first(5).join("\n") if ENV["DEBUG"]
+        nil
+      end
+    end
+  end
+end