svg_conform 0.1.0

data/lib/svg_conform/requirements/no_external_fonts_requirement.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_relative "base_requirement"
+
+module SvgConform
+  module Requirements
+    # Validates that no external font references are present
+    # All fonts must be embedded in the SVG
+    class NoExternalFontsRequirement < BaseRequirement
+      attribute :type, :string, default: -> { "NoExternalFontsRequirement" }
+      attribute :check_font_face, :boolean, default: true
+      attribute :check_style_fonts, :boolean, default: true
+
+      yaml do
+        map "id", to: :id
+        map "description", to: :description
+        map "type", to: :type
+        map "check_font_face", to: :check_font_face
+        map "check_style_fonts", to: :check_style_fonts
+      end
+
+      def check(node, context)
+        return unless element?(node)
+
+        case node.name
+        when "style"
+          check_style_element(node, context) if check_style_fonts
+        when "font-face"
+          check_font_face_element(node, context) if check_font_face
+        else
+          check_style_attribute(node, context) if check_style_fonts
+        end
+      end
+
+      def should_check_node?(node, context = nil)
+        return false unless element?(node)
+        return false if context&.node_structurally_invalid?(node)
+
+        node.name == "style" ||
+          node.name == "font-face" ||
+          has_style_attribute?(node)
+      end
+
+      private
+
+      def check_style_element(node, context)
+        # Check for @font-face with external src in style elements
+        content = node.text || ""
+
+        # Match @font-face blocks
+        content.scan(/@font-face\s*\{([^}]+)\}/m) do |match|
+          font_face_content = match[0]
+
+          # Check for src with url() that is not data: URI
+          if font_face_content =~ /src\s*:\s*url\s*\(\s*['"]?([^'")\s]+)['"]?\s*\)/i
+            url = ::Regexp.last_match(1)
+            unless embedded_font?(url)
+              context.add_error(
+                requirement_id: id,
+                message: "External font reference not allowed: #{url}. Fonts must be embedded as data URIs.",
+                node: node,
+                severity: :error,
+              )
+            end
+          end
+        end
+      end
+
+      def check_font_face_element(node, context)
+        # Check font-face-src and font-face-uri elements
+        node.xpath(".//font-face-src/font-face-uri").each do |uri_node|
+          href = get_attribute(uri_node,
+                               "xlink:href") || get_attribute(uri_node, "href")
+          if href && !embedded_font?(href)
+            context.add_error(
+              requirement_id: id,
+              message: "External font reference in font-face-uri not allowed: #{href}. Fonts must be embedded as data URIs.",
+              node: uri_node,
+              severity: :error,
+            )
+          end
+        end
+      end
+
+      def check_style_attribute(node, context)
+        style_value = get_attribute(node, "style")
+        return unless style_value
+
+        # Check for font-family with url() references
+        return unless style_value =~ /font-family\s*:\s*.*url\s*\(\s*['"]?([^'")\s]+)['"]?\s*\)/i
+
+        url = ::Regexp.last_match(1)
+        return if embedded_font?(url)
+
+        context.add_error(
+          requirement_id: id,
+          message: "External font URL in style attribute not allowed: #{url}. Fonts must be embedded as data URIs.",
+          node: node,
+          severity: :error,
+        )
+      end
+
+      def has_style_attribute?(node)
+        !get_attribute(node, "style").nil?
+      end
+
+      def embedded_font?(url)
+        return true if url.nil? || url.empty?
+
+        # Data URLs are embedded
+        return true if url.start_with?("data:")
+
+        # Fragment identifiers (internal references) are allowed
+        return true if url.start_with?("#")
+
+        # Everything else is external
+        false
+      end
+    end
+  end
+end

