svg_conform 0.1.0

data/lib/svg_conform/remediations/no_external_css_remediation.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require_relative "base_remediation"
+
+module SvgConform
+  module Remediations
+    # Remediation action to remove external CSS references
+    class NoExternalCssRemediation < BaseRemediation
+      attribute :type, :string, default: -> { "NoExternalCssRemediation" }
+      attribute :strategy, :string, default: "remove_external_references"
+      attribute :preserve_inline_styles, :boolean, default: true
+      attribute :log_removed_elements, :boolean, default: true
+
+      def apply(document, context)
+        changes = []
+
+        case @strategy
+        when "remove_external_references"
+          changes += remove_external_link_elements(document, context)
+          changes += remove_external_imports_from_style_elements(document,
+                                                                 context)
+          changes += remove_external_urls_from_style_attributes(document,
+                                                                context)
+        else
+          context.add_error(
+            message: "Unknown remediation strategy: #{@strategy}",
+            node: document.root,
+          )
+          return []
+        end
+
+        if @log_removed_elements && changes.any?
+          log_remediation(context,
+                          "Removed #{changes.length} external CSS references")
+        end
+
+        changes
+      end
+
+      private
+
+      def remove_external_link_elements(document, context)
+        changes = []
+
+        document.traverse do |node|
+          next unless element?(node) && node.name == "link"
+
+          rel = get_attribute(node, "rel")
+          href = get_attribute(node, "href")
+
+          if rel&.downcase == "stylesheet" && href && !allowed_url?(href)
+            if @log_removed_elements
+              log_removal(context,
+                          "Removing external CSS link: #{href}")
+            end
+            node.remove
+            changes << {
+              type: :element_removed,
+              description: "Removed external CSS link: #{href}",
+              node_name: node.name,
+              href: href,
+            }
+          end
+        end
+
+        changes
+      end
+
+      def remove_external_imports_from_style_elements(document, context)
+        changes = []
+
+        document.traverse do |node|
+          next unless element?(node) && node.name == "style"
+
+          content = node.text || ""
+          original_content = content.dup
+
+          # Remove @import url() statements
+          content.gsub!(/@import\s+url\s*\(\s*['"]?([^'")\s]+)['"]?\s*\)\s*;?/i) do |match|
+            url = ::Regexp.last_match(1)
+            if allowed_url?(url)
+              match # Keep allowed URLs
+            else
+              if @log_removed_elements
+                log_removal(context,
+                            "Removing external CSS import: #{url}")
+              end
+              changes << {
+                type: :content_modified,
+                description: "Removed external CSS import: #{url}",
+                node_name: node.name,
+                url: url,
+              }
+              "" # Remove disallowed URLs
+            end
+          end
+
+          # Remove @import "url" statements
+          content.gsub!(/@import\s+['"]([^'"]+)['"]\s*;?/i) do |match|
+            url = ::Regexp.last_match(1)
+            if allowed_url?(url)
+              match # Keep allowed URLs
+            else
+              if @log_removed_elements
+                log_removal(context,
+                            "Removing external CSS import: #{url}")
+              end
+              changes << {
+                type: :content_modified,
+                description: "Removed external CSS import: #{url}",
+                node_name: node.name,
+                url: url,
+              }
+              "" # Remove disallowed URLs
+            end
+          end
+
+          # Update the node content if it changed
+          if content != original_content
+            # Clear existing text content and set new content
+            node.text = content
+          end
+        end
+
+        changes
+      end
+
+      def remove_external_urls_from_style_attributes(document, context)
+        changes = []
+
+        document.traverse do |node|
+          next unless element?(node)
+
+          style_value = get_attribute(node, "style")
+          next unless style_value
+
+          original_style = style_value.dup
+
+          # Remove url() references in style attributes
+          style_value.gsub!(/url\s*\(\s*['"]?([^'")\s]+)['"]?\s*\)/i) do |match|
+            url = ::Regexp.last_match(1)
+            if allowed_url?(url)
+              match # Keep allowed URLs
+            else
+              if @log_removed_elements
+                log_removal(context,
+                            "Removing external URL from style attribute: #{url}")
+              end
+              changes << {
+                type: :attribute_modified,
+                description: "Removed external URL from style attribute: #{url}",
+                node_name: node.name,
+                attribute_name: "style",
+                url: url,
+              }
+              "" # Remove disallowed URLs
+            end
+          end
+
+          # Update the attribute if it changed
+          if style_value != original_style
+            set_attribute(node, "style",
+                          style_value)
+          end
+        end
+
+        changes
+      end
+
+      def allowed_url?(url)
+        return true if url.nil? || url.empty?
+
+        # Data URLs are typically allowed
+        return true if url.start_with?("data:")
+
+        # Fragment identifiers (internal references) are allowed
+        return true if url.start_with?("#")
+
+        # For remediation, we're more restrictive - only allow data: and fragment URLs
+        false
+      end
+
+      def log_removal(context, message)
+        context.add_info(message: message) if context.respond_to?(:add_info)
+      end
+
+      def log_remediation(context, message)
+        context.add_info(message: message) if context.respond_to?(:add_info)
+      end
+    end
+  end
+end

