svg_conform 0.1.0

data/lib/svg_conform/compatibility/report_formatter.rb

@@ -0,0 +1,359 @@
+# frozen_string_literal: true
+
+require "paint"
+
+module SvgConform
+  module Compatibility
+    # Handles formatting and display of compatibility analysis results
+    class ReportFormatter
+      def initialize(context)
+        @context = context
+      end
+
+      def display_single_file_result(result)
+        if @context.semantic_analysis?
+          display_semantic_single_result(result)
+        else
+          display_basic_single_result(result)
+        end
+      end
+
+      def display_batch_results(results)
+        if @context.semantic_analysis?
+          display_semantic_batch_results(results)
+        else
+          display_basic_batch_results(results)
+        end
+      end
+
+      def write_output_file(results)
+        return unless @context.file_output?
+
+        content = generate_output_content(results)
+        File.write(@context.output_file, content)
+        puts "📄 Results written to: #{@context.output_file}"
+      end
+
+      private
+
+      def display_semantic_single_result(result)
+        display_file_header(result.filename)
+        display_semantic_validation_section(result)
+        display_semantic_repair_section(result) if @context.repair_mode?
+        display_xml_equivalence_section(result) if result.xml_equivalence
+      end
+
+      def display_basic_single_result(result)
+        display_file_header(result.filename)
+        display_basic_validation_section(result)
+        display_basic_repair_section(result) if @context.repair_mode?
+      end
+
+      def display_semantic_batch_results(results)
+        display_batch_header(results.length)
+        display_semantic_summary_table(results)
+        display_semantic_batch_statistics(results)
+      end
+
+      def display_basic_batch_results(results)
+        display_batch_header(results.length)
+        display_basic_summary_table(results)
+        display_basic_batch_statistics(results)
+      end
+
+      def display_file_header(filename)
+        mode_icon = @context.repair_mode? ? "🔧" : "📋"
+        mode_text = @context.repair_mode? ? "Repair Analysis" : "Analysis"
+        analysis_type = @context.semantic_analysis? ? "Semantic" : "Basic"
+
+        puts Paint["#{mode_icon} #{analysis_type} #{mode_text}: #{filename}",
+                   :cyan, :bold]
+        puts "=" * 60
+      end
+
+      def display_batch_header(file_count)
+        mode_icon = @context.repair_mode? ? "🔧" : "📋"
+        mode_text = @context.repair_mode? ? "Repair Analysis" : "Analysis"
+        analysis_type = @context.semantic_analysis? ? "Semantic" : "Basic"
+
+        puts Paint["#{mode_icon} #{analysis_type} Batch #{mode_text} (#{file_count} files)",
+                   :cyan, :bold]
+        puts "=" * 80
+      end
+
+      def display_semantic_validation_section(result)
+        return unless result.validation_comparison
+
+        puts Paint["📊 Validation Comparison:", :blue, :bold]
+
+        score = result.compatibility_score
+        score_color = if score >= 90
+                        :green
+                      else
+                        score >= 70 ? :yellow : :red
+                      end
+        puts "  Compatibility Score: #{Paint[format('%.1f%%', score),
+                                             score_color, :bold]}"
+
+        validity_status = result.validity_match? ? "✅ Match" : "❌ Mismatch"
+        puts "  Validity Match: #{validity_status}"
+        puts "  SvgConform Valid: #{result.svg_conform_valid? ? '✅' : '❌'}"
+        puts "  Svgcheck Valid: #{result.svgcheck_valid? ? '✅' : '❌'}"
+        puts
+      end
+
+      def display_semantic_repair_section(result)
+        return unless result.validation_comparison
+
+        puts Paint["🔧 Repair Results:", :blue, :bold]
+
+        if result.successful_remediation?
+          puts "  Remediation: #{Paint['✅ Successful', :green, :bold]}"
+        else
+          puts "  Remediation: #{Paint['❌ Failed', :red, :bold]}"
+        end
+
+        if result.content_comparison
+          equivalence = result.content_equivalence_score
+          equiv_color = if equivalence >= 90
+                          :green
+                        else
+                          equivalence >= 70 ? :yellow : :red
+                        end
+          puts "  Content Equivalence: #{Paint[format('%.1f%%', equivalence),
+                                               equiv_color, :bold]}"
+        end
+        puts
+      end
+
+      def display_xml_equivalence_section(result)
+        puts Paint["🔍 XML Equivalence:", :blue, :bold]
+
+        if result.xml_error
+          puts "  Status: #{Paint['❌ Error', :red, :bold]}"
+          puts "  Error: #{result.xml_error}"
+        elsif result.xml_equivalent?
+          puts "  Status: #{Paint['✅ Equivalent', :green, :bold]}"
+        else
+          puts "  Status: #{Paint['❌ Different', :red, :bold]}"
+          puts "  Differences: #{result.xml_differences.length}"
+        end
+        puts
+      end
+
+      def display_basic_validation_section(result)
+        puts Paint["📊 Validation Results:", :blue, :bold]
+        puts "  SvgConform Valid: #{result.svg_conform_valid? ? '✅' : '❌'}"
+        puts "  Svgcheck Valid: #{result.svgcheck_valid? ? '✅' : '❌'}"
+        puts "  Validity Match: #{result.validity_match? ? '✅' : '❌'}"
+        puts
+      end
+
+      def display_basic_repair_section(result)
+        puts Paint["🔧 Repair Results:", :blue, :bold]
+
+        if result.successful_remediation?
+          puts "  Remediation: #{Paint['✅ Successful', :green, :bold]}"
+          puts "  Issues Fixed: #{result.issues_fixed}"
+          puts "  Remediations Applied: #{result.remediations_applied}"
+        else
+          puts "  Remediation: #{Paint['❌ Failed', :red, :bold]}"
+        end
+        puts
+      end
+
+      def display_semantic_summary_table(results)
+        puts Paint["📊 Summary Table:", :blue, :bold]
+        puts
+
+        header = format("%-25s %12s %8s %12s %12s",
+                        "File", "Compatibility", "Valid", "SvgConform", "Svgcheck")
+        puts Paint[header, :white, :bold]
+        puts "-" * 70
+
+        results.each do |result|
+          score = format("%.1f%%", result.compatibility_score)
+          score_color = if result.compatibility_score >= 90
+                          :green
+                        else
+                          result.compatibility_score >= 70 ? :yellow : :red
+                        end
+
+          validity = result.validity_match? ? "✅" : "❌"
+          svg_conform = result.svg_conform_valid? ? "✅" : "❌"
+          svgcheck = result.svgcheck_valid? ? "✅" : "❌"
+
+          row = format("%-25s %12s %8s %12s %12s",
+                       result.filename.truncate(23),
+                       Paint[score, score_color],
+                       validity,
+                       svg_conform,
+                       svgcheck)
+          puts row
+        end
+        puts
+      end
+
+      def display_basic_summary_table(results)
+        puts Paint["📊 Summary Table:", :blue, :bold]
+        puts
+
+        header = format("%-25s %8s %12s %12s %8s",
+                        "File", "Valid", "SvgConform", "Svgcheck", "Errors")
+        puts Paint[header, :white, :bold]
+        puts "-" * 66
+
+        results.each do |result|
+          validity = result.validity_match? ? "✅" : "❌"
+          svg_conform = result.svg_conform_valid? ? "✅" : "❌"
+          svgcheck = result.svgcheck_valid? ? "✅" : "❌"
+          errors = result.error_count
+
+          row = format("%-25s %8s %12s %12s %8d",
+                       result.filename.truncate(23),
+                       validity,
+                       svg_conform,
+                       svgcheck,
+                       errors)
+          puts row
+        end
+        puts
+      end
+
+      def display_semantic_batch_statistics(results)
+        puts Paint["📈 Statistics:", :blue, :bold]
+
+        avg_compatibility = results.sum(&:compatibility_score) / results.length
+        validity_matches = results.count(&:validity_match?)
+        successful_remediations = results.count(&:successful_remediation?) if @context.repair_mode?
+
+        score_color = if avg_compatibility >= 90
+                        :green
+                      else
+                        avg_compatibility >= 70 ? :yellow : :red
+                      end
+        puts "  Average Compatibility: #{Paint[format('%.1f%%', avg_compatibility),
+                                               score_color, :bold]}"
+        puts "  Validity Matches: #{validity_matches}/#{results.length} (#{format('%.1f%%',
+                                                                                  validity_matches * 100.0 / results.length)})"
+
+        if @context.repair_mode?
+          puts "  Successful Remediations: #{successful_remediations}/#{results.length} (#{format('%.1f%%',
+                                                                                                  successful_remediations * 100.0 / results.length)})"
+        end
+        puts
+      end
+
+      def display_basic_batch_statistics(results)
+        puts Paint["📈 Statistics:", :blue, :bold]
+
+        validity_matches = results.count(&:validity_match?)
+        successful_remediations = results.count(&:successful_remediation?) if @context.repair_mode?
+        total_errors = results.sum(&:error_count)
+
+        puts "  Validity Matches: #{validity_matches}/#{results.length} (#{format('%.1f%%',
+                                                                                  validity_matches * 100.0 / results.length)})"
+        puts "  Total Errors: #{total_errors}"
+
+        if @context.repair_mode?
+          puts "  Successful Remediations: #{successful_remediations}/#{results.length} (#{format('%.1f%%',
+                                                                                                  successful_remediations * 100.0 / results.length)})"
+        end
+        puts
+      end
+
+      def generate_output_content(results)
+        content = []
+        content << "# Compatibility Analysis Results"
+        content << ""
+        content << "Analysis Type: #{@context.semantic_analysis? ? 'Semantic' : 'Basic'}"
+        content << "Mode: #{@context.mode.to_s.capitalize}"
+        content << "Profile: #{@context.profile}"
+        content << "Generated: #{Time.now}"
+        content << ""
+
+        if results.is_a?(Array)
+          generate_batch_output_content(content, results)
+        else
+          generate_single_output_content(content, results)
+        end
+
+        content.join("\n")
+      end
+
+      def generate_batch_output_content(content, results)
+        content << "## Summary"
+        content << ""
+
+        if @context.semantic_analysis?
+          avg_compatibility = results.sum(&:compatibility_score) / results.length
+          content << "Average Compatibility: #{format('%.1f%%',
+                                                      avg_compatibility)}"
+        end
+
+        validity_matches = results.count(&:validity_match?)
+        content << "Validity Matches: #{validity_matches}/#{results.length}"
+
+        if @context.repair_mode?
+          successful_remediations = results.count(&:successful_remediation?)
+          content << "Successful Remediations: #{successful_remediations}/#{results.length}"
+        end
+
+        content << ""
+        content << "## Individual Results"
+        content << ""
+
+        results.each do |result|
+          content << "### #{result.filename}"
+          content << ""
+          add_result_details(content, result)
+          content << ""
+        end
+      end
+
+      def generate_single_output_content(content, result)
+        content << "## #{result.filename}"
+        content << ""
+        add_result_details(content, result)
+      end
+
+      def add_result_details(content, result)
+        if @context.semantic_analysis?
+          content << "Compatibility Score: #{format('%.1f%%',
+                                                    result.compatibility_score)}"
+        end
+
+        content << "Validity Match: #{result.validity_match?}"
+        content << "SvgConform Valid: #{result.svg_conform_valid?}"
+        content << "Svgcheck Valid: #{result.svgcheck_valid?}"
+
+        return unless @context.repair_mode?
+
+        content << "Successful Remediation: #{result.successful_remediation?}"
+
+        if result.content_comparison
+          content << "Content Equivalence: #{format('%.1f%%',
+                                                    result.content_equivalence_score)}"
+        end
+
+        return unless result.xml_equivalence
+
+        content << "XML Equivalent: #{result.xml_equivalent?}"
+        return unless result.xml_error
+
+        content << "XML Error: #{result.xml_error}"
+      end
+    end
+  end
+end
+
+# String extension for truncation
+class String
+  def truncate(length)
+    if self.length > length
+      "#{self[0..length - 4]}..."
+    else
+      self
+    end
+  end
+end

