svg_conform 0.1.0

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative "parser"
+require_relative "../../conformance_report"
+
+module SvgConform
+  module ExternalCheckers
+    module Svgcheck
+      # Generates ConformanceReport objects from svgcheck outputs
+      class ReportGenerator
+        def initialize(parser: nil)
+          @parser = parser || Parser.new
+        end
+
+        # Generate a report from svgcheck output files
+        def generate_from_files(filename, output_file: nil, error_file: nil,
+code_file: nil)
+          output_content = output_file && File.exist?(output_file) ? File.read(output_file) : nil
+          error_content = error_file && File.exist?(error_file) ? File.read(error_file) : nil
+          exit_code = code_file && File.exist?(code_file) ? File.read(code_file).strip.to_i : 0
+
+          generate_from_content(filename, output_content, error_content,
+                                exit_code)
+        end
+
+        # Generate a report from svgcheck output content
+        def generate_from_content(filename, output_content,
+error_content = nil, exit_code = 0)
+          # svgcheck writes validation messages to stderr, not stdout
+          # So we use error_content as the main content to parse
+          main_content = error_content || output_content
+
+          report = @parser.parse(main_content, nil, filename: filename)
+
+          # Set additional metadata
+          report.profile = "svg_1_2_rfc" # svgcheck is specifically for SVG 1.2 RFC
+          report.version = detect_svgcheck_version
+
+          # Use exit code to determine validity if needed
+          if exit_code != 0 && report.valid
+            report.valid = false
+          end
+
+          report
+        end
+
+        # Generate reports for both check and repair modes
+        def generate_comparative_reports(filename, check_outputs: nil,
+repair_outputs: nil)
+          reports = {}
+
+          if check_outputs
+            reports[:check] = generate_from_content(
+              filename,
+              check_outputs[:stdout],
+              check_outputs[:stderr],
+              check_outputs[:exit_code],
+            )
+          end
+
+          if repair_outputs
+            reports[:repair] = generate_from_content(
+              filename,
+              repair_outputs[:stdout],
+              repair_outputs[:stderr],
+              repair_outputs[:exit_code],
+            )
+          end
+
+          reports
+        end
+
+        private
+
+        def detect_svgcheck_version
+          # Try to detect svgcheck version - placeholder for now
+          "unknown"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+require_relative "output_generator"
+require_relative "report_generator"
+require_relative "report_comparator"
+require_relative "../../validator"
+require_relative "../../profiles"
+
+module SvgConform
+  module ExternalCheckers
+    module Svgcheck
+      # Pipeline to ensure svg_conform outputs are compatible with svgcheck
+      class ValidationPipeline
+        attr_reader :test_files_dir, :output_dir
+
+        def initialize(test_files_dir: "svgcheck/svgcheck/Tests",
+output_dir: "spec/fixtures/svgcheck")
+          @test_files_dir = test_files_dir
+          @output_dir = output_dir
+          @generator = OutputGenerator.new
+          @report_generator = ReportGenerator.new
+          @comparator = ReportComparator.new(test_files_dir: test_files_dir,
+                                             svgcheck_outputs_dir: output_dir)
+        end
+
+        # Run complete validation pipeline
+        def run_validation_pipeline(mode: :both)
+          results = {
+            stage: "complete_pipeline",
+            total_files: 0,
+            successful_generations: 0,
+            successful_comparisons: 0,
+            failed_generations: 0,
+            failed_comparisons: 0,
+            compatibility_issues: [],
+            summary: {},
+          }
+
+          test_files = find_test_files
+          results[:total_files] = test_files.length
+
+          puts "🚀 Starting validation pipeline for #{test_files.length} files..."
+
+          # Stage 1: Generate svgcheck outputs
+          puts "\n📋 Stage 1: Generating svgcheck outputs..."
+          generation_results = generate_outputs_for_files(test_files, mode)
+          results[:successful_generations] = generation_results[:successful]
+          results[:failed_generations] = generation_results[:failed]
+
+          # Stage 2: Compare reports
+          puts "\n📋 Stage 2: Comparing svg_conform vs svgcheck reports..."
+          comparison_results = compare_all_reports
+          results[:successful_comparisons] = comparison_results[:matching]
+          results[:failed_comparisons] = comparison_results[:different]
+          results[:compatibility_issues] = comparison_results[:differences]
+
+          # Stage 3: Generate summary
+          results[:summary] = generate_pipeline_summary(results)
+
+          results
+        end
+
+        # Validate output compatibility for a single file
+        def validate_file_compatibility(filename)
+          result = {
+            filename: filename,
+            svg_conform_validation: nil,
+            svgcheck_outputs: nil,
+            comparison: nil,
+            compatible: false,
+            issues: [],
+          }
+
+          begin
+            # Generate svg_conform validation
+            result[:svg_conform_validation] =
+              generate_svg_conform_validation(filename)
+
+            # Generate svgcheck outputs
+            result[:svgcheck_outputs] =
+              @generator.generate(filename, mode: :both)
+
+            # Compare outputs
+            if result[:svgcheck_outputs].values.all? { |r| r[:success] }
+              result[:comparison] = @comparator.compare_file(filename)
+              result[:compatible] = result[:comparison][:identical]
+
+              unless result[:compatible]
+                result[:issues] =
+                  extract_compatibility_issues(result[:comparison])
+              end
+            else
+              result[:issues] << "Failed to generate svgcheck outputs"
+            end
+          rescue StandardError => e
+            result[:issues] << "Error during validation: #{e.message}"
+          end
+
+          result
+        end
+
+        # Generate comprehensive compatibility report
+        def generate_compatibility_report
+          pipeline_results = run_validation_pipeline
+
+          {
+            timestamp: Time.now.iso8601,
+            pipeline_version: SvgConform::VERSION,
+            total_files: pipeline_results[:total_files],
+            compatibility_score: calculate_compatibility_score(pipeline_results),
+            results: pipeline_results,
+            recommendations: generate_recommendations(pipeline_results),
+          }
+        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_outputs_for_files(test_files, mode)
+          results = { successful: 0, failed: 0, errors: [] }
+
+          test_files.each do |filename|
+            outputs = @generator.generate(filename, mode: mode)
+
+            if outputs.values.all? { |result| result[:success] }
+              results[:successful] += 1
+              puts "  ✅ #{filename}"
+            else
+              results[:failed] += 1
+              puts "  ❌ #{filename}"
+              results[:errors] << { filename: filename,
+                                    error: "Generation failed" }
+            end
+          rescue StandardError => e
+            results[:failed] += 1
+            puts "  ❌ #{filename}: #{e.message}"
+            results[:errors] << { filename: filename, error: e.message }
+          end
+
+          results
+        end
+
+        def compare_all_reports
+          @comparator.compare_all_test_files
+        end
+
+        def generate_svg_conform_validation(filename)
+          input_file = File.join(@test_files_dir, filename)
+          return nil unless File.exist?(input_file)
+
+          profile = SvgConform::Profiles.load_profile(:svg_1_2_rfc)
+          validator = SvgConform::Validator.new(profile)
+          validator.validate_file(input_file)
+        end
+
+        def extract_compatibility_issues(comparison)
+          issues = []
+
+          # Add basic comparison issues
+          comparison[:differences]&.each do |diff|
+            issues << "Report difference: #{diff}"
+          end
+
+          # Add semantic comparison issues
+          if comparison[:semantic] && comparison[:semantic][:issues].any?
+            comparison[:semantic][:issues].each do |semantic_issue|
+              issues << "Semantic mismatch: #{semantic_issue[:semantic_key]} " \
+                       "(svg_conform: #{semantic_issue[:svg_conform_count]}, " \
+                       "svgcheck: #{semantic_issue[:svgcheck_count]})"
+            end
+          end
+
+          issues
+        end
+
+        def calculate_compatibility_score(pipeline_results)
+          return 0.0 if pipeline_results[:total_files].zero?
+
+          successful_files = pipeline_results[:successful_comparisons]
+          total_files = pipeline_results[:total_files]
+
+          (successful_files.to_f / total_files * 100).round(2)
+        end
+
+        def generate_recommendations(pipeline_results)
+          recommendations = []
+
+          # Generation issues
+          if pipeline_results[:failed_generations].positive?
+            recommendations << {
+              category: "generation",
+              priority: "high",
+              message: "#{pipeline_results[:failed_generations]} files failed svgcheck output generation. " \
+                      "Check svgcheck installation and test file accessibility.",
+            }
+          end
+
+          # Compatibility issues
+          if pipeline_results[:failed_comparisons].positive?
+            recommendations << {
+              category: "compatibility",
+              priority: "high",
+              message: "#{pipeline_results[:failed_comparisons]} files show compatibility issues. " \
+                      "Review profile configuration and requirement mappings.",
+            }
+          end
+
+          # Profile issues
+          compatibility_score = calculate_compatibility_score(pipeline_results)
+          if compatibility_score < 90.0
+            recommendations << {
+              category: "profile",
+              priority: "medium",
+              message: "Compatibility score is #{compatibility_score}%. " \
+                      "Consider reviewing svg_1_2_rfc profile configuration against svgcheck source.",
+            }
+          end
+
+          recommendations
+        end
+
+        def generate_pipeline_summary(results)
+          {
+            compatibility_score: calculate_compatibility_score(results),
+            generation_success_rate: calculate_success_rate(
+              results[:successful_generations], results[:total_files]
+            ),
+            comparison_success_rate: calculate_success_rate(
+              results[:successful_comparisons], results[:total_files]
+            ),
+            total_issues: results[:compatibility_issues].length,
+          }
+        end
+
+        def calculate_success_rate(successful, total)
+          return 0.0 if total.zero?
+
+          (successful.to_f / total * 100).round(2)
+        end
+      end
+    end
+  end
+end

