svg_conform 0.1.0

data/lib/svg_conform/validation_context.rb

@@ -0,0 +1,408 @@
+# frozen_string_literal: true
+
+require "set"
+
+module SvgConform
+  # Context object passed to rules during validation
+  class ValidationContext
+    attr_reader :document, :profile, :errors, :warnings, :fixes,
+                :validity_errors
+
+    def initialize(document, profile)
+      @document = document
+      @profile = profile
+      @errors = []
+      @warnings = []
+      @validity_errors = []
+      @infos = []
+      @data = {}
+      @structurally_invalid_node_ids = Set.new
+    end
+
+    # Mark a node as structurally invalid (e.g., invalid parent-child relationship)
+    # Other requirements should skip attribute validation on these nodes
+    # Also marks all descendants as invalid since they'll be removed with the parent
+    def mark_node_structurally_invalid(node)
+      node_id = generate_node_id(node)
+      @structurally_invalid_node_ids.add(node_id)
+
+      # Mark all descendants as invalid too
+      mark_descendants_invalid(node)
+    end
+
+    # Mark all descendants of a node as structurally invalid
+    def mark_descendants_invalid(node)
+      return unless node.respond_to?(:children)
+
+      node.children.each do |child|
+        child_id = generate_node_id(child)
+        @structurally_invalid_node_ids.add(child_id)
+        # Recursively mark descendants
+        mark_descendants_invalid(child)
+      end
+    end
+
+    # Check if a node is structurally invalid
+    def node_structurally_invalid?(node)
+      node_id = generate_node_id(node)
+      @structurally_invalid_node_ids.include?(node_id)
+    end
+
+    def add_error(node:, message:, rule: nil, requirement: nil,
+requirement_id: nil, severity: nil, fix: nil, data: {})
+      # Support both old rule system and new requirements system
+      rule_or_requirement = requirement || rule
+
+      error = ValidationIssue.new(
+        type: :error,
+        rule: rule_or_requirement,
+        node: node,
+        message: message,
+        fix: fix,
+        data: data,
+        requirement_id: requirement_id,
+        severity: severity,
+      )
+
+      # Handle special severity types
+      if severity == :validity_error
+        @validity_errors << error
+      else
+        @errors << error
+      end
+
+      error
+    end
+
+    def add_warning(rule:, node:, message:, fix: nil)
+      warning = ValidationIssue.new(
+        type: :warning,
+        rule: rule,
+        node: node,
+        message: message,
+        fix: fix,
+      )
+      @warnings << warning
+      warning
+    end
+
+    def add_fix(fix)
+      @fixes << fix
+    end
+
+    def has_errors?
+      !@errors.empty?
+    end
+
+    def has_warnings?
+      !@warnings.empty?
+    end
+
+    def has_fixes?
+      !@fixes.empty?
+    end
+
+    def issue_count
+      @errors.size + @warnings.size
+    end
+
+    def fixable_count
+      (@errors + @warnings).count(&:fixable?)
+    end
+
+    def set_data(key, value)
+      @data[key] = value
+    end
+
+    def get_data(key)
+      @data[key]
+    end
+
+    # Generate a unique identifier for a node based on its path
+    # Builds a stable path by walking up the parent chain
+    def generate_node_id(node)
+      return nil unless node.respond_to?(:name)
+
+      # Build path by walking up parent chain
+      path_parts = []
+      current = node
+
+      while current
+        if current.respond_to?(:name) && current.name
+          # Count previous siblings of the same type for position
+          position = 1
+          if current.respond_to?(:previous_sibling)
+            sibling = current.previous_sibling
+            while sibling
+              position += 1 if sibling.respond_to?(:name) && sibling.name == current.name
+              sibling = sibling.previous_sibling if sibling.respond_to?(:previous_sibling)
+            end
+          end
+
+          path_parts.unshift("#{current.name}[#{position}]")
+        end
+
+        # Stop if we reach the document root (doesn't have parent)
+        break unless current.respond_to?(:parent)
+
+        begin
+          current = current.parent
+        rescue NoMethodError
+          # Parent method failed, we're at root
+          break
+        end
+
+        break unless current
+      end
+
+      "/#{path_parts.join('/')}"
+    end
+  end
+
+  # Base class for validation issues
+  class ValidationIssue
+    attr_reader :type, :rule, :node, :message, :fix, :data,
+                :requirement_id_override, :severity
+
+    def initialize(type:, rule:, node:, message:, fix: nil, data: {},
+requirement_id: nil, severity: nil, violation_type: nil)
+      @type = type
+      @rule = rule
+      @node = node
+      @message = message
+      @fix = fix
+      @data = data
+      @requirement_id_override = requirement_id
+      @severity = severity
+      @violation_type = violation_type || detect_violation_type
+    end
+
+    def requirement_id
+      return @requirement_id_override.to_s if @requirement_id_override
+
+      if @rule.respond_to?(:id)
+        @rule.id.to_s
+      elsif @rule.respond_to?(:class) && @rule.class.respond_to?(:name)
+        # Extract ID from class name for requirements
+        class_name = @rule.class.name.split("::").last
+        class_name.gsub(/Requirement$/, "").downcase.gsub(/([a-z])([A-Z])/,
+                                                          '\1_\2').downcase
+      else
+        "unknown"
+      end
+    end
+
+    def error?
+      @type == :error
+    end
+
+    def warning?
+      @type == :warning
+    end
+
+    def fixable?
+      !@fix.nil?
+    end
+
+    def line
+      @node.respond_to?(:line) ? @node.line : nil
+    end
+
+    def column
+      @node.respond_to?(:column) ? @node.column : nil
+    end
+
+    def element_name
+      @node.respond_to?(:name) ? @node.name : nil
+    end
+
+    def apply_fix
+      return false unless fixable?
+
+      begin
+        if @fix.respond_to?(:call)
+          @fix.call
+        else
+          @fix.apply
+        end
+        true
+      rescue StandardError
+        false
+      end
+    end
+
+    def to_h
+      {
+        type: @type,
+        rule: rule_id,
+        message: @message,
+        line: line,
+        column: column,
+        element: element_name,
+        fixable: fixable?,
+      }
+    end
+
+    def violation_type
+      @violation_type
+    end
+
+    def remediable?
+      case @violation_type
+      when :color_violation, :font_violation, :content_violation, :reference_violation,
+           :namespace_violation, :viewbox_violation, :style_violation
+        true
+      when :structural_violation
+        false
+      else
+        # Default to remediable for backward compatibility
+        true
+      end
+    end
+
+    def remediation_type
+      case @violation_type
+      when :color_violation, :font_violation
+        :convert
+      when :content_violation, :reference_violation, :namespace_violation
+        :remove
+      when :viewbox_violation
+        :add
+      when :style_violation
+        :promote
+      else
+        :unknown
+      end
+    end
+
+    def remediation_confidence
+      case @violation_type
+      when :color_violation, :font_violation, :style_violation
+        :automatic
+      when :viewbox_violation, :namespace_violation
+        :safe_structural
+      when :content_violation, :reference_violation
+        :safe_removal
+      else
+        :manual_review
+      end
+    end
+
+    def suggested_action
+      case @violation_type
+      when :color_violation
+        "Convert color to allowed equivalent using CssColor"
+      when :font_violation
+        "Map font family to generic equivalent"
+      when :content_violation
+        "Remove forbidden element or attribute"
+      when :reference_violation
+        "Remove broken reference or containing element"
+      when :namespace_violation
+        "Fix namespace declarations and remove invalid elements/attributes"
+      when :viewbox_violation
+        "Add missing viewBox attribute"
+      when :style_violation
+        "Promote style properties to attributes"
+      when :structural_violation
+        "Manual fix required - document structure issue"
+      else
+        "Apply available remediation"
+      end
+    end
+
+    def affects_content?
+      case @violation_type
+      when :content_violation, :reference_violation
+        true
+      when :color_violation, :font_violation, :style_violation, :viewbox_violation, :namespace_violation
+        false
+      else
+        false
+      end
+    end
+
+    def to_s
+      location = line ? " at line #{line}" : ""
+      location += ":#{column}" if column
+      rule_info = rule_id ? " (#{rule_id})" : ""
+      remediation_info = remediable? ? " [#{remediation_type}]" : " [NOT REMEDIABLE]"
+      "#{@message}#{location}#{rule_info}#{remediation_info}"
+    end
+
+    def to_h
+      {
+        type: @type,
+        rule: rule_id,
+        message: @message,
+        line: line,
+        column: column,
+        element: element_name,
+        fixable: fixable?,
+        remediable: remediable?,
+        violation_type: @violation_type,
+        remediation_type: remediation_type,
+        remediation_confidence: remediation_confidence,
+        suggested_action: suggested_action,
+        affects_content: affects_content?,
+      }
+    end
+
+    private
+
+    def detect_violation_type
+      req_id = requirement_id.downcase
+      msg = @message.downcase
+
+      # First check for structural violations (non-remediable)
+      return :structural_violation if msg.include?("root element must be") ||
+        msg.include?("malformed") ||
+        msg.include?("invalid document") ||
+        msg.include?("required element missing") ||
+        msg.include?("invalid hierarchy")
+
+      # Then check requirement-based violations (remediable)
+      case req_id
+      when /color/
+        :color_violation
+      when /font/
+        :font_violation
+      when /forbidden|content/
+        :content_violation
+      when /reference|id/
+        :reference_violation
+      when /namespace/
+        :namespace_violation
+      when /viewbox/
+        :viewbox_violation
+      when /style/
+        :style_violation
+      else
+        # Check message content for clues
+        return :color_violation if msg.include?("color")
+        return :font_violation if msg.include?("font")
+        return :content_violation if msg.include?("forbidden")
+        return :reference_violation if msg.include?("reference") || msg.include?("href")
+        return :namespace_violation if msg.include?("namespace")
+        return :viewbox_violation if msg.include?("viewbox")
+        return :style_violation if msg.include?("style")
+
+        :unknown_violation
+      end
+    end
+
+    def rule_id
+      return @requirement_id_override if @requirement_id_override
+      return @rule.id if @rule.respond_to?(:id)
+
+      if @rule.respond_to?(:class) && @rule.class.respond_to?(:name)
+        # Extract ID from class name for requirements
+        class_name = @rule.class.name.split("::").last
+        class_name.gsub(/Requirement$/, "").downcase.gsub(/([a-z])([A-Z])/,
+                                                          '\1_\2').downcase
+      else
+        "unknown"
+      end
+    end
+  end
+end

