svg_conform 0.1.0

data/lib/svg_conform/external_checkers/svgcheck/compatibility_engine.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module SvgConform
+  module ExternalCheckers
+    module Svgcheck
+      # Compatibility engine for matching svg_conform behavior to svgcheck
+      class CompatibilityEngine
+        def initialize
+          # Load any compatibility-specific configuration
+        end
+
+        # Check if file should be treated as unparseable by svgcheck
+        def should_mimic_parse_failure?(_filename, _validation_result)
+          # Implement parse failure detection logic based on svgcheck behavior
+          # For now, return false - this would need to be enhanced based on actual svgcheck behavior
+          false
+        end
+
+        # Check if validity errors should be included as regular errors (for svgcheck compatibility)
+        def should_include_validity_errors?(validation_result, filename)
+          # Include validity errors if both width and height are present
+          # This matches svgcheck's behavior from the mapping config
+          return false unless validation_result.validity_errors.any?
+
+          # Check for specific datatype condition mentioned in mapping config
+          has_width_and_height_datatype_condition?(validation_result, filename)
+        end
+
+        # Filter errors for svgcheck compatibility
+        def filter_errors_for_svgcheck(errors, _filename, _validation_result)
+          filtered_errors = []
+
+          errors.each do |error|
+            # Skip namespace_validation errors only for RDF/metadata namespaces
+            # svgcheck skips these silently, but reports other namespace errors
+            # Only skip RDF-related namespace errors
+            if (error.requirement_id == "namespace_validation") && rdf_namespace_error?(error)
+              next
+            end
+
+            # Map svg_conform requirement IDs to svgcheck-compatible ones
+            mapped_req_id = map_requirement_id(error.requirement_id)
+            next if mapped_req_id.nil? # Skip unmapped requirements
+
+            filtered_errors << [error, mapped_req_id]
+          end
+
+          filtered_errors
+        end
+
+        private
+
+        def rdf_namespace_error?(error)
+          return false unless error.respond_to?(:message)
+
+          # List of RDF/metadata namespaces that svgcheck silently skips
+          rdf_namespaces = [
+            "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+            "http://creativecommons.org/ns#",
+            "http://purl.org/dc/elements/1.1/",
+            "http://purl.org/dc/dcmitype/",
+            "http://www.w3.org/2000/01/rdf-schema#",
+          ]
+
+          rdf_namespaces.any? { |ns| error.message.include?(ns) }
+        end
+
+        def has_width_and_height_datatype_condition?(validation_result,
+_filename)
+          # This would need to be implemented based on the specific logic
+          # mentioned in the mapping config's "datatype_condition": "both_width_and_height_present"
+          # For now, return true if there are validity errors
+          validation_result.validity_errors.any?
+        end
+
+        def map_requirement_id(requirement_id)
+          # Map svg_conform requirement IDs to svgcheck-compatible requirement IDs
+          mapping = {
+            "allowed_elements" => "allowed_elements",
+            # forbidden_content not mapped - it's redundant with allowed_elements checks
+            "namespace_attributes" => "namespace_attributes",
+            "namespace_validation" => "namespace_attributes", # Map to closest equivalent
+            "font_family" => "style", # svgcheck reports font-family issues as style errors
+            "color_restrictions" => "color_restrictions",
+            "viewbox_required" => "viewbox_required",
+            "style" => "style", # Direct mapping for StyleRequirement
+            "style_promotion" => "style",
+            "style_syntax" => "style",
+            "style_validation" => "style",
+            "property_value" => "style",
+            "required_attribute" => "viewbox_required",
+            "namespace" => "namespace_attributes",
+          }
+
+          # Return nil for unmapped requirements (like invalid_id_references)
+          mapping[requirement_id.to_s]
+        end
+
+        # Extract semantic meaning from error for comparison
+        def extract_semantic_meaning(error)
+          # Ensure we have a valid error object
+          return "unknown" unless error.respond_to?(:message) && error.respond_to?(:requirement_id)
+
+          # Try to create a semantic key based on the error type and context
+          requirement = error.requirement_id
+          message = error.message
+
+          # Handle different types of errors semantically
+          case requirement
+          when "color_restrictions"
+            # Extract color and attribute for semantic grouping
+            if message&.include?("doesn't allow") && (match = message.match(/attribute ['"]([^'"]+)['"].*value ['"]([^'"]+)['"]/))
+              attribute = match[1]
+              value = match[2]
+              "color_restriction:#{attribute}:#{value}"
+            else
+              requirement
+            end
+          when "font_family"
+            # Group font family errors by attribute and font
+            if message&.include?("font-family") && (match = message.match(/font-family.*['"]([^'"]+)['"]/))
+              font = match[1]
+              "font_restriction:#{font}"
+            else
+              requirement
+            end
+          when "allowed_elements"
+            # Group by element type
+            if message&.include?("not allowed") && (match = message.match(/Element ['"]([^'"]+)['"]/))
+              element = match[1]
+              "element_not_allowed:#{element}"
+            elsif message&.include?("does not allow the attribute") && (match = message.match(/element ['"]([^'"]+)['"].*attribute ['"]([^'"]+)['"]/))
+              element = match[1]
+              attribute = match[2]
+              "invalid_attribute:#{element}:#{attribute}"
+            else
+              requirement
+            end
+          when "namespace_attributes"
+            # Group by namespace issues
+            if message&.include?("namespace") && (match = message.match(/namespace ['"]([^'"]+)['"]/))
+              namespace = match[1]
+              "namespace_issue:#{namespace}"
+            else
+              requirement
+            end
+          when "viewbox_required"
+            # ViewBox is generally consistent
+            "viewbox_required"
+          when "style"
+            # Group style issues by property
+            if message&.include?("style") && (match = message.match(/property ['"]([^'"]+)['"]/))
+              property = match[1]
+              "style_issue:#{property}"
+            else
+              requirement
+            end
+          else
+            # Fallback to requirement_id for other cases
+            requirement || "unknown"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/svg_conform/external_checkers/svgcheck/output_generator.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "open3"
+require "fileutils"
+
+module SvgConform
+  module ExternalCheckers
+    module Svgcheck
+      # Generates svgcheck outputs for comparison testing
+      class OutputGenerator
+        attr_reader :svgcheck_exec, :svgcheck_path
+
+        def initialize(svgcheck_exec: "python3",
+svgcheck_path: "svgcheck/svgcheck")
+          @svgcheck_exec = svgcheck_exec
+          @svgcheck_path = svgcheck_path
+        end
+
+        # Generate svgcheck outputs for a given input file
+        def generate(input_file, mode: :both)
+          results = {}
+
+          case mode
+          when :check
+            results[:check] = generate_mode_output(input_file, :check)
+          when :repair
+            results[:repair] = generate_mode_output(input_file, :repair)
+          when :both
+            results[:check] = generate_mode_output(input_file, :check)
+            results[:repair] = generate_mode_output(input_file, :repair)
+          else
+            raise ArgumentError,
+                  "Invalid mode: #{mode}. Must be :check, :repair, or :both"
+          end
+
+          results
+        end
+
+        private
+
+        def generate_mode_output(input_file, mode)
+          unless available?
+            return {
+              success: false,
+              error: "svgcheck not available (#{@svgcheck_exec} or #{@svgcheck_path} not found)",
+            }
+          end
+
+          begin
+            # Change to svgcheck directory to run the module
+            original_dir = Dir.pwd
+            Dir.chdir(@svgcheck_path)
+
+            # Build command based on mode
+            relative_input = File.join("Tests", File.basename(input_file))
+            cmd = if mode == :repair
+                    [@svgcheck_exec, "run.py", "--repair", relative_input]
+                  else
+                    [@svgcheck_exec, "run.py", relative_input] # check mode - no --repair flag
+                  end
+
+            stdout, stderr, status = Open3.capture3(*cmd)
+
+            # Return to original directory
+            Dir.chdir(original_dir)
+
+            {
+              success: true,
+              stdout: stdout,
+              stderr: stderr,
+              exit_code: status.exitstatus,
+              mode: mode,
+            }
+          rescue StandardError => e
+            # Make sure we return to original directory even on error
+            Dir.chdir(original_dir) if Dir.pwd != original_dir
+
+            {
+              success: false,
+              error: "Error running svgcheck in #{mode} mode: #{e.message}",
+            }
+          end
+        end
+
+        def available?
+          command_available?(@svgcheck_exec) && Dir.exist?(@svgcheck_path)
+        end
+
+        # SECURITY: Prevent command injection by using array form of system()
+        # GitHub CodeQL: Uncontrolled command line (CWE-078)
+        # This affects svgcheck comparison 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
+end