data/lib/svg_conform/requirements/no_external_images_requirement.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative "base_requirement"
+
+module SvgConform
+  module Requirements
+    # Validates that no external image references are present
+    # All images must be embedded in the SVG
+    class NoExternalImagesRequirement < BaseRequirement
+      attribute :type, :string, default: -> { "NoExternalImagesRequirement" }
+      attribute :check_image_elements, :boolean, default: true
+      attribute :check_style_images, :boolean, default: true
+
+      yaml do
+        map "id", to: :id
+        map "description", to: :description
+        map "type", to: :type
+        map "check_image_elements", to: :check_image_elements
+        map "check_style_images", to: :check_style_images
+      end
+
+      def check(node, context)
+        return unless element?(node)
+
+        case node.name
+        when "image"
+          check_image_element(node, context) if check_image_elements
+        else
+          check_style_attribute(node, context) if check_style_images
+        end
+      end
+
+      def should_check_node?(node, context = nil)
+        return false unless element?(node)
+        return false if context&.node_structurally_invalid?(node)
+
+        node.name == "image" || has_style_attribute?(node)
+      end
+
+      private
+
+      def check_image_element(node, context)
+        # Check href and xlink:href attributes
+        href = get_attribute(node, "href") || get_attribute(node, "xlink:href")
+        return unless href && !embedded_image?(href)
+
+        context.add_error(
+          requirement_id: id,
+          message: "External image reference not allowed: #{href}. Images must be embedded as data URIs.",
+          node: node,
+          severity: :error,
+        )
+      end
+
+      def check_style_attribute(node, context)
+        style_value = get_attribute(node, "style")
+        return unless style_value
+
+        # Check for url() references to images in background, background-image, etc.
+        style_value.scan(/url\s*\(\s*['"]?([^'")\s]+)['"]?\s*\)/i) do
+          url = ::Regexp.last_match(1)
+          next if embedded_image?(url)
+
+          context.add_error(
+            requirement_id: id,
+            message: "External image URL in style attribute not allowed: #{url}. Images must be embedded as data URIs.",
+            node: node,
+            severity: :error,
+          )
+        end
+      end
+
+      def has_style_attribute?(node)
+        !get_attribute(node, "style").nil?
+      end
+
+      def embedded_image?(url)
+        return true if url.nil? || url.empty?
+
+        # Data URLs are embedded
+        return true if url.start_with?("data:")
+
+        # Fragment identifiers (internal references) are allowed
+        return true if url.start_with?("#")
+
+        # Everything else is external
+        false
+      end
+    end
+  end
+end

data/lib/svg_conform/requirements/style_promotion_requirement.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module SvgConform
+  module Requirements
+    # Detects CSS style properties that should be promoted to attributes
+    class StylePromotionRequirement < BaseRequirement
+      # 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 validate_document(document, context)
+        document.xpath("//*[@style]").each do |element|
+          style_attr = element["style"]
+          next if style_attr.nil? || style_attr.strip.empty?
+
+          validate_style_properties(element, style_attr, context)
+        end
+      end
+
+      private
+
+      def validate_style_properties(element, style_attr, context)
+        # Parse CSS style declarations
+        style_declarations = parse_style_declarations(style_attr)
+
+        style_declarations.each do |property, value|
+          next unless PROMOTABLE_PROPERTIES.include?(property)
+
+          # Report each promotable property as an issue
+          context.add_error(
+            requirement_id: id,
+            message: "Style property '#{property}' can be promoted to attribute",
+            node: element,
+            severity: :info,
+            data: {
+              attribute: "style",
+              property: property,
+              value: value,
+              element: element.name,
+              suggestion: "Move '#{property}:#{value}' from style to #{property} attribute",
+            },
+          )
+        end
+      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
+    end
+  end
+end

