svg_conform 0.1.0

data/lib/svg_conform/commands/check.rb

@@ -0,0 +1,390 @@
+# frozen_string_literal: true
+
+require "paint"
+require "table_tennis"
+require "fileutils"
+require_relative "../batch_report"
+
+module SvgConform
+  module Commands
+    # Check command for validating SVG files (single or batch)
+    class Check
+      def initialize(files, options)
+        @files = Array(files)
+        @options = options
+      end
+
+      def execute
+        # Determine which files to process
+        files_to_process = determine_files
+
+        if files_to_process.empty?
+          puts Paint["Error: No SVG files found", :red]
+          exit 1
+        end
+
+        # Single file mode vs batch mode
+        if files_to_process.length == 1 && !@options[:directory]
+          process_single_file(files_to_process.first)
+        else
+          process_batch(files_to_process)
+        end
+      end
+
+      private
+
+      def determine_files
+        if @options[:directory]
+          # Directory mode: recursive scan
+          dir = @options[:directory]
+          unless Dir.exist?(dir)
+            puts Paint["Error: Directory '#{dir}' not found", :red]
+            exit 1
+          end
+          Dir.glob(File.join(dir, "**/*.svg")).sort
+        elsif @files.empty?
+          puts Paint["Error: No files or directory specified", :red]
+          exit 1
+          []
+        else
+          # File mode: validate each file exists
+          @files.each do |file|
+            unless File.exist?(file)
+              puts Paint["Error: File '#{file}' not found", :red]
+              exit 1
+            end
+          end
+          @files
+        end
+      end
+
+      def process_single_file(file)
+        @file = file
+
+        begin
+          # Validate the file
+          validator = SvgConform::Validator.new
+          result = validator.validate_file(@file,
+                                           profile: @options[:profile].to_sym)
+
+          # Generate report
+          report = SvgConform::ConformanceReport.from_svg_conform_result(
+            File.basename(@file),
+            result,
+            profile: @options[:profile].to_sym,
+          )
+
+          # Output based on format
+          case @options[:format]
+          when "yaml"
+            output_yaml(report)
+          when "json"
+            output_json(report)
+          else
+            output_table(report)
+          end
+
+          # Create remediated file if requested
+          create_remediated_file(result) if @options[:fix]
+
+          # Exit with appropriate code
+          exit(report.valid? ? 0 : 1)
+        rescue StandardError => e
+          puts Paint["Error: #{e.message}", :red]
+          exit 1
+        end
+      end
+
+      def output_table(report)
+        puts Paint["SVG Validation Report", :bold]
+        puts "=" * 50
+        puts "File: #{@file}"
+        puts "Profile: #{@options[:profile]}"
+        puts "Valid: #{report.valid? ? Paint['✓', :green] : Paint['✗', :red]}"
+        puts "Total Errors: #{report.errors.total_count}"
+        puts
+
+        if report.errors.total_count.positive?
+          puts Paint["Validation Errors:", :bold]
+          puts
+
+          # Group errors by type
+          error_groups = report.errors.issues.group_by(&:message)
+
+          error_groups.each do |message, errors|
+            puts Paint["• #{message}", :red]
+            if errors.size > 1
+              puts Paint["  (#{errors.size} occurrences)",
+                         :black]
+            end
+
+            # Show first few locations
+            errors.first(3).each do |error|
+              puts Paint["    at #{error.element}", :black] if error.element
+            end
+
+            if errors.size > 3
+              puts Paint["    ... and #{errors.size - 3} more",
+                         :black]
+            end
+            puts
+          end
+        else
+          puts Paint["✓ No validation errors found", :green]
+        end
+      end
+
+      def output_yaml(report)
+        output = report.to_yaml
+        write_output(output)
+      end
+
+      def output_json(report)
+        write_output(report.to_json)
+      end
+
+      def write_output(content)
+        if @options[:output]
+          File.write(@options[:output], content)
+          puts Paint["Report written to #{@options[:output]}", :green]
+        else
+          puts content
+        end
+      end
+
+      def process_batch(files)
+        puts Paint["Batch Processing", :bold]
+        puts "=" * 80
+        puts "Files: #{files.length}"
+        puts "Profile: #{@options[:profile]}"
+        puts "=" * 80
+        puts
+
+        # Initialize batch report
+        batch_report = BatchReport.new
+        batch_report.directory = @options[:directory] || File.dirname(files.first)
+        batch_report.profile = @options[:profile]
+
+        # Validate output directory if fixing
+        if @options[:fix]
+          validate_output_options(files)
+          prepare_output_directory
+        end
+
+        # Process each file
+        files.each_with_index do |file, index|
+          unless @options[:quiet]
+            puts "[#{index + 1}/#{files.length}] #{File.basename(file)}"
+          end
+
+          file_result = process_file_for_batch(file)
+          batch_report.files << file_result
+
+          # Update manifest if remediated
+          if file_result.remediated_path
+            batch_report.manifest[file] = file_result.remediated_path
+          end
+        end
+
+        # Calculate statistics
+        batch_report.calculate_statistics
+
+        # Output results
+        output_batch_results(batch_report)
+
+        # Create manifest file if requested or if fixing
+        create_manifest_file(batch_report) if @options[:manifest] || @options[:fix]
+
+        # Exit with appropriate code
+        exit(batch_report.failed.zero? ? 0 : 1)
+      end
+
+      def process_file_for_batch(file)
+        file_result = FileResult.new
+        file_result.filename = File.basename(file)
+        file_result.original_path = file
+
+        begin
+          # Initial validation
+          validator = SvgConform::Validator.new
+          initial_result = validator.validate_file(file,
+                                                   profile: @options[:profile].to_sym)
+
+          file_result.valid_before = initial_result.valid?
+          file_result.errors_before = initial_result.errors.count
+
+          unless @options[:quiet]
+            if initial_result.valid?
+              puts "  ✓ Already valid"
+            else
+              puts "  ✗ Invalid: #{initial_result.errors.count} errors"
+            end
+          end
+
+          # Handle remediation if requested
+          if @options[:fix] && !initial_result.valid?
+            profile = SvgConform::Profiles.get(@options[:profile].to_sym)
+            runner = SvgConform::RemediationRunner.new(profile: profile)
+            remediation_result = runner.run_remediation_file(file)
+
+            if remediation_result.remediated_content
+              output_path = determine_output_path(file)
+              File.write(output_path, remediation_result.remediated_content)
+
+              file_result.valid_after = remediation_result.final_validation.valid?
+              file_result.errors_after = remediation_result.final_validation.errors.count
+              file_result.remediated_path = output_path
+              file_result.status = file_result.valid_after ? "remediated" : "failed"
+
+              unless @options[:quiet]
+                if file_result.valid_after
+                  puts "  ✓ Remediated successfully"
+                else
+                  puts "  ⚠ #{file_result.errors_after} errors remain"
+                end
+              end
+            else
+              file_result.valid_after = false
+              file_result.errors_after = initial_result.errors.count
+              file_result.status = "failed"
+              unless @options[:quiet]
+                puts "  ✗ Remediation failed"
+              end
+            end
+          else
+            # No remediation requested or already valid
+            file_result.valid_after = file_result.valid_before
+            file_result.errors_after = file_result.errors_before
+            file_result.status = file_result.valid_before ? "valid" : "failed"
+          end
+        rescue StandardError => e
+          file_result.status = "error"
+          file_result.error_message = e.message
+          file_result.valid_after = false
+          file_result.errors_after = -1
+          unless @options[:quiet]
+            puts "  ✗ Error: #{e.message}"
+          end
+        end
+
+        file_result
+      end
+
+      def validate_output_options(files)
+        return if @options[:in_place]
+
+        # Multiple files require output-dir
+        if files.length > 1 && !@options[:output_dir]
+          puts Paint["Error: --output-dir required for multiple files with --fix",
+                     :red]
+          exit 1
+        end
+
+        # In-place requires force
+        if @options[:in_place] && !@options[:force]
+          puts Paint["Error: --in-place requires --force flag for safety", :red]
+          exit 1
+        end
+      end
+
+      def prepare_output_directory
+        return if @options[:in_place]
+
+        output_dir = @options[:output_dir]
+        if output_dir
+          FileUtils.mkdir_p(output_dir)
+        end
+      end
+
+      def determine_output_path(file)
+        if @options[:in_place]
+          file
+        elsif @options[:output_dir]
+          File.join(@options[:output_dir], File.basename(file))
+        else
+          "#{file}.fixed.svg"
+        end
+      end
+
+      def output_batch_results(batch_report)
+        puts
+        puts "=" * 80
+        puts Paint["BATCH VALIDATION SUMMARY", :bold]
+        puts "=" * 80
+        puts "Directory: #{batch_report.directory}"
+        puts "Profile: #{batch_report.profile}"
+        puts "Files processed: #{batch_report.total_files}"
+        puts "Valid before: #{batch_report.valid_before}"
+        if @options[:fix]
+          puts "Remediated: #{batch_report.remediated}"
+        end
+        puts "Valid after: #{batch_report.valid_after}"
+        puts "Failed: #{batch_report.failed}"
+        puts "Success rate: #{batch_report.success_rate}%"
+        puts "=" * 80
+
+        # Output detailed report if requested
+        if @options[:report_format] && @options[:report_output]
+          case @options[:report_format]
+          when "json"
+            File.write(@options[:report_output], batch_report.to_json)
+            puts Paint["Detailed JSON report written to #{@options[:report_output]}",
+                       :green]
+          when "yaml"
+            File.write(@options[:report_output], batch_report.to_yaml)
+            puts Paint["Detailed YAML report written to #{@options[:report_output]}",
+                       :green]
+          end
+        end
+      end
+
+      def create_manifest_file(batch_report)
+        return if batch_report.manifest.empty?
+
+        manifest_path = @options[:manifest] || "manifest.json"
+        manifest_data = {
+          timestamp: batch_report.timestamp,
+          profile: batch_report.profile,
+          mappings: batch_report.manifest,
+        }
+
+        File.write(manifest_path, JSON.pretty_generate(manifest_data))
+        puts Paint["Manifest written to #{manifest_path}", :green]
+      end
+
+      def create_remediated_file(_result)
+        # Load the profile for remediation
+        profile = SvgConform::Profiles.get(@options[:profile].to_sym)
+
+        # Create remediation runner
+        runner = SvgConform::RemediationRunner.new(profile: profile)
+
+        # Run remediation
+        remediation_result = runner.run_remediation_file(@file)
+
+        if remediation_result.success? && remediation_result.remediated_content
+          output_file = @options[:fix_output] || "#{@file}.fixed.svg"
+          File.write(output_file, remediation_result.remediated_content)
+          puts Paint["Remediated file written to #{output_file}", :green]
+
+          # Show remediation summary
+          if remediation_result.issues_fixed.positive?
+            puts Paint["✓ Fixed #{remediation_result.issues_fixed} issue(s)",
+                       :green]
+          else
+            puts Paint["No issues were fixed (file may already be valid)",
+                       :yellow]
+          end
+        else
+          puts Paint["Warning: Could not create remediated file", :yellow]
+          if remediation_result.error?
+            puts Paint["Error: #{remediation_result.error.message}",
+                       :red]
+          end
+        end
+      rescue StandardError => e
+        puts Paint["Error creating remediated file: #{e.message}", :red]
+      end
+    end
+  end
+end