data/lib/svg_conform/external_checkers/svgcheck/parser.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module SvgConform
+  module ExternalCheckers
+    module Svgcheck
+      # Enhanced svgcheck output parser that uses mapping configuration
+      class Parser
+        attr_reader :mapping_config
+
+        def initialize(mapping_config_path = nil)
+          @mapping_config_path = mapping_config_path || "config/svgcheck_mapping.yml"
+          load_mapping_config
+        end
+
+        # Parse svgcheck output into a ConformanceReport
+        def parse(output_content, _error_content = nil, filename: nil)
+          return create_empty_report(filename) if output_content.nil? || output_content.strip.empty?
+
+          errors = parse_error_lines(output_content)
+          create_report_from_errors(errors, filename)
+        end
+
+        private
+
+        def load_mapping_config
+          @mapping_config = if File.exist?(@mapping_config_path)
+                              YAML.load_file(@mapping_config_path)
+                            else
+                              # Fallback to empty config if file doesn't exist
+                              {
+                                "message_patterns" => [],
+                                "requirement_mappings" => {},
+                                "skip_patterns" => [],
+                                "special_rules" => {},
+                              }
+                            end
+        end
+
+        def parse_error_lines(content)
+          errors = []
+
+          content.each_line do |line|
+            line = line.strip
+            next if line.empty?
+            next if should_skip_line?(line)
+
+            # Try to match against message patterns
+            matched_error = match_against_patterns(line)
+            errors << if matched_error
+                        matched_error
+                      else
+                        # Fallback to basic error structure for unmapped errors
+                        create_unmapped_error(line)
+                      end
+          end
+
+          errors
+        end
+
+        def should_skip_line?(line)
+          return false unless @mapping_config["skip_patterns"]
+
+          @mapping_config["skip_patterns"].each do |skip_pattern|
+            pattern = skip_pattern["pattern"]
+            flags = skip_pattern["flags"]
+
+            regex_flags = 0
+            regex_flags |= Regexp::IGNORECASE if flags&.include?("i")
+
+            if line.match?(Regexp.new(pattern, regex_flags))
+              return true
+            end
+          end
+
+          false
+        end
+
+        def match_against_patterns(line)
+          return nil unless @mapping_config["message_patterns"]
+
+          @mapping_config["message_patterns"].each do |pattern_config|
+            pattern = pattern_config["pattern"]
+            requirement = pattern_config["requirement"]
+            semantic_key = pattern_config["semantic_key"]
+
+            match = line.match(Regexp.new(pattern))
+            next unless match
+
+            # Skip patterns that map to null requirement (unmapped errors)
+            return nil if requirement.nil?
+
+            return create_mapped_error(line, requirement, semantic_key, match)
+          end
+
+          nil
+        end
+
+        def create_mapped_error(line, requirement_id, semantic_key, match)
+          # Substitute regex groups in semantic key
+          processed_semantic_key = semantic_key
+          if semantic_key && match.captures.any?
+            match.captures.each_with_index do |capture, index|
+              processed_semantic_key = processed_semantic_key.gsub(
+                "${#{index + 1}}", capture || ""
+              )
+            end
+          end
+
+          # Apply requirement_mappings to normalize requirement IDs
+          normalized_requirement_id = apply_requirement_mapping(requirement_id)
+
+          issue = SvgConform::ConformanceIssue.new
+          issue.type = "error"
+          issue.requirement_id = normalized_requirement_id
+          issue.message = line
+
+          # Extract semantic information from the match
+          if (match.captures.length >= 1) && match.captures[0]
+            issue.attribute = match.captures[0]
+          end
+          if (match.captures.length >= 2) && match.captures[1]
+            issue.value = match.captures[1]
+          end
+          if (match.captures.length >= 3) && match.captures[2]
+            issue.element = match.captures[2]
+          end
+
+          issue
+        end
+
+        def apply_requirement_mapping(requirement_id)
+          return requirement_id unless @mapping_config["requirement_mappings"]
+
+          # Apply requirement_mappings to normalize requirement IDs
+          mappings = @mapping_config["requirement_mappings"]
+          mappings[requirement_id.to_s] || requirement_id
+        end
+
+        def create_unmapped_error(line)
+          issue = SvgConform::ConformanceIssue.new
+          issue.type = "error"
+          issue.requirement_id = "unmapped_svgcheck_error"
+          issue.message = line
+          issue
+        end
+
+        def create_report_from_errors(errors, filename)
+          report = SvgConform::ConformanceReport.new
+          report.filename = filename
+          report.tool = "svgcheck"
+          report.timestamp = Time.now.iso8601
+          report.valid = errors.empty?
+
+          # Initialize summaries
+          report.errors = SvgConform::IssueSummary.new
+          report.errors.total_count = errors.length
+          report.errors.by_requirement = {}
+          report.errors.issues = errors
+
+          report.warnings = SvgConform::IssueSummary.new
+          report.warnings.total_count = 0
+          report.warnings.by_requirement = {}
+          report.warnings.issues = []
+
+          # Group errors by requirement
+          if errors.any?
+            error_groups = errors.group_by(&:requirement_id)
+            error_groups.each do |req_id, req_errors|
+              report.errors.by_requirement[req_id] = req_errors.length
+            end
+          end
+
+          report
+        end
+
+        def create_empty_report(filename)
+          report = SvgConform::ConformanceReport.new
+          report.filename = filename
+          report.tool = "svgcheck"
+          report.timestamp = Time.now.iso8601
+          report.valid = true
+
+          report.errors = SvgConform::IssueSummary.new
+          report.errors.total_count = 0
+          report.errors.by_requirement = {}
+          report.errors.issues = []
+
+          report.warnings = SvgConform::IssueSummary.new
+          report.warnings.total_count = 0
+          report.warnings.by_requirement = {}
+          report.warnings.issues = []
+
+          report
+        end
+      end
+    end
+  end
+end