data/lib/svg_conform/requirements/style_requirement.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require_relative "base_requirement"
+
+module SvgConform
+  module Requirements
+    # Unified style requirement that handles all style validation:
+    # - Style syntax validation
+    # - Allowed style properties (whitelist/blacklist)
+    # - Property value validation
+    class StyleRequirement < BaseRequirement
+      attribute :type, :string, default: -> { "StyleRequirement" }
+      attribute :allowed_properties, :string, collection: true, default: -> {
+        []
+      }
+      attribute :disallowed_properties, :string, collection: true, default: -> {
+        []
+      }
+      attribute :property_values, :hash, default: -> { {} }
+      attribute :property_types, :hash, default: -> { {} }
+
+      yaml do
+        map "id", to: :id
+        map "description", to: :description
+        map "type", to: :type
+        map "allowed_properties", to: :allowed_properties
+        map "disallowed_properties", to: :disallowed_properties
+        map "property_values", to: :property_values
+        map "property_types", to: :property_types
+      end
+
+      def check(node, context)
+        return unless element?(node)
+
+        style_value = get_attribute(node, "style")
+        return unless style_value
+        return if style_value.strip.empty?
+
+        # 1. Check for malformed style syntax
+        check_malformed_syntax(style_value, node, context)
+
+        # 2. Check for allowed/disallowed properties and validate their values
+        check_style_properties(style_value, node, context)
+      end
+
+      private
+
+      def check_malformed_syntax(style_value, node, context)
+        # Check for malformed fields like ['malformed']
+        if /\[['"][^'"]*['"]\]/.match?(style_value)
+          context.add_error(
+            requirement_id: id,
+            message: "Malformed field '#{style_value.match(/\[['"][^'"]*['"]\]/)[0]}' in style attribute found. Field removed.",
+            node: node,
+            severity: :error,
+            data: { attribute: "style", value: style_value },
+          )
+        end
+
+        # Check for other malformed syntax patterns
+        # Invalid property declarations without colons
+        style_value.split(";").each do |declaration|
+          declaration = declaration.strip
+          next if declaration.empty?
+
+          next if declaration.include?(":")
+
+          context.add_error(
+            requirement_id: id,
+            message: "Malformed style declaration '#{declaration}' found. Declaration removed.",
+            node: node,
+            severity: :error,
+            data: { attribute: "style", declaration: declaration },
+          )
+        end
+      end
+
+      def check_style_properties(style_value, node, context)
+        style_value.split(";").each do |declaration|
+          declaration = declaration.strip
+          next if declaration.empty?
+
+          next unless declaration.include?(":")
+
+          property, value = declaration.split(":", 2).map(&:strip)
+          property = property.downcase
+
+          # Check if property is allowed
+          if property_invalid?(property)
+            context.add_error(
+              requirement_id: id,
+              message: "Style property '#{property}' removed",
+              node: node,
+              severity: :error,
+              data: { attribute: "style", property: property },
+            )
+            next
+          end
+
+          # Skip value validation for color properties - handled by ColorRestrictionsRequirement
+          color_properties = %w[fill stroke color stop-color flood-color
+                                lighting-color]
+          next if color_properties.include?(property)
+
+          # Skip value validation for font-family - handled by FontFamilyRequirement
+          next if property == "font-family"
+
+          # Check if property value is valid
+          next unless property_value_invalid?(property, value)
+
+          context.add_error(
+            requirement_id: id,
+            message: "Invalid value '#{value}' for style property '#{property}'",
+            node: node,
+            severity: :error,
+            data: { attribute: "style", property: property, value: value },
+          )
+        end
+      end
+
+      def property_invalid?(property)
+        # If allowed_properties is specified (whitelist approach), use that
+        if allowed_properties && !allowed_properties.empty?
+          allowed_props = allowed_properties
+          allowed_props = [allowed_props] if allowed_props.is_a?(String)
+          return !allowed_props.include?(property)
+        end
+
+        # Otherwise, use disallowed_properties (blacklist approach)
+        if disallowed_properties && !disallowed_properties.empty?
+          disallowed_props = disallowed_properties
+          disallowed_props = [disallowed_props] if disallowed_props.is_a?(String)
+          return disallowed_props.include?(property)
+        end
+
+        # If neither is specified, allow all properties
+        false
+      end
+
+      def property_value_invalid?(property, value)
+        # First check explicit allowed values
+        if property_values && property_values[property]
+          allowed_values = property_values[property]
+          unless allowed_values.nil? || allowed_values.empty?
+            # Convert to array if it's a single value
+            allowed_values = [allowed_values] if allowed_values.is_a?(String)
+
+            # Separate literal values from type references (those starting with '<')
+            literal_values = allowed_values.reject { |v| v.start_with?("<") }
+            type_references = allowed_values.select { |v| v.start_with?("<") }
+
+            # Check literal values first (case-insensitive)
+            return false if literal_values.map(&:downcase).include?(value.downcase)
+
+            # If there are type references, validate against those types
+            if type_references.any?
+              type_references.each do |type_ref|
+                return false if validate_property_type(value, type_ref)
+              end
+              # Value didn't match any type reference
+            else
+              # No type references, and didn't match literals
+            end
+            return true
+          end
+        end
+
+        # Then check type-based validation
+        if property_types && property_types[property]
+          property_type = property_types[property]
+          return !validate_property_type(value, property_type)
+        end
+
+        # If no validation rules are specified, allow the value
+        false
+      end
+
+      # Validate a property value against its type (from word_properties.py)
+      def validate_property_type(value, type)
+        case type
+        when "<color>"
+          validate_color_value(value)
+        when "<paint>"
+          validate_paint_value(value)
+        when "<number>"
+          validate_number_value(value)
+        when "<integer>"
+          validate_integer_value(value)
+        else
+          # Unknown type, allow it
+          true
+        end
+      end
+
+      # Validate color values (from basic_types['<color>'] in word_properties.py)
+      def validate_color_value(value)
+        allowed_colors = ["black", "#ffffff", "#FFFFFF", "white", "#000000",
+                          "currentColor", "inherit"]
+        # Case-insensitive comparison for all values
+        allowed_colors_lower = allowed_colors.map(&:downcase)
+        allowed_colors_lower.include?(value.downcase) || allowed_colors.include?(value)
+      end
+
+      # Validate paint values (from basic_types['<paint>'] in word_properties.py)
+      def validate_paint_value(value)
+        # <paint> includes 'none', 'currentColor', 'inherit', and <color> values
+        return true if %w[none currentColor inherit].include?(value.downcase)
+
+        # Also check if it's a valid color
+        validate_color_value(value)
+      end
+
+      # Validate number values (basic numeric validation)
+      def validate_number_value(value)
+        # Allow numbers with optional units, decimals, percentages
+        value.match?(/^[+-]?(\d+\.?\d*|\.\d+)(%|px|em|ex|pt|pc|cm|mm|in)?$/i)
+      end
+
+      # Validate integer values
+      def validate_integer_value(value)
+        # Allow positive/negative integers
+        value.match?(/^[+-]?\d+$/)
+      end
+    end
+  end
+end