data/lib/svg_conform/external_checkers/svgcheck.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "svgcheck/parser"
+require_relative "svgcheck/compatibility_engine"
+require_relative "svgcheck/report_generator"
+require_relative "svgcheck/output_generator"
+require_relative "svgcheck/validation_pipeline"
+require_relative "svgcheck/report_comparator"
+
+module SvgConform
+  module ExternalCheckers
+    # SVGCheck external checker integration
+    module Svgcheck
+      # Main svgcheck checker class
+      class Checker < BaseChecker
+        SVGCHECK_EXECUTABLE = "python3"
+        SVGCHECK_MODULE_PATH = "svgcheck/svgcheck"
+
+        def initialize
+          super(name: "svgcheck", version: detect_version)
+        end
+
+        def available?
+          command_available?(SVGCHECK_EXECUTABLE) &&
+            Dir.exist?(SVGCHECK_MODULE_PATH)
+        end
+
+        def generate_outputs(input_file, mode: :both)
+          generator = OutputGenerator.new(
+            svgcheck_exec: SVGCHECK_EXECUTABLE,
+            svgcheck_path: SVGCHECK_MODULE_PATH,
+          )
+          generator.generate(input_file, mode: mode)
+        end
+
+        def parse_output(output_content, error_content = nil)
+          parser = Parser.new
+          parser.parse(output_content, error_content)
+        end
+
+        private
+
+        def detect_version
+          # Try to detect svgcheck version - placeholder for now
+          "unknown"
+        end
+
+        def command_available?(command)
+          system("which #{command} > /dev/null 2>&1") ||
+            system("where #{command} > NUL 2>&1") || # Windows
+            File.executable?(command) # Direct path
+        end
+      end
+    end
+  end
+end

