svg_conform 0.1.0

data/lib/svg_conform/requirements/font_family_requirement.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require_relative "base_requirement"
+
+module SvgConform
+  module Requirements
+    # Validates font family restrictions
+    class FontFamilyRequirement < BaseRequirement
+      attribute :type, :string, default: -> { "FontFamilyRequirement" }
+      attribute :allowed_families, :string, collection: true, default: -> {
+        %w[serif sans-serif monospace]
+      }
+      attribute :svgcheck_compatibility, :boolean, default: -> { false }
+      attribute :enable_fallback, :boolean, default: -> { false }
+      attribute :default_fallback, :string, default: -> { "sans-serif" }
+
+      yaml do
+        map "id", to: :id
+        map "description", to: :description
+        map "type", to: :type
+        map "allowed_families", to: :allowed_families
+        map "svgcheck_compatibility", to: :svgcheck_compatibility
+        map "enable_fallback", to: :enable_fallback
+        map "default_fallback", to: :default_fallback
+      end
+
+      def check(node, context)
+        return unless element?(node)
+
+        # Check font-family attribute only (not style properties)
+        # Style properties are handled by StylePromotionRequirement to avoid duplication
+        font_family = get_attribute(node, "font-family")
+        return unless font_family
+
+        if svgcheck_compatibility
+          check_font_family_svgcheck_mode(node, context, font_family,
+                                          "font-family")
+        elsif !valid_font_family?(font_family)
+          context.add_error(
+            requirement_id: id,
+            message: "Font family '#{font_family}' is not allowed in this profile",
+            node: node,
+            severity: :error,
+            data: { attribute: "font-family", value: font_family },
+          )
+        end
+      end
+
+      private
+
+      def check_font_family_svgcheck_mode(node, context, font_family_value,
+attribute_name)
+        # Check if the font family value is valid according to svgcheck
+        return if valid_font_family_svgcheck?(font_family_value)
+
+        # Generate error message matching svgcheck's exact format
+        context.add_error(
+          requirement_id: id,
+          message: "The attribute '#{attribute_name}' does not allow the value '#{font_family_value}', replaced with '#{default_fallback}'",
+          node: node,
+          severity: :error,
+          data: {
+            attribute: attribute_name,
+            original_value: font_family_value,
+            replacement_value: default_fallback,
+          },
+        )
+      end
+
+      def extract_valid_fonts(font_family_value)
+        # Parse font family list (comma-separated)
+        families = font_family_value.split(",").map(&:strip)
+
+        valid_fonts = []
+        families.each do |family|
+          # Remove quotes if present
+          clean_family = family.gsub(/['"]/, "").strip.downcase
+          valid_fonts << clean_family if allowed_families.include?(clean_family)
+        end
+
+        valid_fonts
+      end
+
+      def valid_font_family_svgcheck?(font_family)
+        # svgcheck allows: serif, sans-serif, monospace, inherit
+        # Any other value is considered invalid and gets replaced with sans-serif
+        svgcheck_allowed = %w[serif sans-serif monospace inherit]
+
+        # Parse font family list (can be comma-separated)
+        families = font_family.split(",").map(&:strip)
+
+        # Check if any family in the list is valid
+        families.any? do |family|
+          # Remove quotes if present
+          clean_family = family.gsub(/['"]/, "").strip.downcase
+          svgcheck_allowed.include?(clean_family)
+        end
+      end
+
+      def valid_font_family?(font_family)
+        # Parse font family list (can be comma-separated)
+        families = font_family.split(",").map(&:strip)
+
+        # All families must be allowed (matching svgcheck behavior)
+        families.all? do |family|
+          # Remove quotes if present
+          clean_family = family.gsub(/['"]/, "").strip.downcase
+          allowed_families.include?(clean_family)
+        end
+      end
+
+      def parse_style(style_string)
+        return {} if style_string.nil? || style_string.empty?
+
+        properties = {}
+        declarations = style_string.split(";").map(&:strip)
+
+        declarations.each do |declaration|
+          next if declaration.empty?
+
+          parts = declaration.split(":", 2)
+          next unless parts.length == 2
+
+          property = parts[0].strip
+          value = parts[1].strip
+          properties[property] = value
+        end
+
+        properties
+      end
+    end
+  end
+end

data/lib/svg_conform/requirements/forbidden_content_requirement.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "base_requirement"
+
+module SvgConform
+  module Requirements
+    class ForbiddenContentRequirement < BaseRequirement
+      attribute :forbidden_elements, :string, collection: true, default: -> {
+        []
+      }
+      attribute :forbidden_attributes, :string, collection: true, default: -> {
+        []
+      }
+
+      yaml do
+        map "id", to: :id
+        map "description", to: :description
+        map "type", to: :type
+        map "forbidden_elements", to: :forbidden_elements
+        map "forbidden_attributes", to: :forbidden_attributes
+      end
+
+      def validate_document(document, context)
+        document.traverse do |node|
+          check(node, context) if should_check_node?(node)
+        end
+      end
+
+      def check(node, context)
+        return unless element?(node)
+
+        # Check if this is a forbidden element
+        if forbidden_elements.include?(node.name)
+          context.add_error(
+            requirement_id: id,
+            message: "Forbidden element '#{node.name}' is not allowed",
+            node: node,
+            severity: :error,
+          )
+        end
+
+        # Check for forbidden attributes
+        if node.respond_to?(:attributes) && node.attributes
+          node.attributes.each do |attr|
+            attr_name = attr.respond_to?(:name) ? attr.name : attr.to_s
+
+            if forbidden_attributes.include?(attr_name)
+              context.add_error(
+                requirement_id: id,
+                message: "Forbidden attribute '#{attr_name}' is not allowed",
+                node: node,
+                severity: :error,
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/svg_conform/requirements/id_reference_requirement.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require_relative "base_requirement"
+require "set"
+
+module SvgConform
+  module Requirements
+    class IdReferenceRequirement < BaseRequirement
+      def validate_document(document, context)
+        # Collect all IDs in the document
+        ids = Set.new
+        document.xpath("//*[@id]").each do |element|
+          id_value = element["id"]
+          ids.add(id_value) if id_value && !id_value.empty?
+        end
+
+        # Check references to IDs
+        check_url_references(document, ids, context)
+        check_href_references(document, ids, context)
+        check_other_references(document, ids, context)
+      end
+
+      private
+
+      def check_url_references(document, ids, context)
+        # Check url() references in style attributes and CSS properties
+        url_attributes = %w[fill stroke marker-start marker-mid marker-end
+                            clip-path mask filter]
+
+        url_attributes.each do |attr_name|
+          document.xpath("//*[@#{attr_name}]").each do |element|
+            attr_value = element[attr_name]
+            next unless attr_value
+
+            url_refs = extract_url_references(attr_value)
+            url_refs.each do |ref_id|
+              next if ids.include?(ref_id)
+
+              context.add_error(
+                node: element,
+                message: "Reference to undefined ID '#{ref_id}' in attribute '#{attr_name}'",
+                requirement_id: id,
+              )
+            end
+          end
+        end
+
+        # Check style attributes
+        document.xpath("//*[@style]").each do |element|
+          style_attr = element["style"]
+          next unless style_attr
+
+          url_refs = extract_url_references(style_attr)
+          url_refs.each do |ref_id|
+            next if ids.include?(ref_id)
+
+            context.add_error(
+              node: element,
+              message: "Reference to undefined ID '#{ref_id}' in style attribute",
+              requirement_id: id,
+            )
+          end
+        end
+      end
+
+      def check_href_references(document, ids, context)
+        # Check href and xlink:href references
+        document.xpath("//*[@href or @*[local-name()='href']]").each do |element|
+          href_value = element["href"]
+
+          # Check for xlink:href if regular href is not present
+          if href_value.nil?
+            href_value = element.attributes.find do |attr|
+              attr.name == "href" && attr.namespace&.uri == "http://www.w3.org/1999/xlink"
+            end&.value
+          end
+
+          next unless href_value
+
+          # Only check fragment identifiers (starting with #)
+          next unless href_value.start_with?("#")
+
+          ref_id = href_value[1..] # Remove the #
+          next if ids.include?(ref_id)
+
+          context.add_error(
+            node: element,
+            message: "Reference to undefined ID '#{ref_id}' in href attribute",
+            requirement_id: id,
+          )
+        end
+      end
+
+      def check_other_references(document, ids, context)
+        # Check other attributes that reference IDs
+        id_ref_attributes = %w[for aria-labelledby aria-describedby
+                               aria-controls aria-owns]
+
+        id_ref_attributes.each do |attr_name|
+          document.xpath("//*[@#{attr_name}]").each do |element|
+            attr_value = element[attr_name]
+            next unless attr_value
+
+            # These attributes can contain space-separated lists of IDs
+            ref_ids = attr_value.split(/\s+/)
+            ref_ids.each do |ref_id|
+              next if ref_id.empty?
+
+              next if ids.include?(ref_id)
+
+              context.add_error(
+                node: element,
+                message: "Reference to undefined ID '#{ref_id}' in #{attr_name} attribute",
+                requirement_id: id,
+              )
+            end
+          end
+        end
+      end
+
+      def extract_url_references(value)
+        refs = []
+
+        # Match url(#id) patterns
+        value.scan(/url\(#([^)]+)\)/) do |match|
+          refs << match[0]
+        end
+
+        refs
+      end
+    end
+  end
+end

data/lib/svg_conform/requirements/invalid_id_references_requirement.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require_relative "base_requirement"
+
+module SvgConform
+  module Requirements
+    # Requirement to validate that ID references point to existing elements
+    # Based on the Lucid SVG fix script that removes use elements with invalid IDREF
+    class InvalidIdReferencesRequirement < BaseRequirement
+      attribute :type, :string, default: -> { "InvalidIdReferencesRequirement" }
+      attribute :check_use_elements, :boolean, default: true
+      attribute :check_other_references, :boolean, default: false
+      attribute :strict_mode, :boolean, default: false
+
+      yaml do
+        map "id", to: :id
+        map "description", to: :description
+        map "type", to: :type
+        map "check_use_elements", to: :check_use_elements
+        map "check_other_references", to: :check_other_references
+        map "strict_mode", to: :strict_mode
+      end
+
+      def validate_document(document, context)
+        # Collect all existing IDs in the document
+        existing_ids = collect_existing_ids(document)
+        context.set_data(:existing_ids, existing_ids)
+
+        # Check for invalid references
+        super(document, context)
+      end
+
+      def check(node, context)
+        return unless element?(node)
+
+        if check_use_elements && node.name == "use"
+          check_use_element(node,
+                            context)
+        end
+
+        return unless check_other_references
+
+        check_other_id_references(node, context)
+      end
+
+      private
+
+      def collect_existing_ids(document)
+        ids = Set.new
+        document.traverse do |node|
+          next unless element?(node)
+
+          id_attr = get_attribute(node, "id")
+          ids.add(id_attr) if id_attr && !id_attr.empty?
+        end
+        ids
+      end
+
+      def check_use_element(node, context)
+        href = get_attribute(node, "xlink:href") || get_attribute(node, "href")
+        return unless href&.start_with?("#")
+
+        id_ref = href[1..] # Remove # prefix
+        return if id_ref.empty?
+
+        existing_ids = context.get_data(:existing_ids)
+        return if existing_ids.include?(id_ref)
+
+        context.add_error(
+          requirement: self,
+          node: node,
+          message: "use element references non-existent ID: #{id_ref}",
+          data: { invalid_id: id_ref, href: href },
+        )
+      end
+
+      def check_other_id_references(node, context)
+        # Check other attributes that reference IDs
+        id_reference_attributes = %w[
+          clip-path mask filter marker-start marker-mid marker-end
+          fill stroke
+        ]
+
+        existing_ids = context.get_data(:existing_ids)
+
+        id_reference_attributes.each do |attr_name|
+          attr_value = get_attribute(node, attr_name)
+          next unless attr_value
+
+          # Extract ID from url(#id) format
+          next unless attr_value =~ /^url\(#(.+)\)$/
+
+          id_ref = Regexp.last_match(1)
+          next if existing_ids.include?(id_ref)
+
+          context.add_error(
+            requirement: self,
+            node: node,
+            message: "#{attr_name} references non-existent ID: #{id_ref}",
+            data: { invalid_id: id_ref, attribute: attr_name,
+                    value: attr_value },
+          )
+        end
+
+        # Check style attribute for ID references
+        check_style_id_references(node, context, existing_ids)
+      end
+
+      def check_style_id_references(node, context, existing_ids)
+        style_value = get_attribute(node, "style")
+        return unless style_value
+
+        styles = parse_style(style_value)
+
+        styles.each do |property, value|
+          next unless value =~ /^url\(#(.+)\)$/
+
+          id_ref = Regexp.last_match(1)
+          next if existing_ids.include?(id_ref)
+
+          context.add_error(
+            requirement: self,
+            node: node,
+            message: "style property #{property} references non-existent ID: #{id_ref}",
+            data: { invalid_id: id_ref, style_property: property,
+                    value: value },
+          )
+        end
+      end
+    end
+  end
+end

data/lib/svg_conform/requirements/link_validation_requirement.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "base_requirement"
+
+module SvgConform
+  module Requirements
+    class LinkValidationRequirement < BaseRequirement
+      def check(node, context)
+        return unless element?(node)
+
+        # Check href attributes (both href and xlink:href)
+        href_value = get_attribute(node, "href")
+
+        # Check for xlink:href if regular href is not present
+        if href_value.nil? && node.respond_to?(:attributes)
+          xlink_href = node.attributes.find do |attr|
+            attr.name == "href" && attr.namespace&.uri == "http://www.w3.org/1999/xlink"
+          end
+          href_value = xlink_href&.value
+        end
+
+        if href_value && !ascii_only?(href_value)
+          context.add_error(
+            requirement_id: id,
+            message: "Link href '#{href_value}' contains non-ASCII characters",
+            node: node,
+            severity: :error,
+          )
+        end
+
+        # Check other IRI attributes
+        iri_attributes = %w[src action formaction cite longdesc usemap]
+        iri_attributes.each do |attr_name|
+          iri_value = get_attribute(node, attr_name)
+          next unless iri_value
+
+          next if ascii_only?(iri_value)
+
+          context.add_error(
+            requirement_id: id,
+            message: "IRI attribute '#{attr_name}' value '#{iri_value}' contains non-ASCII characters",
+            node: node,
+            severity: :error,
+          )
+        end
+      end
+
+      private
+
+      def ascii_only?(string)
+        string.ascii_only?
+      end
+    end
+  end
+end