data/lib/svg_conform/compatibility/svg_analysis_engine.rb

@@ -0,0 +1,316 @@
+# frozen_string_literal: true
+
+require_relative "../semantic_comparator"
+require_relative "../remediation_runner"
+
+module SvgConform
+  module Compatibility
+    # Handles SVG-specific analysis operations
+    class SvgAnalysisEngine
+      def initialize(context, file_processor)
+        @context = context
+        @file_processor = file_processor
+      end
+
+      def analyze_file(filename, svgcheck_report)
+        if @context.check_mode?
+          analyze_validation(filename, svgcheck_report)
+        else
+          analyze_repair(filename, svgcheck_report)
+        end
+      end
+
+      private
+
+      def analyze_validation(filename, svgcheck_report)
+        input_file = @file_processor.input_file_path(filename)
+        svg_conform_result = run_validation(input_file)
+        svg_conform_report = create_conformance_report(filename,
+                                                       svg_conform_result)
+
+        if @context.semantic_analysis?
+          build_semantic_validation_result(filename, svg_conform_report,
+                                           svgcheck_report)
+        else
+          build_basic_validation_result(filename, svg_conform_report,
+                                        svgcheck_report)
+        end
+      end
+
+      def analyze_repair(filename, svgcheck_report)
+        input_file = @file_processor.input_file_path(filename)
+        svg_conform_result = run_remediation(input_file, filename)
+
+        if @context.semantic_analysis?
+          build_semantic_repair_result(filename, svg_conform_result,
+                                       svgcheck_report)
+        else
+          build_basic_repair_result(filename, svg_conform_result,
+                                    svgcheck_report)
+        end
+      end
+
+      def run_validation(input_file)
+        validator = SvgConform::Validator.new
+        validator.validate_file(input_file, profile: @context.profile)
+      end
+
+      def run_remediation(input_file, filename)
+        remediation_runner = SvgConform::RemediationRunner.new(profile: @context.profile)
+        svg_content = File.read(input_file)
+        remediation_runner.run_remediation(svg_content, filename: filename)
+      end
+
+      def create_conformance_report(filename, svg_conform_result)
+        SvgConform::ConformanceReport.from_svg_conform_result(
+          filename,
+          svg_conform_result,
+          profile: @context.profile,
+          use_svgcheck_mapping: true,
+        )
+      end
+
+      def build_semantic_validation_result(filename, svg_conform_report,
+svgcheck_report)
+        validation_comparison = SvgConform::SemanticComparator.compare_validation_results(
+          svg_conform_report,
+          svgcheck_report,
+        )
+
+        ComparisonResult.new(
+          filename: filename,
+          type: :semantic_validation,
+          validation_comparison: validation_comparison,
+        )
+      end
+
+      def build_basic_validation_result(filename, svg_conform_report,
+svgcheck_report)
+        ComparisonResult.new(
+          filename: filename,
+          type: :basic_validation,
+          svg_conform_result: svg_conform_report,
+          svgcheck_result: svgcheck_report,
+        )
+      end
+
+      def build_semantic_repair_result(filename, svg_conform_result,
+svgcheck_report)
+        svg_conform_report = svg_conform_result.generate_conformance_report
+        validation_comparison = SvgConform::SemanticComparator.compare_validation_results(
+          svg_conform_report,
+          svgcheck_report,
+        )
+
+        content_comparison = build_content_comparison(svg_conform_result,
+                                                      svgcheck_report)
+        xml_equivalence = build_xml_equivalence(filename, svg_conform_result)
+
+        ComparisonResult.new(
+          filename: filename,
+          type: :semantic_repair,
+          validation_comparison: validation_comparison,
+          content_comparison: content_comparison,
+          xml_equivalence: xml_equivalence,
+        )
+      end
+
+      def build_basic_repair_result(filename, svg_conform_result,
+svgcheck_report)
+        ComparisonResult.new(
+          filename: filename,
+          type: :basic_repair,
+          svg_conform_result: svg_conform_result,
+          svgcheck_result: svgcheck_report,
+        )
+      end
+
+      def build_content_comparison(svg_conform_result, svgcheck_report)
+        return nil unless svgcheck_report.respond_to?(:remediated_content) &&
+          svg_conform_result.remediated_content
+
+        SvgConform::SemanticComparator.compare_remediated_content(
+          svg_conform_result.remediated_content,
+          svgcheck_report.remediated_content,
+        )
+      end
+
+      def build_xml_equivalence(filename, svg_conform_result)
+        return nil unless svg_conform_result.remediated_content
+
+        unless @file_processor.svgcheck_repaired_file_exists?(filename)
+          return {
+            error: "Svgcheck repaired file not found: #{@file_processor.svgcheck_repaired_file_path(filename)}",
+            xml_equivalent: false,
+          }
+        end
+
+        begin
+          svgcheck_content = @file_processor.read_svgcheck_repaired_content(filename)
+          compare_xml_content(svg_conform_result.remediated_content,
+                              svgcheck_content)
+        rescue StandardError => e
+          {
+            error: "Error comparing XML files: #{e.message}",
+            xml_equivalent: false,
+          }
+        end
+      end
+
+      def compare_xml_content(svg_conform_content, svgcheck_content)
+        require "equivalent-xml"
+
+        xml_equivalent = EquivalentXml.equivalent?(svg_conform_content, svgcheck_content, {
+                                                     element_order: false,
+                                                     normalize_whitespace: true,
+                                                   })
+
+        if xml_equivalent
+          {
+            xml_equivalent: true,
+            differences: [],
+          }
+        else
+          differences = analyze_xml_differences(svg_conform_content,
+                                                svgcheck_content)
+          {
+            xml_equivalent: false,
+            differences: differences,
+          }
+        end
+      end
+
+      def analyze_xml_differences(svg_conform_content, svgcheck_content)
+        differences = []
+
+        begin
+          require "moxml"
+          moxml = Moxml.new
+
+          svg_conform_doc = moxml.parse(svg_conform_content)
+          svgcheck_doc = moxml.parse(svgcheck_content)
+
+          svg_conform_root = svg_conform_doc.root
+          svgcheck_root = svgcheck_doc.root
+
+          # Compare element names
+          if svg_conform_root.name != svgcheck_root.name
+            differences << {
+              type: :root_element_name,
+              svg_conform: svg_conform_root.name,
+              svgcheck: svgcheck_root.name,
+            }
+          end
+
+          # Compare attributes and children recursively
+          differences.concat(compare_element_attributes(svg_conform_root,
+                                                        svgcheck_root))
+          differences.concat(compare_child_elements(svg_conform_root,
+                                                    svgcheck_root))
+        rescue StandardError => e
+          differences << {
+            type: :parsing_error,
+            error: e.message,
+          }
+        end
+
+        differences
+      end
+
+      def compare_element_attributes(elem1, elem2)
+        differences = []
+        attrs1 = normalize_attributes(elem1.attributes)
+        attrs2 = normalize_attributes(elem2.attributes)
+        all_attr_names = (attrs1.keys + attrs2.keys).uniq
+
+        all_attr_names.each do |attr_name|
+          val1 = attrs1[attr_name]
+          val2 = attrs2[attr_name]
+
+          next unless val1 != val2
+
+          differences << {
+            type: :attribute_difference,
+            element: elem1.name,
+            attribute: attr_name,
+            svg_conform: val1,
+            svgcheck: val2,
+          }
+        end
+
+        differences
+      end
+
+      def normalize_attributes(attributes)
+        return {} if attributes.nil?
+
+        case attributes
+        when Hash
+          attributes
+        when Array
+          attributes.each_with_object({}) do |attr, hash|
+            if attr.respond_to?(:name) && attr.respond_to?(:value)
+              hash[attr.name] = attr.value
+            elsif attr.is_a?(Array) && attr.length == 2
+              hash[attr[0]] = attr[1]
+            end
+          end
+        else
+          {}
+        end
+      end
+
+      def compare_child_elements(elem1, elem2)
+        differences = []
+        children1 = elem1.children.select { |child| child.respond_to?(:name) }
+        children2 = elem2.children.select { |child| child.respond_to?(:name) }
+
+        if children1.length != children2.length
+          differences << {
+            type: :child_count_difference,
+            element: elem1.name,
+            svg_conform_count: children1.length,
+            svgcheck_count: children2.length,
+          }
+        end
+
+        max_children = [children1.length, children2.length].max
+        (0...max_children).each do |i|
+          child1 = children1[i]
+          child2 = children2[i]
+
+          if child1 && child2
+            if child1.name == child2.name
+              differences.concat(compare_element_attributes(child1, child2))
+              differences.concat(compare_child_elements(child1, child2))
+            else
+              differences << {
+                type: :child_element_name,
+                parent: elem1.name,
+                position: i,
+                svg_conform: child1.name,
+                svgcheck: child2.name,
+              }
+            end
+          elsif child1
+            differences << {
+              type: :extra_child_svg_conform,
+              parent: elem1.name,
+              position: i,
+              element: child1.name,
+            }
+          elsif child2
+            differences << {
+              type: :extra_child_svgcheck,
+              parent: elem1.name,
+              position: i,
+              element: child2.name,
+            }
+          end
+        end
+
+        differences
+      end
+    end
+  end
+end