data/lib/svg_conform/external_checkers.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module SvgConform
+  # Namespace for external SVG conformance checkers
+  # This allows for multiple external checker integrations while keeping them separate
+  module ExternalCheckers
+    autoload :Svgcheck, "svg_conform/external_checkers/svgcheck"
+
+    # Base class for external checker integrations
+    class BaseChecker
+      attr_reader :name, :version
+
+      def initialize(name:, version: nil)
+        @name = name
+        @version = version
+      end
+
+      # Generate outputs for a given file - to be implemented by subclasses
+      def generate_outputs(input_file, mode: :both)
+        raise NotImplementedError, "Subclasses must implement generate_outputs"
+      end
+
+      # Parse checker output into a ConformanceReport - to be implemented by subclasses
+      def parse_output(output_content, error_content = nil)
+        raise NotImplementedError, "Subclasses must implement parse_output"
+      end
+
+      # Check if the checker is available on the system
+      def available?
+        raise NotImplementedError, "Subclasses must implement available?"
+      end
+    end
+  end
+end

data/lib/svg_conform/fixer.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module SvgConform
+  # Utility class for applying fixes to SVG documents
+  class Fixer
+    attr_reader :document, :fixes_applied
+
+    def initialize(document)
+      @document = document
+      @fixes_applied = []
+    end
+
+    # Apply a single fix
+    def apply_fix(fix)
+      return false unless fix.respond_to?(:call) || fix.respond_to?(:apply)
+
+      begin
+        result = if fix.respond_to?(:call)
+                   fix.call
+                 else
+                   fix.apply
+                 end
+
+        @fixes_applied << fix if result
+        result
+      rescue StandardError
+        false
+      end
+    end
+
+    # Apply multiple fixes
+    def apply_fixes(fixes)
+      success_count = 0
+
+      fixes.each do |fix|
+        success_count += 1 if apply_fix(fix)
+      end
+
+      success_count
+    end
+
+    # Apply all fixable issues from a validation result
+    def apply_validation_fixes(validation_result)
+      fixable_issues = (validation_result.errors + validation_result.warnings).select(&:fixable?)
+      apply_fixes(fixable_issues.map(&:fix))
+    end
+
+    def fixes_count
+      @fixes_applied.size
+    end
+
+    def to_xml
+      @document.to_xml
+    end
+  end
+end

