svg_conform 0.1.0

data/lib/svg_conform/remediation_engine.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module SvgConform
+  # Engine for applying remediations to SVG documents based on validation failures
+  class RemediationEngine
+    attr_reader :profile, :results
+
+    def initialize(profile)
+      @profile = profile
+      @results = []
+    end
+
+    # Apply remediations for failed requirements
+    def apply_remediations(document, validation_result)
+      @results.clear
+
+      # Group failed requirements by their remediations
+      remediation_groups = group_requirements_by_remediations(validation_result.failed_requirements)
+
+      # Apply each remediation only once, even if it targets multiple failed requirements
+      remediation_groups.each do |remediation, failed_requirements|
+        result = remediation.execute(document, failed_requirements)
+        @results << result
+      end
+
+      @results
+    end
+
+    # Get remediations that would apply to given failed requirements
+    def applicable_remediations(failed_requirements)
+      failed_requirement_ids = failed_requirements.map do |req|
+        req.requirement_id || req.rule&.id
+      end
+
+      @profile.remediations.select do |remediation|
+        remediation.targets.any? do |req_id|
+          failed_requirement_ids.include?(req_id)
+        end
+      end
+    end
+
+    # Check if any remediations are available for the profile
+    def has_remediations?
+      @profile.remediation_count.positive?
+    end
+
+    # Get summary of remediation results
+    def summary
+      return "No remediations applied" if @results.empty?
+
+      successful = @results.count(&:success?)
+      failed = @results.count(&:failure?)
+      total_changes = @results.sum(&:changes_count)
+
+      "Applied #{successful} remediations successfully, #{failed} failed. Total changes: #{total_changes}"
+    end
+
+    # Get successful remediation results
+    def successful_results
+      @results.select(&:success?)
+    end
+
+    # Get failed remediation results
+    def failed_results
+      @results.select(&:failure?)
+    end
+
+    # Get total number of changes made
+    def total_changes
+      @results.sum(&:changes_count)
+    end
+
+    private
+
+    # Group failed requirements by the remediations that target them
+    def group_requirements_by_remediations(failed_requirements)
+      groups = {}
+
+      @profile.remediations.each do |remediation|
+        # Find failed requirements that this remediation targets
+        targeted_failures = failed_requirements.select do |failure|
+          remediation.targets.include?(failure.requirement_id)
+        end
+
+        # Only include remediations that have applicable failures
+        groups[remediation] = targeted_failures unless targeted_failures.empty?
+      end
+
+      groups
+    end
+  end
+end

data/lib/svg_conform/remediation_result.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module SvgConform
+  # Result object for remediation operations
+  class RemediationResult
+    attr_reader :remediation_id, :success, :failed_requirements, :message,
+                :changes_made, :error
+
+    def initialize(remediation_id:, success:, failed_requirements:,
+message: nil, changes_made: [], error: nil)
+      @remediation_id = remediation_id
+      @success = success
+      @failed_requirements = failed_requirements
+      @message = message
+      @changes_made = changes_made || []
+      @error = error
+    end
+
+    def success?
+      @success
+    end
+
+    def failure?
+      !@success
+    end
+
+    def changes_count
+      @changes_made.size
+    end
+
+    def to_s
+      status = success? ? "SUCCESS" : "FAILURE"
+      "#{@remediation_id}: #{status} - #{@message}"
+    end
+  end
+end

