svg_conform 0.1.0

data/lib/svg_conform/compatibility_analyzer.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+require "json"
+
+module SvgConform
+  # Analyzes compatibility between svg_conform and svgcheck results
+  class CompatibilityAnalyzer
+    attr_reader :results
+
+    def initialize
+      @results = {}
+    end
+
+    # Analyze all test files and compare results
+    def analyze_all_files
+      input_dir = File.join(__dir__, "..", "..", "spec", "fixtures",
+                            "svgcheck", "inputs")
+      check_dir = File.join(__dir__, "..", "..", "spec", "fixtures",
+                            "svgcheck", "check")
+      repair_dir = File.join(__dir__, "..", "..", "spec", "fixtures",
+                             "svgcheck", "repair")
+
+      Dir.glob(File.join(input_dir, "*.svg")).each do |input_file|
+        basename = File.basename(input_file, ".svg")
+        next if basename.start_with?("rfc") # Skip non-SVG files
+
+        puts "Analyzing #{basename}..."
+        result = analyze_file(input_file, check_dir, repair_dir)
+        @results[basename] = result
+      end
+
+      @results
+    end
+
+    # Analyze a single file
+    def analyze_file(input_file, check_dir, repair_dir)
+      basename = File.basename(input_file, ".svg")
+
+      # Load svgcheck results
+      svgcheck_out = load_svgcheck_file(check_dir, "#{basename}.svg.out")
+      svgcheck_err = load_svgcheck_file(check_dir, "#{basename}.svg.err")
+      svgcheck_code = load_svgcheck_file(check_dir, "#{basename}.svg.code")
+      svgcheck_repair = load_svgcheck_file(repair_dir, "#{basename}.svg.file")
+
+      # Run our validation
+      our_validation = run_our_validation(input_file)
+      our_remediation = nil # Skip remediation for now
+
+      # Parse svgcheck results
+      svgcheck_errors = parse_svgcheck_errors(svgcheck_out)
+      svgcheck_valid = svgcheck_out.include?("INFO: File conforms to SVG requirements")
+
+      # Compare results
+      {
+        file: basename,
+        input_file: input_file,
+        svgcheck: {
+          valid: svgcheck_valid,
+          errors: svgcheck_errors,
+          error_count: svgcheck_errors.length,
+          exit_code: svgcheck_code&.strip&.to_i,
+          raw_output: svgcheck_out,
+          raw_error: svgcheck_err,
+          repaired_content: svgcheck_repair,
+        },
+        our_results: {
+          valid: our_validation[:valid],
+          errors: our_validation[:errors],
+          error_count: our_validation[:errors].length,
+          remediated_content: our_remediation,
+        },
+        compatibility: analyze_compatibility(svgcheck_errors, svgcheck_valid,
+                                             our_validation),
+      }
+    end
+
+    # Generate a detailed report
+    def generate_report
+      return "No analysis results available" if @results.empty?
+
+      report = []
+      report << "SVG Conform vs SVGCheck Compatibility Analysis"
+      report << "=" * 50
+      report << ""
+
+      # Summary statistics
+      total_files = @results.length
+      compatible_files = @results.count do |_, r|
+        r[:compatibility][:overall_compatible]
+      end
+
+      report << "Summary:"
+      report << "  Total files analyzed: #{total_files}"
+      report << "  Compatible files: #{compatible_files}"
+      report << "  Compatibility rate: #{(compatible_files.to_f / total_files * 100).round(1)}%"
+      report << ""
+
+      # Detailed analysis for each file
+      @results.each do |basename, result|
+        report << "File: #{basename}"
+        report << "-" * 30
+
+        # Validation comparison
+        svgcheck_valid = result[:svgcheck][:valid]
+        our_valid = result[:our_results][:valid]
+
+        report << "  Validation:"
+        report << "    SVGCheck: #{svgcheck_valid ? 'VALID' : 'INVALID'} (#{result[:svgcheck][:error_count]} errors)"
+        report << "    Our tool:  #{our_valid ? 'VALID' : 'INVALID'} (#{result[:our_results][:error_count]} errors)"
+        report << "    Match: #{svgcheck_valid == our_valid ? 'YES' : 'NO'}"
+
+        # Error analysis
+        if result[:svgcheck][:error_count].positive? || result[:our_results][:error_count].positive?
+          report << "  Errors:"
+
+          if result[:svgcheck][:error_count].positive?
+            report << "    SVGCheck errors:"
+            result[:svgcheck][:errors].each do |error|
+              report << "      - Line #{error[:line]}: #{error[:message]}"
+            end
+          end
+
+          if result[:our_results][:error_count].positive?
+            report << "    Our errors:"
+            result[:our_results][:errors].each do |error|
+              report << "      - #{error}"
+            end
+          end
+        end
+
+        # Compatibility issues
+        compatibility = result[:compatibility]
+        unless compatibility[:issues].empty?
+          report << "  Compatibility Issues:"
+          compatibility[:issues].each do |issue|
+            report << "    - #{issue}"
+          end
+        end
+
+        report << ""
+      end
+
+      # Pattern analysis
+      report << "Common Patterns:"
+      report << "-" * 20
+
+      # Find common error types
+      all_svgcheck_errors = @results.values.flat_map do |r|
+        r[:svgcheck][:errors]
+      end
+      error_patterns = all_svgcheck_errors.group_by do |e|
+        extract_error_pattern(e[:message])
+      end
+
+      error_patterns.each do |pattern, errors|
+        report << "  #{pattern}: #{errors.length} occurrences"
+      end
+
+      report.join("\n")
+    end
+
+    private
+
+    def load_svgcheck_file(dir, filename)
+      file_path = File.join(dir, filename)
+      return nil unless File.exist?(file_path)
+
+      File.read(file_path)
+    rescue StandardError
+      nil
+    end
+
+    def run_our_validation(input_file)
+      svg_content = File.read(input_file)
+      validator = SvgConform::Validator.new
+      result = validator.validate(svg_content, profile: :svg_1_2_rfc)
+
+      {
+        valid: result.valid?,
+        errors: result.errors.map { |e| "Line #{e.line || '?'}: #{e.message}" },
+      }
+    rescue StandardError => e
+      {
+        valid: false,
+        errors: ["ERROR: #{e.message}"],
+      }
+    end
+
+    def run_our_remediation(input_file)
+      document = SvgConform::Document.from_file(input_file)
+      profile = SvgConform::Profiles.get(:svg_1_2_rfc)
+      fixer = SvgConform::Fixer.new(profile)
+
+      fixed_document = fixer.fix(document)
+      fixed_document.to_xml
+    rescue StandardError => e
+      "ERROR: #{e.message}"
+    end
+
+    def parse_svgcheck_errors(output)
+      return [] if output.nil? || output.empty?
+
+      errors = []
+      output.lines.each do |line|
+        line = line.strip
+        next if line.empty?
+        next if line.start_with?("INFO:")
+        next if line.include?("File conforms to SVG requirements")
+
+        # Parse error format: "filename:line: message"
+        if line =~ /^(.+):(\d+): (.+)$/
+          errors << {
+            file: Regexp.last_match(1),
+            line: Regexp.last_match(2).to_i,
+            message: Regexp.last_match(3),
+          }
+        elsif line.start_with?("ERROR:")
+          errors << {
+            file: "",
+            line: 0,
+            message: line,
+          }
+        end
+      end
+
+      errors
+    end
+
+    def analyze_compatibility(svgcheck_errors, svgcheck_valid, our_validation)
+      issues = []
+
+      # Check if validation results match
+      if svgcheck_valid != our_validation[:valid]
+        if svgcheck_valid && !our_validation[:valid]
+          issues << "We reject a file that svgcheck accepts"
+        elsif !svgcheck_valid && our_validation[:valid]
+          issues << "We accept a file that svgcheck rejects"
+        end
+      end
+
+      # Check error count differences
+      error_count_diff = (svgcheck_errors.length - our_validation[:errors].length).abs
+      issues << "Error count differs by #{error_count_diff}" if error_count_diff.positive?
+
+      # Check for missing error types
+      svgcheck_error_types = svgcheck_errors.map do |e|
+        extract_error_pattern(e[:message])
+      end.uniq
+      our_error_types = our_validation[:errors].map do |e|
+        extract_error_pattern(e)
+      end.uniq
+
+      missing_types = svgcheck_error_types - our_error_types
+      extra_types = our_error_types - svgcheck_error_types
+
+      missing_types.each { |type| issues << "Missing error type: #{type}" }
+      extra_types.each { |type| issues << "Extra error type: #{type}" }
+
+      {
+        overall_compatible: issues.empty?,
+        issues: issues,
+        error_count_match: svgcheck_errors.length == our_validation[:errors].length,
+        validation_result_match: svgcheck_valid == our_validation[:valid],
+      }
+    end
+
+    def extract_error_pattern(error_message)
+      # Extract the general pattern from an error message
+      case error_message
+      when /attribute '(\w+)' does not allow the value '([^']+)'/
+        "invalid_attribute_value:#{Regexp.last_match(1)}"
+      when /Color '([^']+)' in attribute '(\w+)'/
+        "invalid_color:#{Regexp.last_match(2)}"
+      when /viewBox/i
+        "viewbox_issue"
+      when /namespace/i
+        "namespace_issue"
+      when /font/i
+        "font_issue"
+      else
+        error_message.split(":").first || error_message
+      end
+    end
+  end
+end