data/lib/svg_conform/profile.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+require_relative "requirements"
+require_relative "remediations"
+
+module SvgConform
+  # Base class for SVG validation profiles using lutaml-model serialization
+  class Profile < Lutaml::Model::Serializable
+    attribute :name, :string
+    attribute :description, :string
+    attribute :import, :string
+    attribute :requirements, SvgConform::Requirements::BaseRequirement,
+              collection: true, polymorphic: true
+    attribute :remediations, SvgConform::Remediations::BaseRemediation,
+              collection: true, polymorphic: true
+
+    def self.build_class_map(dir_name, namespace, excluded_file)
+      target_dir = File.expand_path(dir_name, __dir__)
+      class_map = {}
+
+      Dir.glob(File.join(target_dir,
+                         "*_#{dir_name.chomp('s')}.rb")).each do |file|
+        filename = File.basename(file, ".rb")
+        next if filename == excluded_file
+
+        class_name = filename.split("_").map(&:capitalize).join
+        class_map[class_name] = "SvgConform::#{namespace}::#{class_name}"
+      end
+
+      class_map
+    end
+
+    # Build class maps dynamically from filesystem
+    REQUIREMENTS_CLASS_MAP = build_class_map(
+      "requirements", "Requirements", "base_requirement"
+    )
+    REMEDIATIONS_CLASS_MAP = build_class_map(
+      "remediations", "Remediations", "base_remediation"
+    )
+
+    yaml do
+      map "name", to: :name
+      map "description", to: :description
+      map "import", to: :import
+      map "requirements", to: :requirements, polymorphic: {
+        attribute: "type",
+        class_map: REQUIREMENTS_CLASS_MAP,
+      }
+      map "remediations", to: :remediations, polymorphic: {
+        attribute: "type",
+        class_map: REMEDIATIONS_CLASS_MAP,
+      }
+    end
+
+    # New requirement methods
+    def add_requirement(requirement)
+      self.requirements ||= []
+      requirements << requirement
+      self
+    end
+
+    def remove_requirement(requirement_id)
+      return self unless requirements
+
+      requirements.reject! { |req| req.id == requirement_id }
+      self
+    end
+
+    def has_requirement?(requirement_id)
+      return false unless requirements
+
+      requirements.any? { |req| req.id == requirement_id }
+    end
+
+    def get_requirement(requirement_id)
+      return nil unless requirements
+
+      requirements.find { |req| req.id == requirement_id }
+    end
+
+    def requirement_count
+      requirements&.size || 0
+    end
+
+    # New remediation methods
+    def add_remediation(remediation)
+      self.remediations ||= []
+      remediations << remediation
+      self
+    end
+
+    def remove_remediation(remediation_id)
+      return self unless remediations
+
+      remediations.reject! { |rem| rem.id == remediation_id }
+      self
+    end
+
+    def has_remediation?(remediation_id)
+      return false unless remediations
+
+      remediations.any? { |rem| rem.id == remediation_id }
+    end
+
+    def get_remediation(remediation_id)
+      return nil unless remediations
+
+      remediations.find { |rem| rem.id == remediation_id }
+    end
+
+    def remediation_count
+      remediations&.size || 0
+    end
+
+    def validate(document)
+      context = ValidationContext.new(document, self)
+
+      # Validate using requirements system
+      requirements&.each do |requirement|
+        requirement.validate_document(document, context)
+      end
+
+      ValidationResult.new(document, self, context)
+    end
+
+    def validate_file(file_path)
+      document = Document.from_file(file_path)
+      validate(document)
+    end
+
+    # Apply remediations to a document after validation
+    def apply_remediations(document)
+      # Run validation to get failed requirements
+      validation_result = validate(document)
+
+      all_changes = []
+
+      # Apply remediations for failed requirements
+      remediations&.each do |remediation|
+        if remediation.should_execute?(validation_result.failed_requirements)
+          changes = remediation.apply(document, nil)
+          all_changes.concat(changes) if changes
+        end
+      end
+
+      all_changes
+    end
+
+    # Simple YAML loading methods for individual profiles
+    def self.load_from_file(file_path)
+      yaml_content = File.read(file_path)
+      from_yaml(yaml_content)
+    end
+
+    def self.save_to_file(profile, file_path)
+      File.write(file_path, profile.to_yaml)
+    end
+
+    def to_s
+      "#{name}: #{description} (#{requirement_count} checks, #{remediation_count} remediations)"
+    end
+  end
+end

