svg_conform 0.1.0

data/lib/svg_conform/remediations/invalid_id_references_remediation.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require_relative "base_remediation"
+
+module SvgConform
+  module Remediations
+    # Remediation action for fixing invalid ID references
+    # Based on the Lucid SVG fix script behavior
+    class InvalidIdReferencesRemediation < BaseRemediation
+      attribute :type, :string, default: -> { "InvalidIdReferencesRemediation" }
+      attribute :strategy, :string, default: "remove_invalid_use"
+      attribute :log_removed_elements, :boolean, default: false
+      attribute :create_placeholder_comment, :boolean, default: false
+      attribute :preserve_valid_attributes, :boolean, default: true
+
+      def apply(document, _context)
+        changes = []
+
+        # Find all use elements with invalid href references
+        document.traverse do |node|
+          next unless node.respond_to?(:name) && node.name == "use"
+
+          href = get_attribute(node,
+                               "href") || get_attribute(node, "xlink:href")
+          next unless href&.start_with?("#")
+
+          referenced_id = href[1..] # Remove the #
+          next if document.xpath("//*[@id='#{referenced_id}']").any? # ID exists, skip
+
+          # Handle invalid ID reference
+          change = handle_use_element(node,
+                                      { href: href, invalid_id: referenced_id })
+          changes << change if change
+        end
+
+        changes
+      end
+
+      private
+
+      def handle_use_element(node, data)
+        case @strategy
+        when "remove_invalid_use"
+          remove_use_element(node, data)
+        when "remove_invalid_href"
+          remove_href_attribute(node, data)
+        when "replace_with_placeholder"
+          replace_with_placeholder(node, data)
+        else
+          raise "Unknown strategy: #{@strategy}"
+        end
+      end
+
+      def handle_other_id_reference(node, data)
+        case @strategy
+        when "remove_invalid_use", "remove_invalid_href"
+          remove_invalid_attribute(node, data)
+        when "replace_with_placeholder"
+          replace_attribute_with_placeholder(node, data)
+        else
+          raise "Unknown strategy: #{@strategy}"
+        end
+      end
+
+      def remove_use_element(node, data)
+        if @create_placeholder_comment
+          comment_text = "Removed invalid use element: href=#{data[:href]}, invalid_id=#{data[:invalid_id]}"
+          comment = create_comment(node.document, comment_text)
+          replace_node(node, comment)
+        else
+          remove_node(node)
+        end
+
+        log_change(
+          :remove_element,
+          "Removed use element with invalid ID reference: #{data[:invalid_id]}",
+          node,
+        )
+      end
+
+      def remove_href_attribute(node, data)
+        # Remove both possible href attributes
+        remove_attribute(node, "xlink:href")
+        remove_attribute(node, "href")
+
+        log_change(
+          :remove_attribute,
+          "Removed invalid href attribute referencing: #{data[:invalid_id]}",
+          node,
+        )
+      end
+
+      def replace_with_placeholder(node, data)
+        comment_text = "Invalid use element removed: #{node.to_xml.strip}"
+        comment = create_comment(node.document, comment_text)
+        replace_node(node, comment)
+
+        log_change(
+          :replace_with_comment,
+          "Replaced use element with comment due to invalid ID reference: #{data[:invalid_id]}",
+          node,
+        )
+      end
+
+      def remove_invalid_attribute(node, data)
+        attribute_name = data[:attribute]
+        remove_attribute(node, attribute_name)
+
+        log_change(
+          :remove_attribute,
+          "Removed #{attribute_name} attribute with invalid ID reference: #{data[:invalid_id]}",
+          node,
+        )
+      end
+
+      def replace_attribute_with_placeholder(node, data)
+        attribute_name = data[:attribute]
+        placeholder_value = "none" # Safe fallback value
+        set_attribute(node, attribute_name, placeholder_value)
+
+        log_change(
+          :replace_attribute,
+          "Replaced #{attribute_name} attribute (invalid ID: #{data[:invalid_id]}) with placeholder: #{placeholder_value}",
+          node,
+        )
+      end
+    end
+  end
+end