data/lib/svg_conform/remediations/style_promotion_remediation.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative "base_remediation"
+
+module SvgConform
+  module Remediations
+    # Promotes CSS style properties to individual attributes
+    class StylePromotionRemediation < BaseRemediation
+      # CSS properties that can be promoted to SVG attributes
+      PROMOTABLE_PROPERTIES = %w[
+        fill stroke stroke-width stroke-opacity stroke-linecap stroke-linejoin
+        fill-opacity fill-rule text-anchor font-family font-size font-weight
+        font-style opacity visibility display
+      ].freeze
+
+      def apply(document, _context)
+        results = []
+
+        document.xpath("//*[@style]").each do |element|
+          style_attr = element["style"]
+          next if style_attr.nil? || style_attr.strip.empty?
+
+          promoted_properties = promote_style_properties(element, style_attr)
+          promoted_properties.each do |property, value|
+            results << create_promotion_result(element, property, value)
+          end
+        end
+
+        results
+      end
+
+      private
+
+      def promote_style_properties(element, style_attr)
+        promoted = {}
+        remaining_styles = []
+
+        # Parse CSS style declarations
+        style_declarations = parse_style_declarations(style_attr)
+
+        style_declarations.each do |property, value|
+          if PROMOTABLE_PROPERTIES.include?(property)
+            # Promote to attribute
+            element[property] = value
+            promoted[property] = value
+          else
+            # Keep in style attribute
+            remaining_styles << "#{property}:#{value}"
+          end
+        end
+
+        # Update or remove style attribute
+        if remaining_styles.empty?
+          element.remove_attribute("style")
+        else
+          element["style"] = remaining_styles.join(";")
+        end
+
+        promoted
+      end
+
+      def parse_style_declarations(style_attr)
+        declarations = {}
+
+        # Split by semicolon and parse each declaration
+        style_attr.split(";").each do |declaration|
+          next if declaration.strip.empty?
+
+          parts = declaration.split(":", 2)
+          next unless parts.length == 2
+
+          property = parts[0].strip
+          value = parts[1].strip
+
+          # Remove any trailing semicolon from value
+          value = value.chomp(";")
+
+          declarations[property] = value
+        end
+
+        declarations
+      end
+
+      def create_promotion_result(element, property, _value)
+        log_change(
+          :style_promotion,
+          "Style property '#{property}' promoted to attribute",
+          element,
+        )
+      end
+    end
+  end
+end