data/lib/svg_conform/external_checkers/svgcheck/report_comparator.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require_relative "../../conformance_report"
+require_relative "../../validator"
+require_relative "../../profiles"
+
+module SvgConform
+  module ExternalCheckers
+    module Svgcheck
+      # Sophisticated report comparison mechanism for svg_conform vs svgcheck
+      class ReportComparator
+        attr_reader :test_files_dir, :svgcheck_outputs_dir
+
+        def initialize(test_files_dir: "svgcheck/svgcheck/Tests",
+svgcheck_outputs_dir: "spec/fixtures/svgcheck")
+          @test_files_dir = test_files_dir
+          @svgcheck_outputs_dir = svgcheck_outputs_dir
+        end
+
+        # Compare all test files between svg_conform and svgcheck
+        def compare_all_test_files
+          test_files = find_test_files
+
+          results = {
+            total_files: test_files.length,
+            matching: 0,
+            different: 0,
+            errors: 0,
+            differences: {},
+          }
+
+          test_files.each do |filename|
+            comparison = compare_file(filename)
+
+            if comparison[:identical]
+              results[:matching] += 1
+            else
+              results[:different] += 1
+              results[:differences][filename] = comparison
+            end
+          rescue StandardError => e
+            results[:errors] += 1
+            results[:differences][filename] = {
+              error: e.message,
+              summary: "Error during comparison: #{e.message}",
+            }
+          end
+
+          results
+        end
+
+        # Compare a single file between svg_conform and svgcheck
+        def compare_file(filename)
+          svg_conform_report = generate_svg_conform_report(filename)
+          svgcheck_report = load_svgcheck_report(filename)
+
+          unless svgcheck_report
+            return { error: "No svgcheck report found",
+                     identical: false }
+          end
+
+          # Perform detailed comparison
+          comparison = svg_conform_report.compare_with(svgcheck_report)
+
+          # Add semantic comparison
+          semantic_comparison = perform_semantic_comparison(svg_conform_report,
+                                                            svgcheck_report)
+          comparison[:semantic] = semantic_comparison
+
+          comparison
+        end
+
+        private
+
+        def find_test_files
+          return [] unless Dir.exist?(@test_files_dir)
+
+          pattern = File.join(@test_files_dir, "*.{svg,xml}")
+          Dir.glob(pattern).map { |path| File.basename(path) }.sort
+        end
+
+        def generate_svg_conform_report(filename)
+          input_file = File.join(@test_files_dir, filename)
+          return nil unless File.exist?(input_file)
+
+          # Load svg_1_2_rfc profile
+          profile = SvgConform::Profiles.load_profile(:svg_1_2_rfc)
+
+          # Validate using svg_conform
+          validator = SvgConform::Validator.new(profile)
+          validation_result = validator.validate_file(input_file)
+
+          # Create report with svgcheck mapping for compatibility
+          ConformanceReport.from_svg_conform_result(
+            filename,
+            validation_result,
+            profile: "svg_1_2_rfc",
+            use_svgcheck_mapping: true,
+          )
+        end
+
+        def load_svgcheck_report(filename)
+          base_name = File.basename(filename, ".*")
+          extension = File.extname(filename)
+
+          # Try to load from check mode first, then repair mode
+          check_error_file = File.join(@svgcheck_outputs_dir, "check",
+                                       "#{base_name}#{extension}.out")
+          repair_error_file = File.join(@svgcheck_outputs_dir, "repair",
+                                        "#{base_name}#{extension}.out")
+
+          error_file = if File.exist?(check_error_file)
+                         check_error_file
+                       elsif File.exist?(repair_error_file)
+                         repair_error_file
+                       else
+                         return nil
+                       end
+
+          error_content = File.read(error_file)
+          ConformanceReport.from_svgcheck_result(filename, error_content)
+        end
+
+        def perform_semantic_comparison(svg_conform_report, svgcheck_report)
+          semantic_issues = []
+
+          # Compare semantic equivalence of errors
+          svg_conform_errors = group_errors_semantically(svg_conform_report.errors.issues)
+          svgcheck_errors = group_errors_semantically(svgcheck_report.errors.issues)
+
+          # Find semantic mismatches
+          all_semantic_keys = (svg_conform_errors.keys + svgcheck_errors.keys).uniq
+
+          all_semantic_keys.each do |semantic_key|
+            svg_count = svg_conform_errors[semantic_key]&.length || 0
+            svgcheck_count = svgcheck_errors[semantic_key]&.length || 0
+
+            next if svg_count == svgcheck_count
+
+            semantic_issues << {
+              semantic_key: semantic_key,
+              svg_conform_count: svg_count,
+              svgcheck_count: svgcheck_count,
+              difference: svg_count - svgcheck_count,
+            }
+          end
+
+          {
+            total_semantic_groups: all_semantic_keys.length,
+            matching_groups: all_semantic_keys.length - semantic_issues.length,
+            mismatched_groups: semantic_issues.length,
+            issues: semantic_issues,
+          }
+        end
+
+        def group_errors_semantically(errors)
+          errors.group_by do |error|
+            # Create semantic key based on requirement and core issue
+            requirement = error.requirement_id
+            attribute = error.attribute
+            element = error.element
+
+            if attribute && element
+              "#{requirement}:#{element}:#{attribute}"
+            elsif element
+              "#{requirement}:#{element}"
+            else
+              requirement
+            end
+          end
+        end
+      end
+    end
+  end
+end