svg_conform 0.1.0

data/lib/svg_conform/remediations/color_remediation.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require_relative "base_remediation"
+
+module SvgConform
+  module Remediations
+    # Remediation action for color-related issues that matches svgcheck behavior
+    class ColorRemediation < BaseRemediation
+      attribute :type, :string, default: -> { "ColorRemediation" }
+
+      DEFAULT_COLOR_THRESHOLD = 764 # Default threshold if not specified in requirement
+      COLOR_DEFAULT = "black"
+
+      COLOR_MAP = {
+        "rgb(0,0,0)" => "black",
+      }.freeze
+
+      def apply(document, context)
+        # Store the context for use in other methods
+        @context = context
+        @failed_requirements = context[:failed_requirements] if context.is_a?(Hash)
+
+        changes = []
+
+        # Find all elements with color attributes
+        document.traverse do |node|
+          next unless node.respond_to?(:name) && node.name
+
+          changes.concat(fix_color_attributes(node))
+          changes.concat(fix_style_colors(node))
+        end
+
+        changes
+      end
+
+      private
+
+      def fix_color_attributes(node)
+        changes = []
+        color_attributes = %w[fill stroke color stop-color flood-color
+                              lighting-color]
+
+        color_attributes.each do |attr_name|
+          value = get_attribute(node, attr_name)
+          next if value.nil? || value.empty?
+
+          new_color = convert_color_value(value)
+          next unless new_color != value
+
+          set_attribute(node, attr_name, new_color)
+          changes << log_change(
+            :attribute_modified,
+            "The attribute '#{attr_name}' does not allow the value '#{value}', replaced with '#{new_color}'",
+            node,
+          )
+        end
+
+        changes
+      end
+
+      def fix_style_colors(node)
+        changes = []
+        style_value = get_attribute(node, "style")
+        return changes unless style_value
+
+        styles = parse_style(style_value)
+        color_properties = %w[fill stroke color stop-color flood-color
+                              lighting-color]
+        style_changed = false
+
+        color_properties.each do |prop|
+          value = styles[prop]
+          next if value.nil? || value.empty?
+
+          new_color = convert_color_value(value)
+          if new_color != value
+            styles[prop] = new_color
+            style_changed = true
+          end
+        end
+
+        if style_changed
+          new_style = build_style(styles)
+          set_attribute(node, "style", new_style)
+          changes << log_change(
+            :attribute_modified,
+            "Updated style colors",
+            node,
+          )
+        end
+
+        changes
+      end
+
+      def convert_color_value(color_value)
+        v = color_value.strip
+
+        # Check if it's already a valid color according to profile
+        return color_value if valid_color?(v)
+
+        # Handle grey/gray conversion - check if they're allowed, otherwise convert to default
+        if %w[grey gray GREY GRAY].include?(v)
+          return v if valid_color?(v) # If grey is allowed in profile, keep it
+
+          return COLOR_DEFAULT # Otherwise convert to black to match svgcheck
+        end
+
+        # Check color map first
+        return COLOR_MAP[v] if COLOR_MAP.key?(v)
+
+        # Handle different color formats
+        if v.start_with?("rgb(") && v.end_with?(")")
+          convert_rgb_color(v)
+        elsif v.start_with?("#")
+          convert_hex_color(v)
+        else
+          # Unknown color, convert to default
+          COLOR_DEFAULT
+        end
+      end
+
+      def valid_color?(color)
+        # Get allowed colors from the color restrictions requirement in failed requirements
+        color_requirement = find_color_requirement
+        if color_requirement.respond_to?(:allowed_colors)
+          allowed_colors = color_requirement.allowed_colors
+          # Check for exact case-sensitive matches first
+          return true if allowed_colors.include?(color)
+
+          # Check for case-insensitive hex color matches
+          if color.match?(/^#[0-9a-fA-F]{6}$/)
+            hex_allowed = allowed_colors.select do |c|
+              c.match?(/^#[0-9a-fA-F]{6}$/)
+            end
+            return hex_allowed.any? do |allowed|
+              allowed.downcase == color.downcase
+            end
+          end
+
+          return false
+        end
+
+        # Fallback to default validation
+        %w[black white #ffffff #000000 none inherit
+           currentcolor].include?(color.downcase)
+      end
+
+      def find_color_requirement
+        return nil unless @failed_requirements
+
+        @failed_requirements.find do |failure|
+          requirement_id = failure.requirement_id || failure.rule&.id
+          requirement_id == "color_restrictions"
+        end&.rule
+      end
+
+      def convert_rgb_color(rgb_string)
+        # Extract RGB values from rgb(r,g,b) or rgb(r%,g%,b%)
+        match = rgb_string.match(/rgb\(([^)]+)\)/)
+        return COLOR_DEFAULT unless match
+
+        values = match[1].split(",").map(&:strip)
+        return COLOR_DEFAULT unless values.length == 3
+
+        shade = if values.first.include?("%")
+                  # Percentage values
+                  values.sum { |v| v.gsub("%", "").to_f * 255 / 100 }
+                else
+                  # Integer values
+                  values.sum(&:to_i)
+                end
+
+        shade > color_threshold ? "white" : COLOR_DEFAULT
+      end
+
+      def convert_hex_color(hex_string)
+        if hex_string.length == 7 # #rrggbb
+          r = hex_string[1..2].to_i(16)
+          g = hex_string[3..4].to_i(16)
+          b = hex_string[5..6].to_i(16)
+          shade = r + g + b
+        elsif hex_string.length == 4 # #rgb
+          r = hex_string[1].to_i(16) * 17 # Convert single digit to double
+          g = hex_string[2].to_i(16) * 17
+          b = hex_string[3].to_i(16) * 17
+          shade = r + g + b
+        else
+          return COLOR_DEFAULT
+        end
+
+        shade > color_threshold ? "white" : COLOR_DEFAULT
+      end
+
+      def color_threshold
+        # Get threshold from the color requirement configuration, fall back to default
+        color_requirement = find_color_requirement
+        if color_requirement.respond_to?(:black_and_white_threshold) && color_requirement.black_and_white_threshold
+          color_requirement.black_and_white_threshold
+        else
+          DEFAULT_COLOR_THRESHOLD
+        end
+      end
+
+      def parse_style(style_value)
+        return {} if style_value.nil? || style_value.empty?
+
+        styles = {}
+        style_value.split(";").each do |declaration|
+          next if declaration.strip.empty?
+
+          parts = declaration.split(":", 2)
+          next unless parts.size == 2
+
+          property = parts[0].strip
+          value = parts[1].strip
+          styles[property] = value unless property.empty? || value.empty?
+        end
+        styles
+      end
+
+      def build_style(styles)
+        styles.map { |prop, value| "#{prop}:#{value}" }.join(";")
+      end
+    end
+  end
+end

data/lib/svg_conform/remediations/font_embedding_remediation.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require_relative "base_remediation"
+
+module SvgConform
+  module Remediations
+    # Remediation for embedding external fonts
+    # NOTE: This is a placeholder - actual font embedding would require
+    # fetching external fonts and converting them to data URIs
+    class FontEmbeddingRemediation < BaseRemediation
+      attribute :type, :string, default: -> { "FontEmbeddingRemediation" }
+
+      yaml do
+        map "id", to: :id
+        map "description", to: :description
+        map "type", to: :type
+        map "targets", to: :targets
+      end
+
+      def apply(document, _context)
+        changes = []
+
+        # Find all style elements with @font-face rules
+        document.xpath("//style").each do |style_node|
+          content = style_node.text || ""
+          next unless content.include?("@font-face")
+
+          modified_content = embed_fonts_in_css(content, changes)
+          if modified_content != content
+            style_node.content = modified_content
+          end
+        end
+
+        # Find font-face elements with external references
+        document.xpath("//font-face-src/font-face-uri").each do |uri_node|
+          href = get_attribute(uri_node,
+                               "xlink:href") || get_attribute(uri_node, "href")
+          next unless href && !href.start_with?("data:", "#")
+
+          # Convert external font to data URI
+          embedded_uri = fetch_and_embed_font(href)
+          if embedded_uri
+            set_attribute(uri_node, "xlink:href", embedded_uri)
+            changes << {
+              type: "font_embedded",
+              element: "font-face-uri",
+              message: "Embedded external font: #{href}",
+            }
+          else
+            changes << {
+              type: "font_embedding_failed",
+              element: "font-face-uri",
+              message: "Failed to embed font: #{href}",
+            }
+          end
+        end
+
+        changes
+      end
+
+      def can_remediate?
+        true
+      end
+
+      private
+
+      def embed_fonts_in_css(css_content, changes)
+        # Match @font-face blocks and replace external URLs with data URIs
+        css_content.gsub(/@font-face\s*\{([^}]+)\}/m) do |_font_face_block|
+          font_face_content = ::Regexp.last_match(1)
+
+          # Find src: url(...) declarations
+          modified_content = font_face_content.gsub(/src\s*:\s*url\s*\(\s*['"]?([^'")\s]+)['"]?\s*\)/i) do |url_match|
+            url = ::Regexp.last_match(1)
+
+            # Skip if already embedded or internal reference
+            next url_match if url.start_with?("data:", "#")
+
+            # Fetch and embed the font
+            embedded_uri = fetch_and_embed_font(url)
+            if embedded_uri
+              changes << {
+                type: "font_embedded",
+                element: "style",
+                message: "Embedded external font: #{url}",
+              }
+              "src: url(#{embedded_uri})"
+            else
+              changes << {
+                type: "font_embedding_failed",
+                element: "style",
+                message: "Failed to embed font: #{url}",
+              }
+              url_match
+            end
+          end
+
+          "@font-face {#{modified_content}}"
+        end
+      end
+
+      def fetch_and_embed_font(url)
+        require "net/http"
+        require "uri"
+        require "base64"
+
+        # Parse URL
+        uri = URI.parse(url)
+
+        # Fetch the font
+        response = Net::HTTP.get_response(uri)
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        # Get content type or infer from URL
+        content_type = response["content-type"] || infer_font_mime_type(url)
+
+        # Encode as base64
+        base64_data = Base64.strict_encode64(response.body)
+
+        # Return data URI
+        "data:#{content_type};base64,#{base64_data}"
+      rescue StandardError => e
+        warn "Failed to fetch font #{url}: #{e.message}"
+        nil
+      end
+
+      def infer_font_mime_type(url)
+        case url.downcase
+        when /\.woff2$/
+          "font/woff2"
+        when /\.woff$/
+          "font/woff"
+        when /\.ttf$/
+          "font/ttf"
+        when /\.otf$/
+          "font/otf"
+        when /\.eot$/
+          "application/vnd.ms-fontobject"
+        else
+          "font/woff2" # Default to woff2
+        end
+      end
+    end
+  end
+end

