svg_conform 0.1.0

data/lib/svg_conform/compatibility/validity_analysis.rb

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module SvgConform
+  module Compatibility
+    # Model for validity analysis results
+    class ValidityAnalysis < Lutaml::Model::Serializable
+      attribute :svg_conform_valid, :boolean
+      attribute :svgcheck_valid, :boolean
+      attribute :validity_match, :boolean
+      attribute :mismatch_reasons, :string, collection: true
+      attribute :requirement_differences, :string, collection: true
+
+      def initialize(svg_conform_valid:, svgcheck_valid:)
+        @svg_conform_valid = svg_conform_valid
+        @svgcheck_valid = svgcheck_valid
+        @validity_match = svg_conform_valid == svgcheck_valid
+        @mismatch_reasons = []
+        @requirement_differences = []
+      end
+
+      def add_mismatch_reason(reason)
+        @mismatch_reasons << reason
+      end
+
+      def add_requirement_difference(difference)
+        @requirement_differences << difference
+      end
+
+      def mismatch?
+        !@validity_match
+      end
+
+      def both_valid?
+        @svg_conform_valid && @svgcheck_valid
+      end
+
+      def both_invalid?
+        !@svg_conform_valid && !@svgcheck_valid
+      end
+
+      def svg_conform_stricter?
+        !@svg_conform_valid && @svgcheck_valid
+      end
+
+      def svgcheck_stricter?
+        @svg_conform_valid && !@svgcheck_valid
+      end
+    end
+
+    # Model for semantic pattern analysis
+    class SemanticPattern < Lutaml::Model::Serializable
+      attribute :pattern_type, :string
+      attribute :svg_conform_message, :string
+      attribute :svgcheck_message, :string
+      attribute :semantic_key, :string
+      attribute :confidence_score, :float
+      attribute :mapped, :boolean
+
+      def initialize(pattern_type:, svg_conform_message:, svgcheck_message:)
+        @pattern_type = pattern_type
+        @svg_conform_message = svg_conform_message
+        @svgcheck_message = svgcheck_message
+        @mapped = false
+        @confidence_score = 0.0
+      end
+
+      def map_to_semantic_key(key, confidence = 1.0)
+        @semantic_key = key
+        @confidence_score = confidence
+        @mapped = true
+      end
+
+      def unmapped?
+        !@mapped
+      end
+    end
+
+    # Enhanced validity analyzer following model-driven architecture
+    class ValidityAnalyzer
+      attr_reader :analysis_results
+
+      def initialize
+        @analysis_results = []
+      end
+
+      def analyze_validity_mismatch(svg_conform_result, svgcheck_result,
+filename)
+        # Handle different result types
+        svg_conform_valid = if svg_conform_result.respond_to?(:valid?)
+                              svg_conform_result.valid?
+                            else
+                              svg_conform_result.valid
+                            end
+
+        svgcheck_valid = if svgcheck_result.respond_to?(:valid?)
+                           svgcheck_result.valid?
+                         else
+                           svgcheck_result.valid
+                         end
+
+        analysis = ValidityAnalysis.new(
+          svg_conform_valid: svg_conform_valid,
+          svgcheck_valid: svgcheck_valid,
+        )
+
+        if analysis.mismatch?
+          investigate_mismatch_reasons(analysis, svg_conform_result,
+                                       svgcheck_result, filename)
+        end
+
+        @analysis_results << analysis
+        analysis
+      end
+
+      def analyze_semantic_patterns(svg_conform_issues, svgcheck_issues)
+        patterns = []
+
+        svg_conform_issues.each do |svg_issue|
+          svgcheck_issues.each do |svg_issue_check|
+            pattern = SemanticPattern.new(
+              pattern_type: determine_pattern_type(svg_issue, svg_issue_check),
+              svg_conform_message: svg_issue.to_s,
+              svgcheck_message: svg_issue_check.to_s,
+            )
+
+            # Try to map to existing semantic keys
+            map_semantic_pattern(pattern)
+            patterns << pattern
+          end
+        end
+
+        patterns
+      end
+
+      private
+
+      def investigate_mismatch_reasons(analysis, svg_conform_result,
+                                       svgcheck_result, _filename)
+        if analysis.svg_conform_stricter?
+          analysis.add_mismatch_reason("SvgConform stricter validation")
+          analyze_svg_conform_requirements(analysis, svg_conform_result)
+        elsif analysis.svgcheck_stricter?
+          analysis.add_mismatch_reason("Svgcheck stricter validation")
+          analyze_svgcheck_requirements(analysis, svgcheck_result)
+        end
+      end
+
+      def analyze_svg_conform_requirements(analysis, result)
+        # Analyze which specific requirements are failing
+        return unless result.respond_to?(:issues)
+
+        result.issues.each do |issue|
+          requirement_type = extract_requirement_type(issue)
+          analysis.add_requirement_difference(
+            "SvgConform requirement: #{requirement_type}",
+          )
+        end
+      end
+
+      def analyze_svgcheck_requirements(analysis, result)
+        # Analyze svgcheck specific requirements
+        return unless result.respond_to?(:messages)
+
+        result.messages.each do |message|
+          requirement_type = extract_svgcheck_requirement_type(message)
+          analysis.add_requirement_difference(
+            "Svgcheck requirement: #{requirement_type}",
+          )
+        end
+      end
+
+      def extract_requirement_type(issue)
+        case issue.to_s
+        when /namespace/i
+          "namespace_requirement"
+        when /viewbox/i
+          "viewbox_requirement"
+        when /font/i
+          "font_requirement"
+        when /color/i
+          "color_requirement"
+        else
+          "unknown_requirement"
+        end
+      end
+
+      def extract_svgcheck_requirement_type(message)
+        case message.to_s
+        when /namespace/i
+          "namespace_validation"
+        when /viewbox/i
+          "viewbox_validation"
+        when /font/i
+          "font_validation"
+        when /color/i
+          "color_validation"
+        else
+          "unknown_validation"
+        end
+      end
+
+      def determine_pattern_type(svg_issue, svgcheck_issue)
+        svg_type = extract_requirement_type(svg_issue)
+        svgcheck_type = extract_svgcheck_requirement_type(svgcheck_issue)
+
+        if svg_type.gsub("_requirement", "") ==
+            svgcheck_type.gsub("_validation", "")
+          "equivalent_validation"
+        else
+          "different_validation"
+        end
+      end
+
+      def map_semantic_pattern(pattern)
+        # Enhanced semantic mapping logic
+        semantic_key = determine_semantic_key(pattern)
+        return unless semantic_key
+
+        confidence = calculate_mapping_confidence(pattern, semantic_key)
+        pattern.map_to_semantic_key(semantic_key, confidence)
+      end
+
+      def determine_semantic_key(pattern)
+        # Use existing semantic comparator logic
+        SvgConform::SemanticComparator.new
+
+        # This would need to be enhanced to work with the pattern model
+        # For now, return a basic mapping
+        case pattern.pattern_type
+        when "equivalent_validation"
+          "validation_equivalent"
+        when "different_validation"
+          "validation_different"
+        end
+      end
+
+      def calculate_mapping_confidence(pattern, _semantic_key)
+        # Calculate confidence based on pattern similarity
+        case pattern.pattern_type
+        when "equivalent_validation"
+          0.9
+        when "different_validation"
+          0.5
+        else
+          0.1
+        end
+      end
+    end
+  end
+end