data/lib/svg_conform/commands/profiles.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "paint"
+require "table_tennis"
+
+module SvgConform
+  module Commands
+    # Profiles command for listing available validation profiles
+    class Profiles
+      def initialize(options)
+        @options = options
+        # Paint doesn't need initialization like Pastel
+      end
+
+      def execute
+        profiles = load_available_profiles
+
+        if @options[:verbose]
+          display_detailed_profiles(profiles)
+        else
+          display_profile_list(profiles)
+        end
+      rescue StandardError => e
+        puts Paint["Error: #{e.message}", :red]
+        exit 1
+      end
+
+      private
+
+      def load_available_profiles
+        # Get all profile files
+        profile_dir = File.join(File.dirname(__FILE__),
+                                "../../../config/profiles")
+        profile_files = Dir.glob(File.join(profile_dir, "*.yml"))
+
+        profiles = {}
+
+        profile_files.each do |file|
+          name = File.basename(file, ".yml")
+          begin
+            profile = SvgConform::Profile.load_from_file(file)
+            profiles[name] = profile
+          rescue StandardError => e
+            puts Paint["Warning: Could not load profile '#{name}': #{e.message}",
+                       :yellow]
+          end
+        end
+
+        profiles
+      end
+
+      def display_profile_list(profiles)
+        puts Paint["Available SVG Profiles", :bold]
+        puts "=" * 40
+        puts
+
+        if profiles.empty?
+          puts Paint["No profiles found", :yellow]
+          return
+        end
+
+        # Create table data - table_tennis handles its own formatting
+        table_data = profiles.map do |name, profile|
+          description = profile.description || "No description available"
+          { profile: name, description: description }
+        end
+
+        # Use table_tennis with headers option
+        table = TableTennis.new(table_data,
+                                headers: { profile: "Profile",
+                                           description: "Description" })
+        puts table
+        puts
+        puts Paint["Use --verbose for detailed information about each profile",
+                   :black]
+      end
+
+      def display_detailed_profiles(profiles)
+        puts Paint["Detailed SVG Validation Profiles", :bold]
+        puts "=" * 50
+        puts
+
+        profiles.each do |name, profile|
+          puts Paint["Profile: #{name}", :bold]
+          puts Paint["-" * 30, :black]
+
+          puts "Description: #{profile.description || 'No description available'}"
+          puts "Requirements: #{profile.requirement_count}"
+          puts "Remediations: #{profile.remediation_count}"
+
+          if profile.requirements&.any?
+            puts "Requirement Details:"
+            profile.requirements.each do |requirement|
+              puts "  • #{requirement.class.name.split('::').last}"
+              if requirement.respond_to?(:description) && requirement.description
+                puts Paint["    #{requirement.description}",
+                           :black]
+              end
+            end
+          end
+
+          if profile.remediations&.any?
+            puts "Remediation Details:"
+            profile.remediations.each do |remediation|
+              puts "  • #{remediation.class.name.split('::').last}"
+              if remediation.respond_to?(:description) && remediation.description
+                puts Paint["    #{remediation.description}",
+                           :black]
+              end
+            end
+          end
+
+          puts
+        end
+      end
+    end
+  end
+end

