svg_conform 0.1.4 → 0.1.5

data/lib/svg_conform/references/base_reference.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module SvgConform
+  module References
+    # Base class for all reference types
+    class BaseReference < Lutaml::Model::Serializable
+      attribute :value, :string
+      attribute :element_name, :string
+      attribute :attribute_name, :string
+      attribute :line_number, :integer
+      attribute :column_number, :integer
+
+      yaml do
+        map "value", to: :value
+        map "element_name", to: :element_name
+        map "attribute_name", to: :attribute_name
+        map "line_number", to: :line_number
+        map "column_number", to: :column_number
+      end
+
+      json do
+        map "value", to: :value
+        map "element_name", to: :element_name
+        map "attribute_name", to: :attribute_name
+        map "line_number", to: :line_number
+        map "column_number", to: :column_number
+      end
+
+      # Abstract method - defines validation scope
+      def validation_scope
+        raise NotImplementedError, "Subclasses must define validation scope"
+      end
+
+      # Can this reference be validated internally by svg_conform?
+      def internally_validatable?
+        validation_scope == :internal
+      end
+
+      # Should this be deferred to consumer for validation?
+      def requires_consumer_validation?
+        validation_scope == :external
+      end
+
+      def to_h
+        {
+          type: self.class.name.split("::").last,
+          value: value,
+          element_name: element_name,
+          attribute_name: attribute_name,
+          line_number: line_number,
+          column_number: column_number,
+          validation_scope: validation_scope,
+        }
+      end
+    end
+
+    # Internal SVG element reference (e.g., #element-id)
+    class InternalFragmentReference < BaseReference
+      def validation_scope
+        :internal
+      end
+
+      def target_id
+        value.sub(/^#/, "")
+      end
+    end
+
+    # External URL reference (http://, https://)
+    class ExternalUrlReference < BaseReference
+      def validation_scope
+        :external
+      end
+
+      def protocol
+        require "uri"
+        URI.parse(value).scheme
+      rescue StandardError
+        nil
+      end
+    end
+
+    # URN reference (urn:*)
+    class UrnReference < BaseReference
+      def validation_scope
+        :external
+      end
+
+      def namespace
+        value.split(":")[1]
+      rescue StandardError
+        nil
+      end
+    end
+
+    # Relative path reference (could be internal or external depending on context)
+    class RelativePathReference < BaseReference
+      def validation_scope
+        :external
+      end
+
+      def has_fragment?
+        value.include?("#")
+      end
+
+      def path_component
+        value.split("#").first
+      end
+
+      def fragment_component
+        parts = value.split("#")
+        parts.size > 1 ? parts.last : nil
+      end
+    end
+
+    # Data URI reference (data:*)
+    class DataUriReference < BaseReference
+      def validation_scope
+        :internal
+      end
+
+      def media_type
+        # Extract media type from data URI
+        match = value.match(%r{^data:([^;,]+)})
+        match ? match[1] : nil
+      end
+    end
+  end
+end

data/lib/svg_conform/references/id_definition.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module SvgConform
+  module References
+    # Represents an ID definition in the SVG document
+    class IdDefinition < Lutaml::Model::Serializable
+      attribute :id_value, :string
+      attribute :element_name, :string
+      attribute :line_number, :integer
+      attribute :column_number, :integer
+
+      yaml do
+        map "id_value", to: :id_value
+        map "element_name", to: :element_name
+        map "line_number", to: :line_number
+        map "column_number", to: :column_number
+      end
+
+      json do
+        map "id_value", to: :id_value
+        map "element_name", to: :element_name
+        map "line_number", to: :line_number
+        map "column_number", to: :column_number
+      end
+
+      def to_h
+        {
+          id_value: id_value,
+          element_name: element_name,
+          line_number: line_number,
+          column_number: column_number,
+        }
+      end
+    end
+  end
+end

data/lib/svg_conform/references/reference_classifier.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "base_reference"
+
+module SvgConform
+  module References
+    # Classifies reference values into appropriate reference types
+    class ReferenceClassifier
+      # Classify a reference value into its appropriate type
+      def self.classify(href_value, element_name:, attribute_name:,
+                       line_number: nil, column_number: nil)
+        return nil if href_value.nil? || href_value.empty?
+
+        reference_class = determine_type(href_value)
+        reference_class.new(
+          value: href_value,
+          element_name: element_name,
+          attribute_name: attribute_name,
+          line_number: line_number,
+          column_number: column_number,
+        )
+      end
+
+      def self.determine_type(href)
+        case href
+        when /^#/
+          InternalFragmentReference
+        when /^data:/i
+          DataUriReference
+        when /^urn:/i
+          UrnReference
+        when %r{^https?://}i
+          ExternalUrlReference
+        when %r{^[./]}
+          # Relative paths starting with ./ or /
+          RelativePathReference
+        else
+          # Could be relative or external depending on context
+          # Treat as relative by default (conservative approach)
+          RelativePathReference
+        end
+      end
+    end
+  end
+end

data/lib/svg_conform/references/reference_manifest.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+require_relative "id_definition"
+require_relative "base_reference"
+
+module SvgConform
+  module References
+    # Comprehensive manifest of all IDs and references in the document
+    # Provides complete context for consumer validation decisions
+    class ReferenceManifest < Lutaml::Model::Serializable
+      attribute :source_document, :string
+      attribute :available_ids, IdDefinition, collection: true, default: -> {
+        []
+      }
+      attribute :internal_references, BaseReference, collection: true, default: -> {
+        []
+      }
+      attribute :external_references, BaseReference, collection: true, default: -> {
+        []
+      }
+
+      yaml do
+        map "source_document", to: :source_document
+        map "available_ids", to: :available_ids
+        map "internal_references", to: :internal_references
+        map "external_references", to: :external_references
+      end
+
+      json do
+        map "source_document", to: :source_document
+        map "available_ids", to: :available_ids
+        map "internal_references", to: :internal_references
+        map "external_references", to: :external_references
+      end
+
+      def initialize(source_document: nil)
+        super()
+        @source_document = source_document
+        @available_ids = []
+        @internal_references = []
+        @external_references = []
+      end
+
+      # Register an ID definition
+      def register_id(id_value, element_name:, line_number: nil,
+column_number: nil)
+        @available_ids << IdDefinition.new(
+          id_value: id_value,
+          element_name: element_name,
+          line_number: line_number,
+          column_number: column_number,
+        )
+      end
+
+      # Register a reference
+      def register_reference(reference)
+        if reference.internally_validatable?
+          @internal_references << reference
+        elsif reference.requires_consumer_validation?
+          @external_references << reference
+        end
+      end
+
+      # Check if an ID is defined
+      def id_defined?(id_value)
+        @available_ids.any? { |id_def| id_def.id_value == id_value }
+      end
+
+      # Get references targeting a specific ID
+      def references_to_id(id_value)
+        @internal_references.select do |ref|
+          ref.is_a?(InternalFragmentReference) &&
+            ref.target_id == id_value
+        end
+      end
+
+      # Get all references grouped by type
+      def references_by_type
+        all_refs = @internal_references + @external_references
+        all_refs.group_by { |ref| ref.class.name.split("::").last }
+      end
+
+      # Get unresolved internal references (references to non-existent IDs)
+      def unresolved_internal_references
+        @internal_references.select do |ref|
+          next unless ref.is_a?(InternalFragmentReference)
+
+          !id_defined?(ref.target_id)
+        end
+      end
+
+      # Get statistics
+      def statistics
+        {
+          total_ids: @available_ids.size,
+          total_references: @internal_references.size + @external_references.size,
+          internal_references: @internal_references.size,
+          external_references: @external_references.size,
+          unresolved_internal: unresolved_internal_references.size,
+          references_by_type: references_by_type.transform_values(&:size),
+        }
+      end
+
+      # Export manifest for consumer processing
+      def to_h
+        {
+          source_document: @source_document,
+          available_ids: @available_ids.map(&:to_h),
+          internal_references: @internal_references.map(&:to_h),
+          external_references: @external_references.map(&:to_h),
+          statistics: statistics,
+        }
+      end
+
+      # Export as YAML for easy inspection
+      def to_yaml
+        require "yaml"
+        to_h.to_yaml
+      end
+
+      # Export as JSON for programmatic processing
+      def to_json(*_args)
+        require "json"
+        JSON.pretty_generate(to_h)
+      end
+    end
+  end
+end

data/lib/svg_conform/references.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "references/base_reference"
+require_relative "references/id_definition"
+require_relative "references/reference_classifier"
+require_relative "references/reference_manifest"
+
+module SvgConform
+  module References
+  end
+end

data/lib/svg_conform/remediations/namespace_attribute_remediation.rb

@@ -32,11 +32,11 @@ module SvgConform
         end
 
         # Second pass: remove unused namespace declarations
-        document.traverse do |node|
-          next unless element?(node)
-
-          changes.concat(remove_unused_namespace_declarations(node,
-                                                              removed_namespaces))
+        # Nokogiri/libxml2 cannot remove namespace declarations via DOM,
+        # so we use string manipulation + reparse
+        if removed_namespaces.any? || disallowed_namespaces.any?
+          changes.concat(remove_namespace_declarations(document,
+                                                       removed_namespaces))
         end
 
         changes
@@ -104,54 +104,45 @@ module SvgConform
         changes
       end
 
-      def remove_unused_namespace_declarations(node, removed_namespaces)
+      def remove_namespace_declarations(document, removed_namespaces)
         changes = []
 
-        # Look for xmlns declarations that correspond to removed namespaces
-        attributes_to_remove = []
+        # Get current XML
+        xml_str = document.to_xml
 
-        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
+        # Build regex to remove xmlns declarations for disallowed namespaces
+        # Match both removed namespaces (from attributes) and explicitly disallowed ones
+        namespaces_to_remove = removed_namespaces.to_a + disallowed_namespaces
 
-          if attributes.respond_to?(:each_key)
-            attributes.each_key do |name|
-              name_str = name.to_s
-              next unless name_str.start_with?("xmlns:")
+        namespaces_to_remove.uniq.each do |ns_identifier|
+          # Try to match xmlns:prefix="anything" where prefix matches the identifier
+          # or xmlns:prefix="identifier" where the URI matches
+          pattern = /\s+xmlns:#{Regexp.escape(ns_identifier)}="[^"]*"/
 
-              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)
+          if xml_str.match?(pattern)
+            xml_str = xml_str.gsub(pattern, "")
             changes << {
-              type: :attribute_removed,
-              description: "Removed unused namespace declaration '#{attr_name}'",
-              node_name: node.name,
-              attribute: attr_name,
+              type: :namespace_removed,
+              description: "Removed unused namespace declaration 'xmlns:#{ns_identifier}'",
+              node_name: "svg",
+              attribute: "xmlns:#{ns_identifier}",
             }
           end
         end
 
+        # Reparse the document to update the internal DOM
+        # This is necessary because namespace declarations cannot be removed
+        # from the DOM directly in Nokogiri/libxml2
+        if changes.any?
+          context = Moxml.new
+          new_moxml_doc = context.parse(xml_str)
+
+          # Replace the document's internal moxml_document
+          # We need to use instance_variable_set since it's a private instance variable
+          document.instance_variable_set(:@moxml_document, new_moxml_doc)
+          document.clear_cache
+        end
+
         changes
       end
 

data/lib/svg_conform/requirements/id_collection_requirement.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "base_requirement"
+
+module SvgConform
+  module Requirements
+    # Collects all ID definitions in the document for reference validation
+    class IdCollectionRequirement < BaseRequirement
+      def check(node, context)
+        return unless element?(node)
+
+        id_value = get_attribute(node, "id")
+        return unless id_value
+
+        # Register the ID in the manifest
+        context.register_id(
+          id_value,
+          element_name: node.name,
+          line_number: node.respond_to?(:line) ? node.line : nil,
+          column_number: node.respond_to?(:column) ? node.column : nil,
+        )
+      end
+
+      def validate_sax_element(element, context)
+        id_value = element.raw_attributes["id"]
+        return unless id_value
+
+        # Register the ID in the manifest
+        context.register_id(
+          id_value,
+          element_name: element.name,
+          line_number: element.respond_to?(:line) ? element.line : nil,
+          column_number: element.respond_to?(:column) ? element.column : nil,
+        )
+      end
+    end
+  end
+end

data/lib/svg_conform/requirements/id_reference_requirement.rb

@@ -10,6 +10,14 @@ module SvgConform
         true
       end
 
+      # Reset state before each validation run to prevent state leakage
+      def reset_state
+        @collected_ids = Set.new
+        @collected_url_refs = []
+        @collected_href_refs = []
+        @collected_other_refs = []
+      end
+
       def collect_sax_data(element, _context)
         # Initialize collections on first call
         @collected_ids ||= Set.new
@@ -67,6 +75,9 @@ module SvgConform
       end
 
       def validate_sax_complete(context)
+        # Guard against nil collections (if collect_sax_data was never called)
+        return unless @collected_url_refs && @collected_href_refs && @collected_other_refs && @collected_ids
+
         # Validate all collected references
         @collected_url_refs.each do |element, ref_id, attr_name|
           next if @collected_ids.include?(ref_id)

data/lib/svg_conform/requirements/invalid_id_references_requirement.rb

@@ -79,6 +79,9 @@ module SvgConform
       end
 
       def validate_sax_complete(context)
+        # Guard against nil collections
+        return unless @use_element_refs && @other_refs && @collected_ids
+
         # Validate use element references
         @use_element_refs.each do |element, ref_id, href|
           next if @collected_ids.include?(ref_id)