data/lib/svg_conform/profiles.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "profile"
+
+module SvgConform
+  module Profiles
+    PROFILES_DIR = File.expand_path("../../config/profiles", __dir__)
+    @@cache = {}
+
+    def self.get(profile_id)
+      case profile_id
+      when Symbol, String
+        load_profile(profile_id.to_s)
+      when Profile
+        profile_id
+      else
+        raise ProfileError, "Invalid profile: #{profile_id}"
+      end
+    end
+
+    def self.available_profiles
+      return @@cache.keys.map(&:to_sym) if @@cache.any?
+
+      profile_files = Dir.glob(File.join(PROFILES_DIR, "*.yml"))
+      profile_files.map { |file| File.basename(file, ".yml").to_sym }
+    end
+
+    def self.load(profile_name)
+      load_profile(profile_name.to_s)
+    end
+
+    def self.list
+      available_profiles.map(&:to_s)
+    end
+
+    def self.clear_cache!
+      @@cache.clear
+    end
+
+    def self.load_profile(profile_name)
+      return @@cache[profile_name] if @@cache[profile_name]
+
+      profile_file = File.join(PROFILES_DIR, "#{profile_name}.yml")
+
+      unless File.exist?(profile_file)
+        raise ProfileError,
+              "Profile not found: #{profile_name} (expected: #{profile_file})"
+      end
+
+      begin
+        profile = Profile.load_from_file(profile_file)
+        @@cache[profile_name] = profile
+        profile
+        # rescue => e
+        #   raise e
+        #   raise ProfileError, "Failed to load profile #{profile_name}: #{e.message}"
+      end
+    end
+  end
+end