svg_conform 0.1.0

data/lib/svg_conform/constants.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module SvgConform
+  module Constants
+    # SVG elements allowed in SVG 1.2 RFC (based on RFC 7996 and svgcheck)
+    SVG_ELEMENTS = {
+      "svg" => %w[version baseProfile width viewBox preserveAspectRatio snapshotTime
+                  height id role break color-rendering fill-rule],
+      "desc" => %w[id role shape-rendering text-rendering buffered-rendering
+                   visibility],
+      "title" => %w[id role shape-rendering text-rendering buffered-rendering
+                    visibility],
+      "path" => %w[d pathLength stroke-miterlimit id role fill style
+                   transform font-size fill-rule],
+      "rect" => %w[x y width height rx ry stroke-miterlimit
+                   id role fill style transform fill-rule],
+      "circle" => %w[cx cy r id role fill style transform fill-rule],
+      "line" => %w[x1 y1 x2 y2 id role fill transform fill-rule],
+      "ellipse" => %w[cx cy rx ry id role fill style transform fill-rule],
+      "polyline" => %w[points id role fill transform fill-rule],
+      "polygon" => %w[points id role fill style transform fill-rule],
+      "solidColor" => %w[id role fill fill-rule],
+      "textArea" => %w[x y width height auto id role fill transform fill-rule],
+      "text" => %w[x y rotate id role fill style transform font-size fill-rule],
+      "g" => %w[label class id role fill style transform fill-rule visibility],
+      "defs" => %w[id role fill fill-rule],
+      "use" => %w[x y href id role fill transform fill-rule],
+      "a" => %w[id role fill transform fill-rule target],
+      "tspan" => %w[x y id role fill fill-rule],
+      "tbreak" => %w[id role],
+    }.freeze
+
+    # SVG properties with their allowed values
+    SVG_PROPERTIES = {
+      "about" => [],
+      "base" => [],
+      "baseProfile" => [],
+      "d" => [],
+      "break" => [],
+      "class" => [],
+      "content" => [],
+      "cx" => ["<number>"],
+      "cy" => ["<number>"],
+      "datatype" => [],
+      "height" => ["<number>"],
+      "href" => [],
+      "id" => [],
+      "label" => [],
+      "lang" => [],
+      "pathLength" => [],
+      "points" => [],
+      "preserveAspectRatio" => [],
+      "property" => [],
+      "r" => ["<number>"],
+      "rel" => [],
+      "resource" => [],
+      "rev" => [],
+      "role" => [],
+      "rotate" => [],
+      "rx" => ["<number>"],
+      "ry" => ["<number>"],
+      "space" => [],
+      "snapshotTime" => [],
+      "transform" => [],
+      "typeof" => [],
+      "version" => [],
+      "width" => ["<number>"],
+      "viewBox" => ["<number>"],
+      "x" => ["<number>"],
+      "x1" => ["<number>"],
+      "x2" => ["<number>"],
+      "y" => ["<number>"],
+      "y1" => ["<number>"],
+      "y2" => ["<number>"],
+
+      "stroke" => ["none", "<paint>"],
+      "stroke-width" => [],
+      "stroke-linecap" => %w[butt round square inherit],
+      "stroke-linejoin" => %w[miter round bevel inherit],
+      "stroke-miterlimit" => [],
+      "stroke-dasharray" => [],
+      "stroke-dashoffset" => [],
+      "stroke-opacity" => [],
+      "vector-effect" => %w[non-scaling-stroke none inherit],
+      "viewport-fill" => ["none", "currentColor", "inherit", "<color>"],
+
+      "display" => %w[inline block list-item run-in compact table inline-table
+                      table-row-group table-header-group table-footer-group
+                      table-row table-column-group table-column table-cell
+                      table-caption none inherit],
+      "viewport-fill-opacity" => [],
+      "visibility" => %w[visible hidden collapse inherit],
+      "image-rendering" => %w[auto optimizeSpeed optimizeQuality inherit],
+      "color-rendering" => %w[auto optimizeSpeed optimizeQuality inherit],
+      "shape-rendering" => %w[auto optimizeSpeed crispEdges geometricPrecision
+                              inherit],
+      "text-rendering" => %w[auto optimizeSpeed optimizeLegibility
+                             geometricPrecision inherit],
+      "buffered-rendering" => %w[auto dynamic static inherit],
+
+      "solid-opacity" => [],
+      "solid-color" => ["currentColor", "inherit", "<color>"],
+      "color" => ["currentColor", "inherit", "<color>"],
+
+      "stop-color" => ["currentColor", "inherit", "<color>"],
+      "stop-opacity" => [],
+
+      "line-increment" => [],
+      "text-align" => %w[start end center inherit],
+      "display-align" => %w[auto before center after inherit],
+
+      "font-size" => [],
+      "font-family" => %w[serif sans-serif monospace inherit],
+      "font-weight" => %w[normal bold bolder lighter inherit 100 200 300 400
+                          500 600 700 800 900],
+      "font-style" => %w[normal italic oblique inherit],
+      "font-variant" => %w[normal small-caps inherit],
+      "direction" => %w[ltr rtl inherit],
+      "unicode-bidi" => %w[normal embed bidi-override inherit],
+      "text-anchor" => %w[start middle end inherit],
+      "fill" => ["none", "inherit", "<color>"],
+      "fill-rule" => %w[nonzero evenodd inherit],
+      "fill-opacity" => [],
+
+      "requiredFeatures" => [],
+      "requiredFormats" => [],
+      "requiredExtensions" => [],
+      "requiredFonts" => [],
+      "systemLanguage" => [],
+    }.freeze
+
+    # Basic types for validation
+    BASIC_TYPES = {
+      "<color>" => %w[black #ffffff #FFFFFF white #000000],
+      "<paint>" => ["none", "currentColor", "inherit", "<color>"],
+      "<integer>" => ["+"],
+      "<number>" => ["+"],
+    }.freeze
+
+    # Default color for replacements
+    COLOR_DEFAULT = "black"
+
+    # Color threshold for grayscale conversion (from Python code)
+    COLOR_THRESHOLD = 764
+
+    # Style properties that can be promoted to attributes
+    STYLE_PROPERTIES = %w[
+      font-family font-weight font-style font-variant direction unicode-bidi
+      text-anchor fill fill-rule stroke stroke-width font-size fill-opacity
+      stroke-linecap stroke-opacity stroke-linejoin
+    ].freeze
+
+    # Elements allowed within other elements
+    SVG_CHILD_ELEMENTS = %w[
+      title path rect circle line ellipse polyline polygon solidColor
+      textArea text g defs use a tspan desc
+    ].freeze
+
+    TEXT_CHILD_ELEMENTS = %w[desc title tspan text a].freeze
+
+    ELEMENT_CHILDREN = {
+      "svg" => SVG_CHILD_ELEMENTS,
+      "desc" => ["text"],
+      "title" => ["text"],
+      "path" => %w[title desc],
+      "rect" => %w[title desc],
+      "circle" => %w[title desc],
+      "line" => %w[title desc],
+      "ellipse" => %w[title desc],
+      "polyline" => %w[title desc],
+      "polygon" => %w[title desc],
+      "solidColor" => %w[title desc],
+      "textArea" => TEXT_CHILD_ELEMENTS,
+      "text" => TEXT_CHILD_ELEMENTS,
+      "g" => SVG_CHILD_ELEMENTS,
+      "defs" => SVG_CHILD_ELEMENTS,
+      "use" => %w[title desc],
+      "a" => SVG_CHILD_ELEMENTS,
+      "tspan" => TEXT_CHILD_ELEMENTS + ["tbreak"],
+    }.freeze
+
+    # Allowed SVG namespaces
+    SVG_NAMESPACES = [
+      "http://www.w3.org/2000/svg",
+    ].freeze
+
+    # Allowed XML namespaces
+    XMLNS_NAMESPACES = [
+      "http://www.w3.org/2000/svg",
+      "http://www.w3.org/1999/xlink",
+      "http://www.w3.org/XML/1998/namespace",
+    ].freeze
+
+    # Color mapping for common color names to RFC-compliant colors
+    COLOR_MAP = {
+      "rgb(0,0,0)" => "black",
+    }.freeze
+  end
+end

data/lib/svg_conform/css_color.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+
+module SvgConform
+  # Handles CSS color equivalence, normalization, and conversion
+  class CssColor
+    # Named colors mapping to their hex equivalents
+    NAMED_COLORS = {
+      "black" => "#000000",
+      "white" => "#ffffff",
+      "red" => "#ff0000",
+      "green" => "#008000",
+      "blue" => "#0000ff",
+      "yellow" => "#ffff00",
+      "cyan" => "#00ffff",
+      "magenta" => "#ff00ff",
+      "silver" => "#c0c0c0",
+      "gray" => "#808080",
+      "grey" => "#808080",
+      "maroon" => "#800000",
+      "olive" => "#808000",
+      "lime" => "#00ff00",
+      "aqua" => "#00ffff",
+      "teal" => "#008080",
+      "navy" => "#000080",
+      "fuchsia" => "#ff00ff",
+      "purple" => "#800080",
+    }.freeze
+
+    # Reverse mapping for canonical named color lookup
+    HEX_TO_NAMED = NAMED_COLORS.invert.freeze
+
+    # CSS color keywords that have special meaning
+    SPECIAL_KEYWORDS = %w[inherit currentcolor transparent none].freeze
+
+    class << self
+      # Normalize a color to its canonical hex representation
+      def normalize(color)
+        return nil if color.nil? || color.empty?
+
+        color = color.strip.downcase
+
+        # Handle special keywords
+        return color if SPECIAL_KEYWORDS.include?(color)
+
+        # Handle named colors
+        return NAMED_COLORS[color] if NAMED_COLORS.key?(color)
+
+        # Handle hex colors
+        if color.match?(/^#[0-9a-f]{3}$/)
+          # Expand short hex: #fff → #ffffff
+          return expand_short_hex(color)
+        elsif color.match?(/^#[0-9a-f]{6}$/)
+          # Already normalized 6-digit hex
+          return color
+        end
+
+        # Handle RGB functions with integers
+        rgb_match = color.match(/^rgb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$/)
+        if rgb_match
+          r, g, b = rgb_match[1..3].map(&:to_i)
+          return rgb_to_hex(r, g, b)
+        end
+
+        # Handle RGB functions with percentages
+        rgb_percent_match = color.match(/^rgb\s*\(\s*(\d+(?:\.\d+)?)%\s*,\s*(\d+(?:\.\d+)?)%\s*,\s*(\d+(?:\.\d+)?)%\s*\)$/)
+        if rgb_percent_match
+          r = (rgb_percent_match[1].to_f * 255 / 100).round
+          g = (rgb_percent_match[2].to_f * 255 / 100).round
+          b = (rgb_percent_match[3].to_f * 255 / 100).round
+          return rgb_to_hex(r, g, b)
+        end
+
+        # Handle mixed RGB functions (percentage and absolute values)
+        rgb_mixed_match = color.match(/^rgb\s*\(\s*(\d+(?:\.\d+)?%?)\s*,\s*(\d+(?:\.\d+)?%?)\s*,\s*(\d+(?:\.\d+)?%?)\s*\)$/)
+        if rgb_mixed_match
+          r = parse_rgb_value(rgb_mixed_match[1])
+          g = parse_rgb_value(rgb_mixed_match[2])
+          b = parse_rgb_value(rgb_mixed_match[3])
+          return rgb_to_hex(r, g, b)
+        end
+
+        # Handle RGBA functions (ignore alpha for SVG purposes)
+        rgba_match = color.match(/^rgba\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*[\d.]+\s*\)$/)
+        if rgba_match
+          r, g, b = rgba_match[1..3].map(&:to_i)
+          return rgb_to_hex(r, g, b)
+        end
+
+        # Return original if unrecognized format
+        color
+      end
+
+      # Check if two colors are equivalent
+      def equivalent?(color1, color2)
+        return false if color1.nil? || color2.nil?
+        return true if color1 == color2
+
+        norm1 = normalize(color1)
+        norm2 = normalize(color2)
+
+        return false if norm1.nil? || norm2.nil?
+
+        norm1 == norm2
+      end
+
+      # Convert color to its canonical form (prefer named colors when available)
+      def to_canonical(color)
+        normalized = normalize(color)
+        return color if normalized.nil?
+
+        # Return special keywords as-is
+        return normalized if SPECIAL_KEYWORDS.include?(normalized)
+
+        # Convert hex to named color if available
+        named = HEX_TO_NAMED[normalized]
+        return named if named
+
+        # Return normalized hex
+        normalized
+      end
+
+      # Expand short hex colors: #fff → #ffffff
+      def expand_short_hex(hex)
+        return hex unless hex.match?(/^#[0-9a-f]{3}$/)
+
+        chars = hex[1..3].chars
+        "##{chars.map { |c| c * 2 }.join}"
+      end
+
+      # Convert RGB values to hex
+      def rgb_to_hex(red, green, blue)
+        # Clamp values to 0-255 range
+        r = [[red.to_i, 0].max, 255].min
+        g = [[green.to_i, 0].max, 255].min
+        b = [[blue.to_i, 0].max, 255].min
+
+        format("#%02x%02x%02x", r, g, b)
+      end
+
+      # Check if a color is valid according to SVG specifications
+      def valid_css_color?(color)
+        return false if color.nil? || color.empty?
+
+        normalized = normalize(color)
+        return false if normalized.nil?
+
+        # Valid if it normalizes to something we recognize
+        SPECIAL_KEYWORDS.include?(normalized) ||
+          NAMED_COLORS.key?(color.strip.downcase) ||
+          normalized.match?(/^#[0-9a-f]{6}$/)
+      end
+
+      # Get all equivalent forms of a color
+      def equivalent_forms(color)
+        normalized = normalize(color)
+        return [color] if normalized.nil?
+
+        forms = [normalized]
+
+        # Add named form if available
+        named = HEX_TO_NAMED[normalized]
+        forms << named if named
+
+        # Add short hex form if applicable
+        if normalized.match?(/^#([0-9a-f])\1([0-9a-f])\2([0-9a-f])\3$/)
+          short_hex = "##{$1}#{$2}#{$3}"
+          forms << short_hex
+        end
+
+        # Add uppercase variants for hex
+        if normalized.match?(/^#[0-9a-f]{6}$/)
+          forms << normalized.upcase
+        end
+
+        forms.uniq
+      end
+
+      # Check if a color is in a list of allowed colors (with equivalence)
+      def allowed_in_list?(color, allowed_colors)
+        return false if color.nil? || allowed_colors.nil? || allowed_colors.empty?
+
+        normalized = normalize(color)
+        return false if normalized.nil?
+
+        allowed_colors.any? { |allowed| equivalent?(color, allowed) }
+      end
+
+      # Calculate RGB sum for threshold-based validation
+      def rgb_sum(color)
+        return nil if color.nil? || color.empty?
+
+        color = color.strip.downcase
+
+        # Handle hex colors
+        if color.match?(/^#[0-9a-f]{3}$/)
+          # Expand short hex and calculate
+          expanded = expand_short_hex(color)
+          r = expanded[1..2].to_i(16)
+          g = expanded[3..4].to_i(16)
+          b = expanded[5..6].to_i(16)
+          return r + g + b
+        elsif color.match?(/^#[0-9a-f]{6}$/)
+          r = color[1..2].to_i(16)
+          g = color[3..4].to_i(16)
+          b = color[5..6].to_i(16)
+          return r + g + b
+        end
+
+        # Handle RGB functions with integers
+        rgb_match = color.match(/^rgb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$/)
+        if rgb_match
+          r, g, b = rgb_match[1..3].map(&:to_i)
+          return r + g + b
+        end
+
+        # Handle RGB functions with percentages
+        rgb_percent_match = color.match(/^rgb\s*\(\s*(\d+(?:\.\d+)?)%\s*,\s*(\d+(?:\.\d+)?)%\s*,\s*(\d+(?:\.\d+)?)%\s*\)$/)
+        if rgb_percent_match
+          r = (rgb_percent_match[1].to_f * 255 / 100).round
+          g = (rgb_percent_match[2].to_f * 255 / 100).round
+          b = (rgb_percent_match[3].to_f * 255 / 100).round
+          return r + g + b
+        end
+
+        # Handle mixed RGB functions
+        rgb_mixed_match = color.match(/^rgb\s*\(\s*(\d+(?:\.\d+)?%?)\s*,\s*(\d+(?:\.\d+)?%?)\s*,\s*(\d+(?:\.\d+)?%?)\s*\)$/)
+        if rgb_mixed_match
+          r = parse_rgb_value(rgb_mixed_match[1])
+          g = parse_rgb_value(rgb_mixed_match[2])
+          b = parse_rgb_value(rgb_mixed_match[3])
+          return r + g + b
+        end
+
+        # Handle named colors
+        if NAMED_COLORS.key?(color)
+          hex = NAMED_COLORS[color]
+          r = hex[1..2].to_i(16)
+          g = hex[3..4].to_i(16)
+          b = hex[5..6].to_i(16)
+          return r + g + b
+        end
+
+        nil
+      end
+
+      private
+
+      # Parse individual RGB value (percentage or absolute)
+      def parse_rgb_value(value_str)
+        value_str = value_str.strip
+        if value_str.end_with?("%")
+          # Percentage value
+          percent = value_str.chomp("%").to_f
+          (percent * 255 / 100).round
+        else
+          # Absolute value
+          value_str.to_i
+        end
+      end
+    end
+  end
+end

data/lib/svg_conform/document.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require "moxml"
+
+module SvgConform
+  # Wrapper around Moxml document for SVG validation
+  class Document
+    attr_reader :file_path, :moxml_document
+
+    def initialize(content_or_path)
+      if File.exist?(content_or_path.to_s)
+        @file_path = content_or_path
+        @content = File.read(@file_path)
+      else
+        @file_path = nil
+        @content = content_or_path
+      end
+
+      parse_document
+    end
+
+    def self.from_file(file_path)
+      new(file_path)
+    end
+
+    def self.from_content(content)
+      new(content)
+    end
+
+    def root
+      @moxml_document.root
+    end
+
+    def elements
+      @moxml_document.elements
+    end
+
+    def xpath(path, namespaces = {})
+      @moxml_document.xpath(path, namespaces)
+    end
+
+    def traverse(&)
+      traverse_node(root, &) if root
+    end
+
+    def svg_elements
+      # Handle both default namespace and prefixed namespace
+      if has_svg_namespace_prefix?
+        xpath("//svg:*", { "svg" => "http://www.w3.org/2000/svg" }).select { |node| node.respond_to?(:name) }
+      else
+        xpath("//*[namespace-uri()='http://www.w3.org/2000/svg']").select { |node| node.respond_to?(:name) }
+      end
+    end
+
+    def to_xml
+      @moxml_document.to_xml
+    end
+
+    def dup
+      Document.from_content(to_xml)
+    end
+
+    def valid_xml?
+      !@moxml_document.nil?
+    rescue StandardError
+      false
+    end
+
+    def namespace_uri
+      root&.namespace&.uri
+    end
+
+    def svg_namespace?
+      namespace_uri == "http://www.w3.org/2000/svg"
+    end
+
+    def has_svg_namespace_prefix?
+      @content.include?("xmlns:svg=") || @content.include?("svg:")
+    end
+
+    def has_viewbox?
+      root&.attribute("viewBox")
+    end
+
+    def viewbox
+      root&.attribute("viewBox")&.value
+    end
+
+    def width
+      root&.attribute("width")&.value
+    end
+
+    def height
+      root&.attribute("height")&.value
+    end
+
+    def version
+      root&.attribute("version")&.value
+    end
+
+    # Find all elements with a specific name
+    def find_elements(name)
+      if has_svg_namespace_prefix?
+        xpath("//svg:#{name}", { "svg" => "http://www.w3.org/2000/svg" })
+      else
+        xpath("//#{name}[namespace-uri()='http://www.w3.org/2000/svg']")
+      end
+    end
+
+    # Find all elements with style attributes
+    def elements_with_style
+      xpath("//*[@style]")
+    end
+
+    # Find all elements with specific attributes
+    def elements_with_attribute(attr_name)
+      xpath("//*[@#{attr_name}]")
+    end
+
+    # Get all unique element names in the document
+    def element_names
+      svg_elements.map(&:name).uniq.sort
+    end
+
+    # Get all unique attribute names in the document
+    def attribute_names
+      attributes = []
+      traverse do |node|
+        attributes.concat(node.attributes.keys) if node.respond_to?(:attributes)
+      end
+      attributes.uniq.sort
+    end
+
+    # Check if document contains external references
+    def has_external_references?
+      # Check for external stylesheets
+      link_elements = if has_svg_namespace_prefix?
+                        xpath('//svg:link[@rel="stylesheet"]',
+                              { "svg" => "http://www.w3.org/2000/svg" })
+                      else
+                        xpath('//link[@rel="stylesheet"][namespace-uri()="http://www.w3.org/2000/svg"]')
+                      end
+      return true if link_elements.any?
+
+      # Check for @import in style elements
+      style_elements = if has_svg_namespace_prefix?
+                         xpath("//svg:style",
+                               { "svg" => "http://www.w3.org/2000/svg" })
+                       else
+                         xpath("//style[namespace-uri()='http://www.w3.org/2000/svg']")
+                       end
+
+      style_elements.each do |style|
+        content = style.text
+        return true if content&.include?("@import")
+      end
+
+      # Check for external references in style attributes
+      elements_with_style.each do |element|
+        style_value = element.attribute("style")&.value
+        return true if style_value&.include?("url(")
+      end
+
+      false
+    end
+
+    private
+
+    def parse_document
+      begin
+        # Create a Moxml context and parse the document
+        context = Moxml.new
+        @moxml_document = context.parse(@content)
+      rescue StandardError => e
+        raise ParseError, "Failed to parse SVG document: #{e.message}"
+      end
+
+      raise ParseError, "Document could not be parsed" unless @moxml_document
+
+      raise ParseError, "Document has no root element" unless root
+
+      # Check if root element is SVG (handle both namespaced and non-namespaced)
+      root_name = root.name
+      root_namespace = root.namespace&.uri
+
+      # Accept if element name is "svg" regardless of namespace
+      # or if it's in the SVG namespace
+      return if root_name == "svg" || root_namespace == "http://www.w3.org/2000/svg"
+
+      raise ParseError, "Root element must be 'svg', found '#{root_name}'"
+    end
+
+    def traverse_node(node, &block)
+      yield node if block
+
+      return unless node.respond_to?(:children)
+
+      node.children.each do |child|
+        traverse_node(child, &block)
+      end
+    end
+  end
+end