data/lib/svg_conform/commands/svgcheck.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "thor"
+require "paint"
+require_relative "svgcheck_compare"
+require_relative "svgcheck_compatibility"
+require_relative "svgcheck_generate"
+
+module SvgConform
+  module Commands
+    # Svgcheck subcommand for svgcheck-related operations
+    class Svgcheck < Thor
+      desc "compare FILE", "Compare SvgConform validation with svgcheck report"
+      long_desc <<~DESC
+        Compare SvgConform validation results with existing svgcheck reports.
+
+        This command looks for a corresponding .svgcheck.yaml file and compares
+        the validation results, showing differences in a detailed table format.
+      DESC
+      option :profile, aliases: "-p", default: "svg_1_2_rfc",
+                       desc: "Profile to validate against"
+      option :svgcheck_report,
+             desc: "Path to svgcheck report (default: auto-detect)"
+      def compare(file)
+        SvgConform::Commands::SvgcheckCompare.new(file, options).execute
+      end
+
+      desc "compatibility", "Run comprehensive svgcheck compatibility analysis"
+      long_desc <<~DESC
+        Run a comprehensive analysis comparing SvgConform validation results
+        with svgcheck outputs in check or repair mode.
+
+        MODES:
+        - check: Compare validation results using svgcheck check mode outputs
+        - repair: Compare remediation results using svgcheck repair mode outputs
+
+        Use --file to analyze a specific file instead of all test files.
+        Use --svgcheck-dir to specify where to find svgcheck outputs.
+
+        Examples:
+          svg_conform svgcheck compatibility --mode check
+          svg_conform svgcheck compatibility --file viewBox-none.svg
+      DESC
+      option :profile, aliases: "-p", default: "svg_1_2_rfc",
+                       desc: "Profile to validate against"
+      option :output, aliases: "-o", desc: "Output file for detailed report"
+      option :file, aliases: "-f",
+                    desc: "Analyze specific file instead of all test files"
+      option :mode, aliases: "-m", default: "check", enum: %w[check repair],
+                    desc: "Comparison mode: check or repair"
+      option :semantic, type: :boolean, default: false,
+                        desc: "Use semantic comparison"
+      option :svgcheck_dir, aliases: "-d", default: "spec/fixtures/svgcheck",
+                            desc: "Directory containing svgcheck outputs"
+      def compatibility
+        SvgConform::Commands::SvgcheckCompatibility.new(options).execute
+      end
+
+      desc "generate SVGCHECK_REPO_PATH", "Generate svgcheck outputs"
+      long_desc <<~DESC
+        Generate svgcheck outputs for test files by running svgcheck on them.
+
+        SVGCHECK_REPO_PATH: Path to the svgcheck repository (e.g., svgcheck-reference)
+
+        By default, processes all test files in SVGCHECK_REPO_PATH/svgcheck/Tests/
+        and generates BOTH check and repair outputs in separate subdirectories.
+
+        Examples:
+          svg_conform svgcheck generate svgcheck-reference
+          svg_conform svgcheck generate svgcheck-reference --mode check
+          svg_conform svgcheck generate svgcheck-reference --single-file example.svg
+      DESC
+      option :mode, aliases: "-m", default: "both", enum: %w[check repair both],
+                    desc: "Generation mode: check, repair, or both"
+      option :svgcheck_exec,
+             desc: "Path to svgcheck executable"
+      option :fixtures_path,
+             desc: "Output directory (default: spec/fixtures/svgcheck)"
+      option :single_file, aliases: "-f", desc: "Process single file only"
+      option :force, type: :boolean, default: false,
+                     desc: "Overwrite existing outputs"
+      option :verbose, aliases: "-v", type: :boolean, default: false,
+                       desc: "Verbose output"
+      def generate(svgcheck_repo_path)
+        SvgConform::Commands::SvgcheckGenerate.new(svgcheck_repo_path,
+                                                   options).execute
+      end
+    end
+  end
+end