data/lib/svg_conform/validation_result.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "json"
+
+module SvgConform
+  # Represents the result of validating an SVG document
+  class ValidationResult
+    attr_reader :document, :profile, :errors, :warnings, :validity_errors,
+                :fixes_applied, :fixed_document
+
+    def initialize(document, profile, context)
+      @document = document
+      @profile = profile
+      @errors = context.errors
+      @warnings = context.warnings
+      @validity_errors = context.validity_errors
+      @fixes_applied = []
+      @fixed_document = nil
+    end
+
+    def valid?
+      @errors.empty? && @validity_errors.empty?
+    end
+
+    def has_errors?
+      !@errors.empty?
+    end
+
+    def has_warnings?
+      !@warnings.empty?
+    end
+
+    def fixable?
+      (@errors + @warnings).any?(&:fixable?)
+    end
+
+    def fixed?
+      !@fixed_document.nil?
+    end
+
+    def error_count
+      @errors.size
+    end
+
+    def warning_count
+      @warnings.size
+    end
+
+    def issue_count
+      error_count + warning_count
+    end
+
+    def fixable_count
+      (@errors + @warnings).count(&:fixable?)
+    end
+
+    def failed_requirements
+      @errors.select(&:requirement_id)
+    end
+
+    def apply_fixes
+      return self unless fixable?
+
+      # Create a copy of the document for fixing
+      @fixed_document = @document.dup
+      @fixes_applied = []
+
+      # Apply fixes for errors first, then warnings
+      fixable_issues = (@errors + @warnings).select(&:fixable?)
+
+      fixable_issues.each do |issue|
+        @fixes_applied << issue if issue.apply_fix
+      end
+
+      self
+    end
+
+    def to_s(format: :text)
+      case format
+      when :text
+        to_text
+      when :json
+        to_json
+      when :hash
+        to_h
+      else
+        to_text
+      end
+    end
+
+    def to_h
+      {
+        file: @document.file_path,
+        profile: @profile.name,
+        valid: valid?,
+        errors: @errors.map(&:to_h),
+        warnings: @warnings.map(&:to_h),
+        fixes_applied: @fixes_applied.size,
+        fixable: fixable_count,
+      }
+    end
+
+    def to_json(*args)
+      JSON.pretty_generate(to_h, *args)
+    end
+
+    private
+
+    def to_text
+      lines = []
+      lines << "SVG Conformance Report"
+      lines << "=" * 22
+      lines << ""
+      lines << "File: #{@document.file_path || 'inline'}"
+      lines << "Profile: #{@profile.name} (#{@profile.description})"
+      lines << "Status: #{valid? ? 'VALID' : 'INVALID'}"
+      lines << ""
+
+      if has_errors?
+        lines << "Errors (#{error_count}):"
+        @errors.each_with_index do |error, i|
+          lines << "  #{i + 1}. #{error}"
+        end
+        lines << ""
+      end
+
+      if has_warnings?
+        lines << "Warnings (#{warning_count}):"
+        @warnings.each_with_index do |warning, i|
+          lines << "  #{i + 1}. #{warning}"
+        end
+        lines << ""
+      end
+
+      if fixable?
+        lines << "Fixes Available: #{fixable_count}"
+        lines << "Fixes Applied: #{@fixes_applied.size}" if fixed?
+        lines << ""
+      end
+
+      lines << "✓ Document is valid and conforms to the #{@profile.name} profile." if valid? && !has_warnings?
+
+      lines.join("\n")
+    end
+  end
+end