data/lib/svg_conform/remediation_runner.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require_relative "validator"
+require_relative "remediation_engine"
+require_relative "document"
+
+module SvgConform
+  # Runner for applying SvgConform remediations to SVG content
+  class RemediationRunner
+    attr_reader :profile, :options
+
+    def initialize(profile: :svg_1_2_rfc, options: {})
+      @profile = resolve_profile(profile)
+      @options = {
+        verbose: false,
+        strict: false,
+      }.merge(options)
+    end
+
+    # Run validation and remediation on SVG content
+    def run_remediation(svg_content, filename: nil)
+      # Parse the SVG content
+      document = SvgConform::Document.from_content(svg_content)
+
+      # Perform initial validation
+      initial_validation = @profile.validate(document)
+
+      # Create remediation engine
+      remediation_engine = SvgConform::RemediationEngine.new(@profile)
+
+      # Apply remediations if there are failures
+      remediation_results = []
+      if initial_validation.failed_requirements.any?
+        remediation_results = remediation_engine.apply_remediations(document,
+                                                                    initial_validation)
+      end
+
+      # Perform final validation after remediations
+      final_validation = @profile.validate(document)
+
+      # Create result object
+      RemediationRunResult.new(
+        filename: filename,
+        original_content: svg_content,
+        remediated_content: document.to_xml,
+        initial_validation: initial_validation,
+        final_validation: final_validation,
+        remediation_results: remediation_results,
+        remediation_engine: remediation_engine,
+      )
+    end
+
+    # Run remediation on a file
+    def run_remediation_file(file_path)
+      raise "File not found: #{file_path}" unless File.exist?(file_path)
+
+      svg_content = File.read(file_path)
+      filename = File.basename(file_path)
+
+      run_remediation(svg_content, filename: filename)
+    end
+
+    # Run remediation on multiple files
+    def run_remediation_batch(file_paths)
+      results = {}
+
+      file_paths.each do |file_path|
+        results[file_path] = run_remediation_file(file_path)
+      rescue StandardError => e
+        results[file_path] = create_error_result(file_path, e)
+      end
+
+      results
+    end
+
+    # Check if profile has any remediations available
+    def has_remediations?
+      @profile.remediation_count.positive?
+    end
+
+    # Get available remediations for the profile
+    def available_remediations
+      @profile.remediations
+    end
+
+    private
+
+    def resolve_profile(profile)
+      case profile
+      when Symbol, String
+        SvgConform::Profiles.get(profile) || raise("Unknown profile: #{profile}")
+      when SvgConform::Profile
+        profile
+      else
+        raise "Invalid profile type: #{profile.class}"
+      end
+    end
+
+    def create_error_result(file_path, error)
+      RemediationRunResult.new(
+        filename: File.basename(file_path),
+        original_content: nil,
+        remediated_content: nil,
+        initial_validation: nil,
+        final_validation: nil,
+        remediation_results: [],
+        remediation_engine: nil,
+        error: error,
+      )
+    end
+  end
+
+  # Result object for overall remediation run (not individual remediation result)
+  class RemediationRunResult
+    attr_reader :filename, :original_content, :remediated_content,
+                :initial_validation, :final_validation, :remediation_results,
+                :remediation_engine, :error
+
+    def initialize(filename:, original_content:, remediated_content:,
+                   initial_validation:, final_validation:, remediation_results:,
+                   remediation_engine:, error: nil)
+      @filename = filename
+      @original_content = original_content
+      @remediated_content = remediated_content
+      @initial_validation = initial_validation
+      @final_validation = final_validation
+      @remediation_results = remediation_results
+      @remediation_engine = remediation_engine
+      @error = error
+    end
+
+    # Check if remediation was successful
+    def success?
+      @error.nil? && @final_validation&.valid?
+    end
+
+    # Check if there was an error
+    def error?
+      !@error.nil?
+    end
+
+    # Get the number of issues fixed
+    def issues_fixed
+      return 0 if @error || @initial_validation.nil? || @final_validation.nil?
+
+      initial_errors = @initial_validation.failed_requirements.length
+      final_errors = @final_validation.failed_requirements.length
+
+      [initial_errors - final_errors, 0].max
+    end
+
+    # Get the number of remediations applied
+    def remediations_applied
+      @remediation_results&.length || 0
+    end
+
+    # Get successful remediations
+    def successful_remediations
+      return [] if @remediation_results.nil?
+
+      @remediation_results.select(&:success?)
+    end
+
+    # Get failed remediations
+    def failed_remediations
+      return [] if @remediation_results.nil?
+
+      @remediation_results.select(&:failure?)
+    end
+
+    # Check if content was modified
+    def content_modified?
+      return false if @original_content.nil? || @remediated_content.nil?
+
+      normalize_content(@original_content) != normalize_content(@remediated_content)
+    end
+
+    # Get summary of changes
+    def changes_summary
+      return "Error occurred" if @error
+      return "No validation performed" if @initial_validation.nil?
+
+      if content_modified?
+        "#{issues_fixed} issues fixed, #{remediations_applied} remediations applied"
+      else
+        "No changes needed"
+      end
+    end
+
+    # Convert to hash for serialization
+    def to_h
+      {
+        filename: @filename,
+        success: success?,
+        error: @error&.message,
+        issues_fixed: issues_fixed,
+        remediations_applied: remediations_applied,
+        content_modified: content_modified?,
+        changes_summary: changes_summary,
+        initial_errors: @initial_validation&.failed_requirements&.length || 0,
+        final_errors: @final_validation&.failed_requirements&.length || 0,
+        remediation_details: @remediation_results&.map(&:to_h) || [],
+      }
+    end
+
+    # Generate a conformance report for the final state
+    def generate_conformance_report
+      return nil if @final_validation.nil? || @filename.nil?
+
+      SvgConform::ConformanceReport.from_svg_conform_result(
+        @filename,
+        @final_validation,
+        profile: @remediation_engine&.profile&.name || :unknown,
+        use_svgcheck_mapping: true,
+      )
+    end
+
+    private
+
+    def normalize_content(content)
+      # Normalize whitespace and formatting for comparison
+      content.gsub(/\s+/, " ").strip
+    end
+  end
+end