data/lib/svg_conform/conformance_report.rb

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module SvgConform
+  # Individual error/warning entry in the report
+  class ConformanceIssue < Lutaml::Model::Serializable
+    attribute :type, :string
+    attribute :requirement_id, :string
+    attribute :message, :string
+    attribute :element, :string
+    attribute :attribute, :string
+    attribute :value, :string
+    attribute :line, :integer
+    attribute :column, :integer
+    attribute :xpath, :string
+    attribute :severity, :string
+    attribute :category, :string
+    attribute :remediation_available, :boolean, default: -> { false }
+    attribute :context, :hash, default: -> { {} }
+
+    yaml do
+      map "type", to: :type
+      map "requirement_id", to: :requirement_id
+      map "message", to: :message
+      map "element", to: :element
+      map "attribute", to: :attribute
+      map "value", to: :value
+      map "line", to: :line
+      map "column", to: :column
+      map "xpath", to: :xpath
+      map "severity", to: :severity
+      map "category", to: :category
+      map "remediation_available", to: :remediation_available
+      map "context", to: :context
+    end
+  end
+
+  # Summary of issues by type
+  class IssueSummary < Lutaml::Model::Serializable
+    attribute :total_count, :integer
+    attribute :by_requirement, :hash, default: -> { {} }
+    attribute :issues, ConformanceIssue, collection: true, default: -> { [] }
+
+    yaml do
+      map "total_count", to: :total_count
+      map "by_requirement", to: :by_requirement
+      map "issues", to: :issues
+    end
+  end
+
+  # Main conformance report structure
+  class ConformanceReport < Lutaml::Model::Serializable
+    attribute :filename, :string
+    attribute :profile, :string
+    attribute :tool, :string # "svg_conform" or "svgcheck"
+    attribute :version, :string
+    attribute :timestamp, :string
+    attribute :valid, :boolean
+    attribute :errors, IssueSummary
+    attribute :warnings, IssueSummary
+
+    yaml do
+      map "filename", to: :filename
+      map "profile", to: :profile
+      map "tool", to: :tool
+      map "version", to: :version
+      map "timestamp", to: :timestamp
+      map "valid", to: :valid
+      map "errors", to: :errors
+      map "warnings", to: :warnings
+    end
+
+    # Create report from SvgConform ValidationResult
+    def self.from_svg_conform_result(filename, validation_result, profile: nil,
+use_svgcheck_mapping: false)
+      report = new
+      report.filename = filename
+      report.profile = profile
+      report.tool = "svg_conform"
+      report.version = SvgConform::VERSION
+      report.timestamp = Time.now.iso8601
+      report.valid = validation_result.valid?
+      report.errors = IssueSummary.new
+      report.errors.total_count = 0
+      report.errors.by_requirement = {}
+      report.errors.issues = []
+
+      report.warnings = IssueSummary.new
+      report.warnings.total_count = 0
+      report.warnings.by_requirement = {}
+      report.warnings.issues = []
+
+      # Use SvgcheckCompatibilityEngine for svgcheck compatibility
+      if use_svgcheck_mapping
+        require_relative "external_checkers/svgcheck/compatibility_engine"
+        compatibility_engine = ExternalCheckers::Svgcheck::CompatibilityEngine.new
+
+        # Check if file should be treated as unparseable by svgcheck
+        if compatibility_engine.should_mimic_parse_failure?(filename,
+                                                            validation_result)
+          # Return empty report like svgcheck does for unparseable files
+          return report
+        end
+      end
+
+      # Process errors (including conditional validity_errors for svgcheck compatibility)
+      all_errors = validation_result.errors.dup
+
+      # For svgcheck compatibility: include validity_errors as regular errors
+      if use_svgcheck_mapping && validation_result.validity_errors.any?
+        compatibility_engine ||= ExternalCheckers::Svgcheck::CompatibilityEngine.new
+        all_errors.concat(validation_result.validity_errors) if compatibility_engine.should_include_validity_errors?(
+          validation_result, filename
+        )
+      end
+
+      if all_errors.any?
+        # Filter errors using compatibility engine or use direct mapping
+        filtered_errors = if use_svgcheck_mapping
+                            compatibility_engine ||= ExternalCheckers::Svgcheck::CompatibilityEngine.new
+                            compatibility_engine.filter_errors_for_svgcheck(
+                              all_errors, filename, validation_result
+                            )
+                          else
+                            all_errors.map do |error|
+                              [error, error.requirement_id]
+                            end
+                          end
+
+        error_groups = filtered_errors.group_by { |_error, req_id| req_id }
+
+        error_groups.each do |req_id, error_pairs|
+          report.errors.by_requirement[req_id] = error_pairs.length
+        end
+
+        # Update total count to reflect filtered errors
+        report.errors.total_count = filtered_errors.length
+
+        # Add ALL filtered errors (no sampling)
+        report.errors.issues = filtered_errors.map do |error, mapped_req_id|
+          # Extract attribute and value from error data if available
+          attribute = error.data[:attribute] if error.respond_to?(:data) && error.data
+          value = error.data[:value] if error.respond_to?(:data) && error.data
+
+          issue = ConformanceIssue.new
+          issue.type = "error"
+          issue.requirement_id = mapped_req_id
+          issue.message = error.message
+          issue.element = error.element_name
+          issue.attribute = attribute
+          issue.value = value
+          issue.line = error.line
+          issue
+        end
+      end
+
+      # Process warnings
+      if validation_result.warnings.any?
+        report.warnings.total_count = validation_result.warnings.length
+
+        # Group by requirement_id
+        warning_groups = validation_result.warnings.group_by(&:requirement_id)
+        warning_groups.each do |req_id, warnings|
+          report.warnings.by_requirement[req_id] = warnings.length
+        end
+
+        # Add ALL warnings (no sampling)
+        report.warnings.issues = validation_result.warnings.map do |warning|
+          issue = ConformanceIssue.new
+          issue.type = "warning"
+          issue.requirement_id = warning.requirement_id
+          issue.message = warning.message
+          issue.element = warning.element_name
+          issue.line = warning.line
+          issue
+        end
+      end
+
+      report
+    end
+
+    # Create report from svgcheck error output
+    def self.from_svgcheck_result(filename, error_content,
+_output_content = nil)
+      report = new
+      report.filename = filename
+      report.tool = "svgcheck"
+      report.timestamp = Time.now.iso8601
+      report.valid = error_content.strip.empty?
+      report.errors = IssueSummary.new
+      report.errors.total_count = 0
+      report.errors.by_requirement = {}
+      report.errors.issues = []
+
+      report.warnings = IssueSummary.new
+      report.warnings.total_count = 0
+      report.warnings.by_requirement = {}
+      report.warnings.issues = []
+
+      return report if error_content.strip.empty?
+
+      # Parse svgcheck errors using the dedicated parser
+      require_relative "external_checkers/svgcheck/parser"
+      parser = ExternalCheckers::Svgcheck::Parser.new
+      parsed_report = parser.parse(error_content, nil, filename: filename)
+      errors = parsed_report.errors.issues
+
+      if errors.any?
+        report.errors.total_count = errors.length
+        report.valid = false
+
+        # Group by type for summary
+        error_groups = errors.group_by { |e| e.requirement_id || "unknown" }
+        error_groups.each do |type, type_errors|
+          report.errors.by_requirement[type] = type_errors.length
+        end
+
+        # Add ALL errors (no sampling)
+        report.errors.issues = errors
+      end
+
+      report
+    end
+
+    # Compare two conformance reports
+    def compare_with(other_report)
+      differences = []
+
+      # Compare error counts
+      differences << "Error count: #{errors.total_count} vs #{other_report.errors.total_count}" if errors.total_count != other_report.errors.total_count
+
+      # Compare warning counts
+      differences << "Warning count: #{warnings.total_count} vs #{other_report.warnings.total_count}" if warnings.total_count != other_report.warnings.total_count
+
+      # Compare error types
+      all_req_ids = (errors.by_requirement.keys + other_report.errors.by_requirement.keys).uniq
+      all_req_ids.each do |req_id|
+        our_count = errors.by_requirement[req_id] || 0
+        their_count = other_report.errors.by_requirement[req_id] || 0
+
+        differences << "#{req_id} errors: #{our_count} vs #{their_count}" if our_count != their_count
+      end
+
+      {
+        identical: differences.empty?,
+        differences: differences,
+        summary: differences.empty? ? "Reports are identical" : "#{differences.length} differences found",
+      }
+    end
+
+    # Save report to YAML file
+    def save_to_file(filepath)
+      File.write(filepath, to_yaml)
+    end
+
+    # Load report from YAML file
+    def self.load_from_file(filepath)
+      from_yaml(File.read(filepath))
+    end
+
+    # Check if the report indicates a valid SVG
+    def valid?
+      valid
+    end
+  end
+end