data/lib/svg_conform/validator.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module SvgConform
+  # Main validator class for SVG conformance checking
+  class Validator
+    attr_reader :options
+
+    def initialize(options = {})
+      @options = {
+        fix: false,
+        strict: false,
+      }.merge(options)
+    end
+
+    # Validate an SVG file
+    def validate_file(file_path, profile: :svg_1_2_rfc, **options)
+      unless File.exist?(file_path)
+        raise ValidationError,
+              "File not found: #{file_path}"
+      end
+
+      document = Document.from_file(file_path)
+      validate_document(document, profile: profile, **options)
+    end
+
+    # Validate SVG content string
+    def validate(svg_content, profile: :svg_1_2_rfc, **options)
+      document = Document.from_content(svg_content)
+      validate_document(document, profile: profile, **options)
+    end
+
+    # Validate a Document object
+    def validate_document(document, profile: :svg_1_2_rfc, **options)
+      merged_options = @options.merge(options)
+      profile_obj = resolve_profile(profile)
+
+      # Perform validation
+      result = profile_obj.validate(document)
+
+      # Apply fixes if requested
+      result.apply_fixes if merged_options[:fix] && result.fixable?
+
+      result
+    end
+
+    # Validate multiple files
+    def validate_files(file_paths, profile: :svg_1_2_rfc, **options)
+      results = {}
+
+      file_paths.each do |file_path|
+        results[file_path] =
+          validate_file(file_path, profile: profile, **options)
+      rescue StandardError => e
+        results[file_path] = create_error_result(file_path, e)
+      end
+
+      results
+    end
+
+    # Get available profiles
+    def available_profiles
+      SvgConform::Profiles.available_profiles
+    end
+
+    private
+
+    def resolve_profile(profile)
+      case profile
+      when Symbol, String
+        SvgConform::Profiles.get(profile) || raise(ProfileError,
+                                                   "Unknown profile: #{profile}")
+      when Profile
+        profile
+      else
+        raise ProfileError, "Invalid profile type: #{profile.class}"
+      end
+    end
+
+    def create_error_result(file_path, error)
+      # Create a minimal error result for files that couldn't be processed
+      OpenStruct.new(
+        valid?: false,
+        errors: [error],
+        warnings: [],
+        file_path: file_path,
+        error?: true,
+        to_s: -> { "Error processing #{file_path}: #{error.message}" },
+      )
+    end
+  end
+end