data/lib/svg_conform/remediations/base_remediation.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+require_relative "../remediation_result"
+
+module SvgConform
+  module Remediations
+    # Base class for all remediations using lutaml-model serialization
+    class BaseRemediation < Lutaml::Model::Serializable
+      attribute :id, :string
+      attribute :description, :string
+      attribute :targets, :string, collection: true
+      attribute :config, :hash
+      attribute :type, :string, polymorphic_class: true, default: -> {
+        self.class.name.split("::").last
+      }
+
+      yaml do
+        map "id", to: :id
+        map "description", to: :description
+        map "targets", to: :targets
+        map "config", to: :config
+        map "type", to: :type
+      end
+
+      def apply(document, context)
+        raise NotImplementedError, "Subclasses must implement apply"
+      end
+
+      # Check if this remediation should execute based on failed requirements
+      def should_execute?(failed_requirements)
+        failed_requirement_ids = failed_requirements.map(&:requirement_id)
+        targets.any? { |req_id| failed_requirement_ids.include?(req_id) }
+      end
+
+      # Execute the remediation and return a result
+      def execute(document, failed_requirements)
+        unless should_execute?(failed_requirements)
+          return RemediationResult.new(
+            remediation_id: @id,
+            success: false,
+            failed_requirements: [],
+            message: "Remediation not applicable",
+          )
+        end
+
+        begin
+          context = { failed_requirements: failed_requirements }
+          changes_made = apply(document, context)
+
+          RemediationResult.new(
+            remediation_id: @id,
+            success: true,
+            failed_requirements: failed_requirements,
+            message: "Remediation applied successfully",
+            changes_made: changes_made,
+          )
+        rescue StandardError => e
+          RemediationResult.new(
+            remediation_id: @id,
+            success: false,
+            failed_requirements: failed_requirements,
+            message: "Remediation failed: #{e.message}",
+            error: e,
+          )
+        end
+      end
+
+      def to_s
+        "#{id}: #{description} (targets: #{targets.join(', ')})"
+      end
+
+      protected
+
+      def element?(node)
+        node.respond_to?(:name) && node.name
+      end
+
+      def get_attribute(node, attr_name)
+        return nil unless node.respond_to?(:[])
+
+        node[attr_name]
+      end
+
+      def set_attribute(node, attr_name, value)
+        return unless node.respond_to?(:[]=)
+
+        node[attr_name] = value
+      end
+
+      def has_attribute?(node, attr_name)
+        return false unless node.respond_to?(:[])
+
+        !node[attr_name].nil?
+      end
+
+      def find_nodes(document, &)
+        nodes = []
+        traverse_nodes(document, nodes, &)
+        nodes
+      end
+
+      # Helper method to remove attribute
+      def remove_attribute(node, name)
+        if node.respond_to?(:remove_attribute)
+          node.remove_attribute(name)
+          true
+        elsif node.respond_to?(:[]=) && node.respond_to?(:[])
+          # Fallback for different implementations
+          node[name] = nil
+          true
+        else
+          false
+        end
+      end
+
+      # Helper method to remove node
+      def remove_node(node)
+        return false unless node.respond_to?(:remove)
+
+        node.remove
+        true
+      end
+
+      # Helper method to replace node
+      def replace_node(node, replacement)
+        return false unless node.respond_to?(:replace)
+
+        node.replace(replacement)
+        true
+      end
+
+      # Helper method to create comment node
+      def create_comment(document, text)
+        document.create_comment(text)
+      end
+
+      def log_change(type, message, node = nil)
+        {
+          type: type,
+          message: message,
+          node: node&.name || "unknown",
+          node_attributes: node.respond_to?(:attributes) ? node.attributes : nil,
+          timestamp: Time.now,
+        }
+      end
+
+      private
+
+      def traverse_nodes(node, nodes, &block)
+        return unless node
+
+        # Add node if it matches the block condition
+        nodes << node if yield(node)
+
+        # Traverse children if the node supports it
+        if node.respond_to?(:children)
+          node.children.each { |child| traverse_nodes(child, nodes, &block) }
+        elsif node.respond_to?(:each)
+          node.each { |child| traverse_nodes(child, nodes, &block) }
+        end
+      end
+    end
+  end
+end