data/lib/svg_conform/remediations/viewbox_remediation.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require_relative "base_remediation"
+
+module SvgConform
+  module Remediations
+    # Remediation action for viewBox-related issues that matches svgcheck behavior
+    class ViewboxRemediation < BaseRemediation
+      attribute :type, :string, default: -> { "ViewboxRemediation" }
+
+      def apply(document, _context)
+        changes = []
+
+        # Get the root SVG element directly from the document
+        svg_element = document.root
+
+        if svg_element
+          # Check if viewBox is missing or malformed
+          current_viewbox = get_attribute(svg_element, "viewBox")
+
+          if current_viewbox.nil? || current_viewbox.empty?
+            changes.concat(add_viewbox_from_dimensions(svg_element))
+          elsif current_viewbox =~ /[()]/ || current_viewbox !~ /^[\d.\s-]+$/
+            # Malformed viewBox - try to fix it
+            changes.concat(fix_malformed_viewbox(svg_element, current_viewbox))
+          end
+        end
+
+        changes
+      end
+
+      private
+
+      def add_viewbox_from_dimensions(svg_element)
+        changes = []
+
+        # Try to get width and height attributes (matching svgcheck logic)
+        width = get_attribute(svg_element, "width")
+        height = get_attribute(svg_element, "height")
+
+        if width && height
+          # Extract numeric values (svgcheck uses maybefloat function)
+          width_num = extract_float(width)
+          height_num = extract_float(height)
+
+          if width_num && height_num
+            # Create viewBox value: "0 0 width height" (matching svgcheck format)
+            # Format numbers to avoid unnecessary decimal places
+            width_formatted = width_num == width_num.to_i ? width_num.to_i.to_s : width_num.to_s
+            height_formatted = height_num == height_num.to_i ? height_num.to_i.to_s : height_num.to_s
+            viewbox_value = "0 0 #{width_formatted} #{height_formatted}"
+            set_attribute(svg_element, "viewBox", viewbox_value)
+
+            changes << log_change(
+              :attribute_added,
+              "The attribute viewBox is required on the root svg element",
+              svg_element,
+            )
+            changes << log_change(
+              :attribute_added,
+              "Trying to put in the attribute with value '#{viewbox_value}'",
+              svg_element,
+            )
+          end
+        end
+
+        changes
+      end
+
+      def extract_float(value)
+        return nil unless value
+
+        # Try to convert to float (matching svgcheck's maybefloat function)
+        begin
+          Float(value)
+        rescue ArgumentError, TypeError
+          nil
+        end
+      end
+
+      def fix_malformed_viewbox(svg_element, malformed_value)
+        changes = []
+
+        # Remove parentheses and extra characters, extract numbers
+        cleaned_value = malformed_value.gsub(/[()]/, "").strip
+
+        # Split by spaces or commas and extract numeric values
+        numbers = cleaned_value.split(/[\s,]+/).map do |part|
+          part.gsub(/[^\d.-]/, "") # Remove non-numeric characters except . and -
+        end.compact.reject(&:empty?)
+
+        # Try to convert to valid numbers
+        valid_numbers = numbers.map do |num_str|
+          Float(num_str)
+        rescue ArgumentError
+          nil
+        end.compact
+
+        # If we have 4 valid numbers, create proper viewBox
+        if valid_numbers.length == 4
+          proper_viewbox = valid_numbers.join(" ")
+          set_attribute(svg_element, "viewBox", proper_viewbox)
+
+          changes << log_change(
+            :attribute_modified,
+            "Fixed malformed viewBox attribute from '#{malformed_value}' to '#{proper_viewbox}'",
+            svg_element,
+          )
+        elsif valid_numbers.length >= 2
+          # If we have at least width and height, use them
+          width = valid_numbers[2] || valid_numbers[0]
+          height = valid_numbers[3] || valid_numbers[1]
+          proper_viewbox = "0 0 #{width} #{height}"
+          set_attribute(svg_element, "viewBox", proper_viewbox)
+
+          changes << log_change(
+            :attribute_modified,
+            "Fixed malformed viewBox attribute from '#{malformed_value}' to '#{proper_viewbox}'",
+            svg_element,
+          )
+        end
+
+        changes
+      end
+    end
+  end
+end

data/lib/svg_conform/remediations.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "remediations/base_remediation"
+require_relative "remediations/color_remediation"
+require_relative "remediations/font_embedding_remediation"
+require_relative "remediations/font_remediation"
+require_relative "remediations/image_embedding_remediation"
+require_relative "remediations/invalid_id_references_remediation"
+require_relative "remediations/namespace_attribute_remediation"
+require_relative "remediations/namespace_remediation"
+require_relative "remediations/no_external_css_remediation"
+require_relative "remediations/style_promotion_remediation"
+require_relative "remediations/viewbox_remediation"
+
+module SvgConform
+  module Remediations
+    # Auto-load all remediation classes
+    def self.all
+      [
+        ColorRemediation,
+        FontEmbeddingRemediation,
+        FontRemediation,
+        ImageEmbeddingRemediation,
+        InvalidIdReferencesRemediation,
+        NamespaceAttributeRemediation,
+        NamespaceRemediation,
+        NoExternalCSSRemediation,
+        StylePromotionRemediation,
+        ViewboxRemediation,
+      ]
+    end
+
+    # Find a remediation class by name
+    def self.find(class_name)
+      const_get(class_name)
+    rescue NameError
+      nil
+    end
+  end
+end