data/lib/svg_conform/compatibility/xml_analysis_engine.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require_relative "../semantic_comparator"
+require_relative "../remediation_runner"
+
+module SvgConform
+  module Compatibility
+    # Handles XML-specific analysis operations for embedded SVG elements
+    class XmlAnalysisEngine
+      def initialize(context, file_processor)
+        @context = context
+        @file_processor = file_processor
+      end
+
+      def analyze_file(filename, svgcheck_report)
+        input_file = @file_processor.input_file_path(filename)
+        doc = parse_xml_file(input_file)
+        return nil unless doc
+
+        svg_elements = extract_svg_elements(doc)
+        return nil if svg_elements.empty?
+
+        display_analysis_header(filename, svg_elements.length)
+        process_svg_elements(svg_elements, filename, svgcheck_report)
+      end
+
+      private
+
+      def parse_xml_file(input_file)
+        require "moxml"
+        xml_content = File.read(input_file)
+        moxml = Moxml.new
+        moxml.parse(xml_content)
+      rescue StandardError => e
+        puts "❌ Error parsing XML file: #{e.message}"
+        nil
+      end
+
+      def extract_svg_elements(doc)
+        svg_elements = doc.xpath("//svg:svg", "svg" => "http://www.w3.org/2000/svg")
+
+        puts "❌ No SVG elements found in XML file" if svg_elements.empty?
+
+        svg_elements
+      end
+
+      def display_analysis_header(filename, element_count)
+        mode_icon = @context.repair_mode? ? "🔧" : "📋"
+        mode_text = @context.repair_mode? ? "Repair Analysis" : "Analysis"
+
+        puts Paint["#{mode_icon} XML File #{mode_text}: #{filename}", :cyan,
+                   :bold]
+        puts "Found #{element_count} embedded SVG element(s)"
+        puts
+      end
+
+      def process_svg_elements(svg_elements, filename, svgcheck_report)
+        svg_elements.each_with_index do |svg_element, index|
+          puts Paint["🔍 Analyzing SVG Element #{index + 1}:", :blue, :bold]
+          process_single_svg_element(svg_element, filename, index,
+                                     svgcheck_report)
+        end
+      end
+
+      def process_single_svg_element(svg_element, filename, index,
+svgcheck_report)
+        svg_content = svg_element.to_xml
+        element_filename = "#{filename}#svg#{index + 1}"
+
+        require "tempfile"
+        temp_file = Tempfile.new(["embedded_svg", ".svg"])
+
+        begin
+          temp_file.write(svg_content)
+          temp_file.close
+
+          if @context.repair_mode?
+            process_embedded_svg_repair(element_filename, svg_content,
+                                        svgcheck_report)
+          else
+            process_embedded_svg_validation(element_filename, temp_file.path,
+                                            svgcheck_report)
+          end
+        ensure
+          temp_file.unlink
+        end
+      end
+
+      def process_embedded_svg_validation(element_filename, temp_file_path,
+svgcheck_report)
+        svg_conform_result = run_validation(temp_file_path)
+        svg_conform_report = create_conformance_report(element_filename,
+                                                       svg_conform_result)
+
+        if @context.semantic_analysis?
+          build_semantic_validation_result(element_filename,
+                                           svg_conform_report, svgcheck_report)
+        else
+          build_basic_validation_result(element_filename, svg_conform_report,
+                                        svgcheck_report)
+        end
+      end
+
+      def process_embedded_svg_repair(element_filename, svg_content,
+svgcheck_report)
+        remediation_runner = SvgConform::RemediationRunner.new(profile: @context.profile)
+        svg_conform_result = remediation_runner.run_remediation(svg_content,
+                                                                filename: element_filename)
+
+        if @context.semantic_analysis?
+          build_semantic_repair_result(element_filename, svg_conform_result,
+                                       svgcheck_report)
+        else
+          build_basic_repair_result(element_filename, svg_conform_result,
+                                    svgcheck_report)
+        end
+      end
+
+      def run_validation(temp_file_path)
+        validator = SvgConform::Validator.new
+        validator.validate_file(temp_file_path, profile: @context.profile)
+      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)
+
+        ComparisonResult.new(
+          filename: filename,
+          type: :semantic_repair,
+          validation_comparison: validation_comparison,
+          content_comparison: content_comparison,
+          xml_equivalence: nil, # XML files don't have repaired file comparison
+        )
+      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
+    end
+  end
+end