data/lib/svg_conform/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SvgConform
+  VERSION = "0.1.0"
+end

data/lib/svg_conform.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+# Configure Lutaml::Model adapters
+Lutaml::Model::Config.configure do |config|
+  config.xml_adapter_type = :nokogiri
+  config.json_adapter_type = :standard_json
+  config.yaml_adapter_type = :standard_yaml
+end
+
+require_relative "svg_conform/version"
+require_relative "svg_conform/document"
+require_relative "svg_conform/validation_context"
+require_relative "svg_conform/validation_result"
+require_relative "svg_conform/profiles"
+require_relative "svg_conform/requirements"
+require_relative "svg_conform/remediations"
+require_relative "svg_conform/remediation_result"
+require_relative "svg_conform/external_checkers"
+require_relative "svg_conform/cli"
+
+module SvgConform
+  class Error < StandardError; end
+  class ParseError < Error; end
+  class ValidationError < Error; end
+  class ProfileError < Error; end
+  class RuleError < Error; end
+
+  # Autoload core classes
+  autoload :Validator, File.expand_path("svg_conform/validator", __dir__)
+  autoload :Fixer, "svg_conform/fixer"
+  autoload :RemediationEngine, "svg_conform/remediation_engine"
+  autoload :ConformanceReport,
+           File.expand_path("svg_conform/conformance_report", __dir__)
+  autoload :BatchReport,
+           File.expand_path("svg_conform/batch_report", __dir__)
+  autoload :ReportComparator,
+           File.expand_path("svg_conform/report_comparator", __dir__)
+  autoload :NamespaceRemediation, "svg_conform/namespace_remediation"
+  autoload :Cli, "svg_conform/cli"
+
+  # Autoload command classes
+  module Commands
+    autoload :Check, "svg_conform/commands/check"
+    autoload :Compare, "svg_conform/commands/compare"
+    autoload :Compatibility,
+             File.expand_path("svg_conform/commands/compatibility", __dir__)
+    autoload :GenerateReports,
+             File.expand_path("svg_conform/commands/generate_reports", __dir__)
+    autoload :Profiles, "svg_conform/commands/profiles"
+  end
+
+  # Convenience method to create a new validator
+  def self.validator
+    Validator.new
+  end
+
+  # Validate a file with the specified profile
+  def self.validate_file(file_path, profile: :svg_1_2_rfc, **options)
+    validator.validate_file(file_path, profile: profile, **options)
+  end
+
+  # Validate SVG content with the specified profile
+  def self.validate(svg_content, profile: :svg_1_2_rfc, **options)
+    validator.validate(svg_content, profile: profile, **options)
+  end
+end