data/lib/svg_conform/requirements/viewbox_required_requirement.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative "base_requirement"
+
+module SvgConform
+  module Requirements
+    # Validates that SVG documents have proper viewBox attributes
+    class ViewboxRequiredRequirement < BaseRequirement
+      attribute :type, :string, default: -> { "ViewboxRequiredRequirement" }
+
+      yaml do
+        map "id", to: :id
+        map "description", to: :description
+        map "type", to: :type
+      end
+
+      def validate_document(document, context)
+        root = document.root
+        return unless root&.name == "svg"
+
+        viewbox = get_attribute(root, "viewBox")
+
+        if viewbox.nil? || viewbox.empty?
+          context.add_error(
+            requirement: self,
+            node: root,
+            message: "SVG root element must have a viewBox attribute",
+            data: { missing_attribute: "viewBox" },
+          )
+
+          # Add informational message about calculated viewBox if width/height are present
+          width = get_attribute(root, "width")
+          height = get_attribute(root, "height")
+
+          if width && height && valid_number?(width) && valid_number?(height)
+            calculated_viewbox = "0 0 #{width.to_f} #{height.to_f}"
+            context.add_error(
+              requirement: self,
+              node: root,
+              message: "Trying to put in the attribute with value '#{calculated_viewbox}'",
+              data: {
+                calculated_viewbox: calculated_viewbox,
+                source_width: width,
+                source_height: height,
+              },
+            )
+          end
+          return
+        end
+
+        # Validate viewBox format (should be "min-x min-y width height")
+        # Also accept comma-separated with parentheses like "(0, 0, 100, 100)" (svgcheck is lenient)
+        normalized_viewbox = viewbox.strip.gsub(/[(),]/, " ").squeeze(" ")
+        parts = normalized_viewbox.strip.split(/\s+/)
+        unless parts.length == 4 && parts.all? { |part| valid_number?(part) }
+          context.add_error(
+            requirement: self,
+            node: root,
+            message: "viewBox attribute must contain four numeric values (min-x min-y width height)",
+            data: {
+              viewbox_value: viewbox,
+              parsed_parts: parts,
+            },
+          )
+          return
+        end
+
+        # Check that width and height are positive
+        width = parts[2].to_f
+        height = parts[3].to_f
+
+        return unless width <= 0 || height <= 0
+
+        context.add_error(
+          requirement: self,
+          node: root,
+          message: "viewBox width and height must be positive values",
+          data: {
+            viewbox_value: viewbox,
+            width: width,
+            height: height,
+          },
+        )
+      end
+
+      private
+
+      def valid_number?(str)
+        Float(str)
+        true
+      rescue ArgumentError
+        false
+      end
+    end
+  end
+end

data/lib/svg_conform/requirements.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "requirements/base_requirement"
+require_relative "requirements/allowed_elements_requirement"
+require_relative "requirements/color_restrictions_requirement"
+require_relative "requirements/font_family_requirement"
+require_relative "requirements/invalid_id_references_requirement"
+require_relative "requirements/namespace_requirement"
+require_relative "requirements/no_external_css_requirement"
+require_relative "requirements/no_external_fonts_requirement"
+require_relative "requirements/no_external_images_requirement"
+require_relative "requirements/viewbox_required_requirement"
+require_relative "requirements/namespace_attributes_requirement"
+require_relative "requirements/forbidden_content_requirement"
+require_relative "requirements/style_requirement"
+require_relative "requirements/style_promotion_requirement"
+require_relative "requirements/link_validation_requirement"
+require_relative "requirements/id_reference_requirement"
+
+module SvgConform
+  module Requirements
+    # Auto-load all requirement classes
+    def self.all
+      [
+        AllowedElementsRequirement,
+        ColorRestrictionsRequirement,
+        FontFamilyRequirement,
+        InvalidIdReferencesRequirement,
+        NamespaceRequirement,
+        NoExternalCssRequirement,
+        NoExternalFontsRequirement,
+        NoExternalImagesRequirement,
+        ViewboxRequiredRequirement,
+        NamespaceAttributesRequirement,
+        ForbiddenContentRequirement,
+        StyleRequirement,
+        LinkValidationRequirement,
+        IdReferenceRequirement,
+      ]
+    end
+
+    # Find a requirement class by name
+    def self.find(class_name)
+      const_get(class_name)
+    rescue NameError
+      nil
+    end
+  end
+end