data/lib/svg_conform/remediations/namespace_attribute_remediation.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+require "set"
+require_relative "base_remediation"
+
+module SvgConform
+  module Remediations
+    # Remediation for removing disallowed namespace attributes and declarations
+    class NamespaceAttributeRemediation < BaseRemediation
+      attribute :type, :string, default: -> { "NamespaceAttributeRemediation" }
+      attribute :disallowed_namespaces, :string, collection: true, default: -> {
+        []
+      }
+      attribute :allowed_namespaces, :string, collection: true, default: -> {
+        []
+      }
+
+      yaml do
+        map "disallowed_namespaces", to: :disallowed_namespaces
+        map "allowed_namespaces", to: :allowed_namespaces
+      end
+
+      def apply(document, _context)
+        changes = []
+        removed_namespaces = Set.new
+
+        # First pass: remove disallowed namespace attributes
+        document.traverse do |node|
+          next unless element?(node)
+
+          changes.concat(remove_disallowed_attributes(node, removed_namespaces))
+        end
+
+        # Second pass: remove unused namespace declarations
+        document.traverse do |node|
+          next unless element?(node)
+
+          changes.concat(remove_unused_namespace_declarations(node,
+                                                              removed_namespaces))
+        end
+
+        changes
+      end
+
+      private
+
+      def remove_disallowed_attributes(node, removed_namespaces)
+        changes = []
+
+        # Get all attributes that need to be checked
+        attributes_to_remove = []
+
+        if node.respond_to?(:attribute_nodes)
+          # Use attribute_nodes if available (Nokogiri style)
+          node.attribute_nodes.each do |attr|
+            namespace_uri = attr.namespace&.href
+            next unless namespace_uri
+
+            if namespace_disallowed?(namespace_uri)
+              attr_name = if attr.namespace&.prefix
+                            "#{attr.namespace.prefix}:#{attr.name}"
+                          else
+                            attr.name
+                          end
+              attributes_to_remove << attr_name
+              removed_namespaces.add(namespace_uri)
+            end
+          end
+        elsif node.respond_to?(:attributes)
+          # Fallback to attributes method
+          attributes = node.attributes
+
+          if attributes.respond_to?(:each_key)
+            # Hash case
+            attributes.each_key do |name|
+              if should_remove_attribute_by_name?(name.to_s, node,
+                                                  removed_namespaces)
+                attributes_to_remove << name.to_s
+              end
+            end
+          elsif attributes.respond_to?(:each)
+            # Array case
+            attributes.each do |attr|
+              if should_remove_moxml_attribute?(attr, node, removed_namespaces)
+                attr_name = attr.respond_to?(:name) ? attr.name : attr.to_s
+                attributes_to_remove << attr_name
+              end
+            end
+          end
+        end
+
+        # Remove the identified attributes
+        attributes_to_remove.each do |attr_name|
+          if remove_attribute(node, attr_name)
+            changes << {
+              type: :attribute_removed,
+              description: "Removed disallowed namespace attribute '#{attr_name}'",
+              node_name: node.name,
+              attribute: attr_name,
+            }
+          end
+        end
+
+        changes
+      end
+
+      def remove_unused_namespace_declarations(node, removed_namespaces)
+        changes = []
+
+        # Look for xmlns declarations that correspond to removed namespaces
+        attributes_to_remove = []
+
+        if node.respond_to?(:attribute_nodes)
+          node.attribute_nodes.each do |attr|
+            attr_name = attr.name
+            next unless attr_name.start_with?("xmlns:")
+
+            namespace_uri = attr.value
+            # Also check if the namespace prefix itself was in disallowed_namespaces
+            # since xmlns:lucid="lucid" means the URI is literally "lucid"
+            prefix = attr_name.sub("xmlns:", "")
+            if removed_namespaces.include?(namespace_uri) || disallowed_namespaces.include?(namespace_uri) || disallowed_namespaces.include?(prefix)
+              attributes_to_remove << attr_name
+            end
+          end
+        elsif node.respond_to?(:attributes)
+          attributes = node.attributes
+
+          if attributes.respond_to?(:each_key)
+            attributes.each_key do |name|
+              name_str = name.to_s
+              next unless name_str.start_with?("xmlns:")
+
+              namespace_uri = get_attribute(node, name_str)
+              prefix = name_str.sub("xmlns:", "")
+              if namespace_uri && (removed_namespaces.include?(namespace_uri) || disallowed_namespaces.include?(namespace_uri) || disallowed_namespaces.include?(prefix))
+                attributes_to_remove << name_str
+              end
+            end
+          end
+        end
+
+        # Remove the xmlns declarations
+        attributes_to_remove.each do |attr_name|
+          if remove_attribute(node, attr_name)
+            changes << {
+              type: :attribute_removed,
+              description: "Removed unused namespace declaration '#{attr_name}'",
+              node_name: node.name,
+              attribute: attr_name,
+            }
+          end
+        end
+
+        changes
+      end
+
+      def namespace_disallowed?(namespace_uri)
+        if allowed_namespaces.empty?
+          # Blacklist mode: disallowed namespaces are forbidden
+          disallowed_namespaces.include?(namespace_uri)
+        else
+          # Whitelist mode: only allowed namespaces are permitted
+          !allowed_namespaces.include?(namespace_uri)
+        end
+      end
+
+      def should_remove_attribute_by_name?(name, node, removed_namespaces)
+        # Check if this is a namespaced attribute by looking for colon in name
+        return false unless name.include?(":")
+
+        prefix, = name.split(":", 2)
+
+        # Find the namespace URI for this prefix
+        namespace_uri = find_namespace_uri(node, prefix)
+
+        return false unless namespace_uri
+
+        if namespace_disallowed?(namespace_uri)
+          removed_namespaces.add(namespace_uri)
+          true
+        else
+          false
+        end
+      end
+
+      def should_remove_moxml_attribute?(attr, node, removed_namespaces)
+        if attr.respond_to?(:namespace) && attr.namespace
+          namespace_uri = if attr.namespace.respond_to?(:href)
+                            attr.namespace.href
+                          elsif attr.namespace.respond_to?(:uri)
+                            attr.namespace.uri
+                          else
+                            attr.namespace.to_s
+                          end
+
+          return false unless namespace_uri && !namespace_uri.empty?
+
+          if namespace_disallowed?(namespace_uri)
+            removed_namespaces.add(namespace_uri)
+            true
+          else
+            false
+          end
+        else
+          # Fallback to name-based checking
+          name = attr.respond_to?(:name) ? attr.name : attr.to_s
+          should_remove_attribute_by_name?(name, node, removed_namespaces)
+        end
+      end
+
+      def find_namespace_uri(node, prefix)
+        # Check current node's namespace definitions
+        current = node
+        while current.respond_to?(:parent)
+          if current.respond_to?(:namespace_definitions)
+            ns_def = current.namespace_definitions.find do |ns|
+              ns.prefix == prefix
+            end
+            if ns_def
+              return ns_def.uri if ns_def.respond_to?(:uri)
+              return ns_def.href if ns_def.respond_to?(:href)
+
+              return ns_def.to_s
+            end
+          end
+
+          # Check if it's defined as an attribute (xmlns:prefix)
+          xmlns_value = get_attribute(current, "xmlns:#{prefix}")
+          return xmlns_value if xmlns_value
+
+          # Move to parent, but break if parent is nil or doesn't respond to parent
+          begin
+            current = current.parent
+          rescue StandardError
+            break
+          end
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/svg_conform/remediations/namespace_remediation.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require_relative "base_remediation"
+
+module SvgConform
+  module Remediations
+    # Remediation action for namespace-related issues
+    class NamespaceRemediation < BaseRemediation
+      attribute :type, :string, default: -> { "NamespaceRemediation" }
+      attribute :default_namespace, :string, default: "http://www.w3.org/2000/svg"
+      attribute :allowed_namespaces, :string, collection: true, default: -> {
+        ["http://www.w3.org/2000/svg", "http://www.w3.org/1999/xlink",
+         "http://www.w3.org/XML/1998/namespace"]
+      }
+      attribute :remove_elements, :boolean, default: true
+      attribute :remove_attributes, :boolean, default: true
+      attribute :remove_declarations, :boolean, default: true
+
+      yaml do
+        map "default_namespace", to: :default_namespace
+        map "allowed_namespaces", to: :allowed_namespaces
+        map "remove_elements", to: :remove_elements
+        map "remove_attributes", to: :remove_attributes
+        map "remove_declarations", to: :remove_declarations
+      end
+      def apply(document, _context)
+        changes = []
+        default_namespace
+
+        # Skip xmlns handling - assume it's already correct in most cases
+        # (This avoids duplicate xmlns attribute issues)
+
+        # Remove invalid namespace elements and attributes based on configuration
+        nodes_to_remove = []
+
+        document.traverse do |node|
+          next unless element?(node)
+
+          # Check if element has invalid namespace using Moxml's namespace API
+          if remove_elements && node.respond_to?(:namespace) && node.namespace
+            namespace_uri = get_namespace_uri(node.namespace)
+
+            if namespace_uri && !allowed_namespaces.include?(namespace_uri)
+              nodes_to_remove << node
+              changes << {
+                type: :element_removed,
+                description: "Removed invalid namespace element: #{node.name} (#{namespace_uri})",
+                node_name: node.name,
+                namespace_uri: namespace_uri,
+              }
+              next # Skip attribute checking for elements we're removing
+            end
+          end
+
+          # Remove invalid namespace attributes from all elements
+          if remove_attributes && node.respond_to?(:attributes) && node.attributes
+            invalid_attrs = []
+
+            node.attributes.each do |attr_name, attr_value|
+              # Handle both string keys and Moxml::Attribute objects
+              name_str = attr_name.respond_to?(:name) ? attr_name.name : attr_name.to_s
+
+              # For root SVG element, remove xmlns declarations for disallowed namespaces
+              if remove_declarations && node.name == "svg" && name_str.start_with?("xmlns:")
+                name_str.sub("xmlns:", "")
+                value_str = attr_value.respond_to?(:value) ? attr_value.value : attr_value.to_s
+
+                if !allowed_namespaces.include?(value_str)
+                  invalid_attrs << name_str
+                end
+              end
+
+              # For all elements, remove attributes with invalid namespaces
+              # Check if attribute has namespace information (Moxml::Attribute objects)
+              if attr_name.respond_to?(:namespace) && attr_name.namespace
+                attr_namespace_uri = get_namespace_uri(attr_name.namespace)
+
+                if attr_namespace_uri && !allowed_namespaces.include?(attr_namespace_uri)
+                  invalid_attrs << name_str
+                end
+              end
+            end
+
+            # Remove invalid attributes
+            invalid_attrs.each do |attr_name|
+              remove_attribute(node, attr_name)
+              description = if attr_name.start_with?("xmlns:")
+                              "Removed invalid namespace declaration: #{attr_name}"
+                            else
+                              "Removed invalid namespace attribute: #{attr_name}"
+                            end
+
+              changes << {
+                type: :attribute_removed,
+                description: description,
+                node_name: node.name,
+                attribute_name: attr_name,
+              }
+            end
+          end
+        end
+
+        # Remove invalid namespace elements
+        nodes_to_remove.each do |node|
+          remove_node(node)
+        end
+
+        changes
+      end
+
+      private
+
+      def get_namespace_uri(namespace)
+        # Extract URI from Moxml::Namespace object
+        if namespace.respond_to?(:uri)
+          namespace.uri
+        elsif namespace.respond_to?(:to_s)
+          # Extract URI from string representation if needed
+          uri_match = namespace.to_s.match(/="([^"]+)"/)
+          uri_match ? uri_match[1] : nil
+        else
+          nil
+        end
+      end
+
+      def find_namespace_uri_for_prefix(node, prefix)
+        # Check current node and ancestors for namespace declarations
+        current = node
+        while current
+          # Check for xmlns:prefix attribute
+          xmlns_attr = "xmlns:#{prefix}"
+          return current.attributes[xmlns_attr] if current.respond_to?(:attributes) && current.attributes[xmlns_attr]
+
+          # Check using get_attribute method
+          namespace_uri = get_attribute(current, xmlns_attr)
+          return namespace_uri if namespace_uri
+
+          # Move to parent
+          current = current.respond_to?(:parent) ? current.parent : nil
+        end
+
+        nil
+      end
+
+      def find_namespace_uri_for_attribute(node, prefix)
+        # Same logic as find_namespace_uri_for_prefix
+        find_namespace_uri_for_prefix(node, prefix)
+      end
+    end
+  end
+end