data/lib/svg_conform/commands/svgcheck_compare.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "paint"
+
+module SvgConform
+  module Commands
+    # Compare command for comparing SvgConform validation with svgcheck reports
+    class SvgcheckCompare
+      def initialize(file, options)
+        @file = file
+        @options = options
+        # Paint doesn't need initialization like Pastel
+      end
+
+      def execute
+        # Determine the correct file to validate
+        validation_file = determine_validation_file(@file)
+
+        unless File.exist?(validation_file)
+          puts Paint["Error: File '#{validation_file}' not found", :red]
+          exit 1
+        end
+
+        begin
+          # Find or use specified svgcheck report
+          svgcheck_report_path = find_svgcheck_report
+          unless svgcheck_report_path && File.exist?(svgcheck_report_path)
+            puts Paint["Error: svgcheck report not found", :red]
+            if svgcheck_report_path
+              puts Paint["Expected: #{svgcheck_report_path}",
+                         :dim]
+            end
+            exit 1
+          end
+
+          # Load svgcheck report using the new external checker parser
+          parser = SvgConform::ExternalCheckers::Svgcheck::Parser.new
+          error_content = File.read(svgcheck_report_path)
+          svgcheck_report = parser.parse(error_content, nil,
+                                         filename: File.basename(@file))
+
+          # Generate SvgConform report using the correct validation file
+          validator = SvgConform::Validator.new
+          result = validator.validate_file(validation_file,
+                                           profile: @options[:profile].to_sym)
+          svg_conform_report = SvgConform::ConformanceReport.from_svg_conform_result(
+            File.basename(@file),
+            result,
+            profile: @options[:profile].to_sym,
+          )
+
+          # Compare the reports
+          comparator = SvgConform::ReportComparator.new
+          comparator.compare_reports(svg_conform_report, svgcheck_report,
+                                     File.basename(@file))
+        rescue StandardError => e
+          puts Paint["Error: #{e.message}", :red]
+          exit 1
+        end
+      end
+
+      private
+
+      def determine_validation_file(file)
+        # If the file is in a Results directory, try to find the original in Tests directory
+        if file.include?("/Results/")
+          test_file = file.gsub("/Results/", "/Tests/")
+          return test_file if File.exist?(test_file)
+        end
+
+        # Otherwise use the original file
+        file
+      end
+
+      def find_svgcheck_report
+        return @options[:svgcheck_report] if @options[:svgcheck_report]
+
+        # Auto-detect based on file name
+        base_name = File.basename(@file)
+
+        # Try common locations
+        possible_paths = [
+          "spec/fixtures/svgcheck_reports/#{base_name}.svgcheck.yaml",
+          "#{File.dirname(@file)}/#{base_name}.svgcheck.yaml",
+          "#{@file}.svgcheck.yaml",
+        ]
+
+        possible_paths.find { |path| File.exist?(path) }
+      end
+    end
+  end
+end