data/lib/svg_conform/remediations/font_remediation.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require_relative "base_remediation"
+
+module SvgConform
+  module Remediations
+    # Remediation action for font-related issues that matches svgcheck behavior
+    class FontRemediation < BaseRemediation
+      attribute :type, :string, default: -> { "FontRemediation" }
+      attribute :default_family, :string, default: -> { "sans-serif" }
+      attribute :mapping, :hash, default: -> { {} }
+
+      def apply(document, _context)
+        changes = []
+        # Find all elements with font-family attributes
+        document.traverse do |node|
+          next unless node.respond_to?(:name) && node.name
+
+          changes.concat(fix_font_family_attribute(node, default_family,
+                                                   mapping))
+          changes.concat(fix_style_font_family(node, default_family, mapping))
+        end
+
+        changes
+      end
+
+      private
+
+      def fix_font_family_attribute(node, default_family, mapping)
+        changes = []
+        font_family = get_attribute(node, "font-family")
+        return changes unless font_family
+
+        new_family = convert_font_family(font_family, default_family, mapping)
+        if new_family != font_family
+          set_attribute(node, "font-family", new_family)
+          changes << log_change(
+            :attribute_modified,
+            "Changed font-family from '#{font_family}' to '#{new_family}'",
+            node,
+          )
+        end
+
+        changes
+      end
+
+      def fix_style_font_family(node, default_family, mapping)
+        changes = []
+        style_value = get_attribute(node, "style")
+        return changes unless style_value
+
+        styles = parse_style(style_value)
+        font_family_style = styles["font-family"]
+        return changes unless font_family_style
+
+        new_family = convert_font_family(font_family_style, default_family,
+                                         mapping)
+        if new_family != font_family_style
+          styles["font-family"] = new_family
+          new_style = build_style(styles)
+          set_attribute(node, "style", new_style)
+          changes << log_change(
+            :attribute_modified,
+            "Updated font-family in style from '#{font_family_style}' to '#{new_family}'",
+            node,
+          )
+        end
+
+        changes
+      end
+
+      def convert_font_family(font_family, default_family, mapping)
+        # Parse font family list (can be comma-separated)
+        families = font_family.split(",").map(&:strip)
+
+        # Check if any family is valid according to svgcheck's allowed values
+        valid_families = %w[serif sans-serif monospace inherit]
+
+        converted_families = families.map do |family|
+          # Remove quotes if present
+          clean_family = family.gsub(/['"]/, "").strip
+
+          # Check mapping first
+          mapped = mapping[clean_family]
+          return mapped if mapped
+
+          # Check if it's already a valid family according to svgcheck
+          if valid_families.include?(clean_family.downcase)
+            clean_family.downcase
+          else
+            # svgcheck replaces any invalid font family with 'sans-serif'
+            default_family
+          end
+        end
+
+        # Return the first converted family or default
+        converted_families.first || default_family
+      end
+
+      def parse_style(style_value)
+        return {} if style_value.nil? || style_value.empty?
+
+        styles = {}
+        style_value.split(";").each do |declaration|
+          next if declaration.strip.empty?
+
+          parts = declaration.split(":", 2)
+          next unless parts.size == 2
+
+          property = parts[0].strip
+          value = parts[1].strip
+          styles[property] = value unless property.empty? || value.empty?
+        end
+        styles
+      end
+
+      def build_style(styles)
+        styles.map { |prop, value| "#{prop}:#{value}" }.join(";")
+      end
+    end
+  end
+end

data/lib/svg_conform/remediations/image_embedding_remediation.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require_relative "base_remediation"
+
+module SvgConform
+  module Remediations
+    # Remediation for embedding external images
+    class ImageEmbeddingRemediation < BaseRemediation
+      attribute :type, :string, default: -> { "ImageEmbeddingRemediation" }
+
+      yaml do
+        map "id", to: :id
+        map "description", to: :description
+        map "type", to: :type
+        map "targets", to: :targets
+      end
+
+      def apply(document, _context)
+        changes = []
+
+        # Find all image elements with external references
+        document.xpath("//image").each do |image_node|
+          href = get_attribute(image_node,
+                               "href") || get_attribute(image_node,
+                                                        "xlink:href")
+          next unless href && !href.start_with?("data:", "#")
+
+          # Convert external image to data URI
+          embedded_uri = fetch_and_embed_image(href)
+          if embedded_uri
+            # Update both href variants for compatibility
+            set_attribute(image_node, "href", embedded_uri)
+            if get_attribute(
+              image_node, "xlink:href"
+            )
+              set_attribute(image_node, "xlink:href",
+                            embedded_uri)
+            end
+
+            changes << {
+              type: "image_embedded",
+              element: "image",
+              message: "Embedded external image: #{href}",
+            }
+          else
+            changes << {
+              type: "image_embedding_failed",
+              element: "image",
+              message: "Failed to embed image: #{href}",
+            }
+          end
+        end
+
+        # Find style attributes with background images
+        document.traverse do |node|
+          next unless element?(node)
+
+          style_value = get_attribute(node, "style")
+          next unless style_value&.include?("url(")
+
+          modified_style = embed_images_in_style(style_value, changes)
+          if modified_style != style_value
+            set_attribute(node, "style", modified_style)
+          end
+        end
+
+        changes
+      end
+
+      def can_remediate?
+        true
+      end
+
+      private
+
+      def embed_images_in_style(style_value, changes)
+        # SECURITY: Prevent ReDoS by limiting input length and using bounded quantifiers
+        # GitHub CodeQL: Regular expression with excessive backtracking
+        return style_value if style_value.length > 10_000
+
+        # Replace url() references with data URIs
+        # Use bounded quantifier {1,2000} to prevent exponential backtracking
+        style_value.gsub(/url\s*\(\s*['"]?([^'")\s]{1,2000})['"]?\s*\)/i) do |url_match|
+          url = ::Regexp.last_match(1)
+
+          # Skip if already embedded or internal reference
+          next url_match if url.start_with?("data:", "#")
+
+          # Fetch and embed the image
+          embedded_uri = fetch_and_embed_image(url)
+          if embedded_uri
+            changes << {
+              type: "image_embedded",
+              element: "style",
+              message: "Embedded external image: #{url}",
+            }
+            "url(#{embedded_uri})"
+          else
+            changes << {
+              type: "image_embedding_failed",
+              element: "style",
+              message: "Failed to embed image: #{url}",
+            }
+            url_match
+          end
+        end
+      end
+
+      def fetch_and_embed_image(url)
+        require "net/http"
+        require "uri"
+        require "base64"
+
+        # Parse URL
+        uri = URI.parse(url)
+
+        # Fetch the image
+        response = Net::HTTP.get_response(uri)
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        # Get content type or infer from URL
+        content_type = response["content-type"] || infer_image_mime_type(url)
+
+        # Encode as base64
+        base64_data = Base64.strict_encode64(response.body)
+
+        # Return data URI
+        "data:#{content_type};base64,#{base64_data}"
+      rescue StandardError => e
+        warn "Failed to fetch image #{url}: #{e.message}"
+        nil
+      end
+
+      def infer_image_mime_type(url)
+        case url.downcase
+        when /\.png$/
+          "image/png"
+        when /\.jpe?g$/
+          "image/jpeg"
+        when /\.gif$/
+          "image/gif"
+        when /\.svg$/
+          "image/svg+xml"
+        when /\.webp$/
+          "image/webp"
+        when /\.bmp$/
+          "image/bmp"
+        else
+          "image/png" # Default to PNG
+        end
+      end
+    end
+  end
+end