svg_conform 0.1.4 → 0.1.5

data/lib/svg_conform/requirements/link_validation_requirement.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "base_requirement"
+require_relative "../references/reference_classifier"
 
 module SvgConform
   module Requirements
@@ -9,22 +10,26 @@ module SvgConform
         return unless element?(node)
 
         # Check href attributes (both href and xlink:href)
-        href_value = get_attribute(node, "href")
+        href_value = extract_href(node)
+        return unless href_value
 
-        # 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
+        # Always validate ASCII requirement (applies to all references)
+        validate_ascii(href_value, node, context)
 
-        if href_value && !ascii_only?(href_value)
-          context.add_error(
-            requirement_id: id,
-            message: "Link href '#{href_value}' contains non-ASCII characters",
+        # Classify and register the reference
+        reference = classify_reference(href_value, node)
+        return unless reference
+
+        context.register_reference(reference)
+
+        # Only validate internal references
+        if reference.internally_validatable?
+          validate_internal_reference(reference, node, context)
+        elsif reference.requires_consumer_validation?
+          # Don't error - just notify consumer
+          context.add_external_reference_notice(
             node: node,
-            severity: :error,
+            reference: reference,
           )
         end
 
@@ -34,14 +39,11 @@ module SvgConform
           iri_value = get_attribute(node, attr_name)
           next unless iri_value
 
-          next if ascii_only?(iri_value)
+          validate_ascii_attribute(iri_value, attr_name, node, context)
 
-          context.add_error(
-            requirement_id: id,
-            message: "IRI attribute '#{attr_name}' value '#{iri_value}' contains non-ASCII characters",
-            node: node,
-            severity: :error,
-          )
+          # Classify and register these references too
+          iri_ref = classify_reference(iri_value, node, attr_name)
+          context.register_reference(iri_ref) if iri_ref
         end
       end
 
@@ -49,13 +51,30 @@ module SvgConform
         # Check href attributes
         href_value = element.raw_attributes["href"] || element.raw_attributes["xlink:href"]
 
-        if href_value && !ascii_only?(href_value)
-          context.add_error(
-            requirement_id: id,
-            message: "Link href '#{href_value}' contains non-ASCII characters",
-            node: element,
-            severity: :error,
+        if href_value
+          validate_ascii(href_value, element, context)
+
+          # Classify and register
+          reference = References::ReferenceClassifier.classify(
+            href_value,
+            element_name: element.name,
+            attribute_name: "href",
+            line_number: element.line,
+            column_number: element.column,
           )
+
+          if reference
+            context.register_reference(reference)
+
+            if reference.internally_validatable?
+              validate_internal_reference(reference, element, context)
+            elsif reference.requires_consumer_validation?
+              context.add_external_reference_notice(
+                node: element,
+                reference: reference,
+              )
+            end
+          end
         end
 
         # Check other IRI attributes
@@ -64,19 +83,83 @@ module SvgConform
           iri_value = element.raw_attributes[attr_name]
           next unless iri_value
 
-          next if ascii_only?(iri_value)
+          validate_ascii_attribute(iri_value, attr_name, element, context)
 
+          # Classify and register
+          iri_ref = References::ReferenceClassifier.classify(
+            iri_value,
+            element_name: element.name,
+            attribute_name: attr_name,
+            line_number: element.line,
+            column_number: element.column,
+          )
+          context.register_reference(iri_ref) if iri_ref
+        end
+      end
+
+      private
+
+      def extract_href(node)
+        href_value = get_attribute(node, "href")
+        return href_value if href_value
+
+        # Check for xlink:href if regular href is not present
+        if node.respond_to?(:attributes)
+          xlink_href = node.attributes.find do |attr|
+            attr.name == "href" && attr.namespace&.uri == "http://www.w3.org/1999/xlink"
+          end
+          xlink_href&.value
+        end
+      end
+
+      def classify_reference(href_value, node, attr_name = "href")
+        References::ReferenceClassifier.classify(
+          href_value,
+          element_name: node.name,
+          attribute_name: attr_name,
+          line_number: node.respond_to?(:line) ? node.line : nil,
+          column_number: node.respond_to?(:column) ? node.column : nil,
+        )
+      end
+
+      def validate_ascii(href_value, node, context)
+        return if ascii_only?(href_value)
+
+        context.add_error(
+          requirement_id: id,
+          message: "Link href '#{href_value}' contains non-ASCII characters",
+          node: node,
+          severity: :error,
+        )
+      end
+
+      def validate_ascii_attribute(iri_value, attr_name, node, context)
+        return 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
+
+      def validate_internal_reference(reference, node, context)
+        return unless reference.is_a?(References::InternalFragmentReference)
+
+        target_id = reference.target_id
+
+        # Use manifest to check if ID exists
+        unless context.id_defined?(target_id)
           context.add_error(
             requirement_id: id,
-            message: "IRI attribute '#{attr_name}' value '#{iri_value}' contains non-ASCII characters",
-            node: element,
+            message: "Internal reference '#{reference.value}' points to non-existent element",
+            node: node,
             severity: :error,
           )
         end
       end
 
-      private
-
       def ascii_only?(string)
         string.ascii_only?
       end

data/lib/svg_conform/requirements/no_external_css_requirement.rb

@@ -41,10 +41,10 @@ module SvgConform
       end
 
       def needs_deferred_validation?
-        check_style_elements  # Only deferred if checking style elements
+        check_style_elements # Only deferred if checking style elements
       end
 
-      def collect_sax_data(element, context)
+      def collect_sax_data(element, _context)
         # Collect style elements for deferred validation (text content needs to be complete)
         if check_style_elements && element.name == "style"
           @collected_style_elements << element
@@ -52,6 +52,9 @@ module SvgConform
       end
 
       def validate_sax_complete(context)
+        # Guard against nil collection
+        return unless @collected_style_elements
+
         # Validate collected style elements
         @collected_style_elements.each do |element|
           check_style_element_sax(element, context)

data/lib/svg_conform/requirements.rb

@@ -1,21 +1,23 @@
 # frozen_string_literal: true
 
 require_relative "requirements/base_requirement"
+require_relative "requirements/element_requirement_config"
 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/viewbox_required_requirement"
+require_relative "requirements/link_validation_requirement"
+require_relative "requirements/id_reference_requirement"
+require_relative "requirements/id_collection_requirement"
+require_relative "requirements/invalid_id_references_requirement"
 require_relative "requirements/forbidden_content_requirement"
+require_relative "requirements/color_restrictions_requirement"
+require_relative "requirements/font_family_requirement"
 require_relative "requirements/style_requirement"
 require_relative "requirements/style_promotion_requirement"
-require_relative "requirements/link_validation_requirement"
-require_relative "requirements/id_reference_requirement"
+require_relative "requirements/no_external_css_requirement"
+require_relative "requirements/no_external_fonts_requirement"
+require_relative "requirements/no_external_images_requirement"
 
 module SvgConform
   module Requirements

data/lib/svg_conform/sax_validation_handler.rb

@@ -4,6 +4,7 @@ require "nokogiri"
 require_relative "element_proxy"
 require_relative "validation_context"
 require_relative "validation_result"
+require_relative "references"
 
 module SvgConform
   # SAX event handler for streaming SVG validation
@@ -30,6 +31,9 @@ module SvgConform
 
     # SAX Event: Document start
     def start_document
+      # Reset state in requirements that maintain state across validations
+      reset_stateful_requirements
+
       # Initialize root level counters
       @position_counters.push({})
     end
@@ -143,12 +147,14 @@ module SvgConform
       context.instance_variable_set(:@structurally_invalid_node_ids, Set.new)
       context.instance_variable_set(:@node_id_cache, {})
       context.instance_variable_set(:@cache_populated, true) # Skip population for SAX
+      context.instance_variable_set(:@reference_manifest,
+                                    References::ReferenceManifest.new(source_document: nil))
       context
     end
 
     # Classify requirements based on validation needs
     def classify_requirements
-      return unless @profile.requirements
+      return unless @profile&.requirements
 
       @profile.requirements.each do |req|
         if req.respond_to?(:needs_deferred_validation?) && req.needs_deferred_validation?
@@ -158,5 +164,14 @@ module SvgConform
         end
       end
     end
+
+    # Reset state in requirements that maintain state
+    def reset_stateful_requirements
+      return unless @profile&.requirements
+
+      @profile.requirements.each do |req|
+        req.reset_state if req.respond_to?(:reset_state)
+      end
+    end
   end
 end

data/lib/svg_conform/validation_context.rb

@@ -6,7 +6,7 @@ module SvgConform
   # Context object passed to rules during validation
   class ValidationContext
     attr_reader :document, :profile, :errors, :warnings, :fixes,
-                :validity_errors
+                :validity_errors, :reference_manifest
 
     def initialize(document, profile)
       @document = document
@@ -19,6 +19,9 @@ module SvgConform
       @structurally_invalid_node_ids = Set.new
       @node_id_cache = {}
       @cache_populated = false
+      @reference_manifest = References::ReferenceManifest.new(
+        source_document: document.file_path,
+      )
     end
 
     # Mark a node as structurally invalid (e.g., invalid parent-child relationship)
@@ -128,6 +131,39 @@ requirement_id: nil, severity: nil, fix: nil, data: {})
       @data[key]
     end
 
+    # Register an ID definition
+    def register_id(id_value, element_name:, line_number: nil,
+column_number: nil)
+      @reference_manifest.register_id(
+        id_value,
+        element_name: element_name,
+        line_number: line_number,
+        column_number: column_number,
+      )
+    end
+
+    # Register a reference
+    def register_reference(reference)
+      @reference_manifest.register_reference(reference)
+    end
+
+    # Check if ID exists in manifest
+    def id_defined?(id_value)
+      @reference_manifest.id_defined?(id_value)
+    end
+
+    # Add notice for external references (not errors)
+    def add_external_reference_notice(node:, reference:, message: nil)
+      notice = ValidationNotice.new(
+        type: :external_reference,
+        node: node,
+        message: message || "External reference: #{reference.value}",
+        data: { reference: reference },
+      )
+      @infos << notice
+      notice
+    end
+
     # Generate a unique identifier for a node based on its path
     # Builds a stable path by walking up the parent chain
     # OPTIMIZED: Lazy cache population - populate entire cache on first call
@@ -489,4 +525,34 @@ requirement_id: nil, severity: nil, violation_type: nil)
       end
     end
   end
+
+  # New class for non-error notifications
+  class ValidationNotice
+    attr_reader :type, :node, :message, :data
+
+    def initialize(type:, node:, message:, data: {})
+      @type = type
+      @node = node
+      @message = message
+      @data = data
+    end
+
+    def line
+      @node.respond_to?(:line) ? @node.line : nil
+    end
+
+    def column
+      @node.respond_to?(:column) ? @node.column : nil
+    end
+
+    def to_h
+      {
+        type: @type,
+        message: @message,
+        line: line,
+        column: column,
+        data: @data,
+      }
+    end
+  end
 end

data/lib/svg_conform/validation_result.rb

@@ -6,7 +6,7 @@ module SvgConform
   # Represents the result of validating an SVG document
   class ValidationResult
     attr_reader :document, :profile, :errors, :warnings, :validity_errors,
-                :fixes_applied, :fixed_document
+                :fixes_applied, :fixed_document, :reference_manifest
 
     def initialize(document, profile, context)
       @document = document
@@ -16,6 +16,7 @@ module SvgConform
       @validity_errors = context.validity_errors
       @fixes_applied = []
       @fixed_document = nil
+      @reference_manifest = context.reference_manifest
     end
 
     def valid?
@@ -58,6 +59,31 @@ module SvgConform
       @errors.select(&:requirement_id)
     end
 
+    # Convenience accessors for manifest data
+    def available_ids
+      @reference_manifest.available_ids
+    end
+
+    def internal_references
+      @reference_manifest.internal_references
+    end
+
+    def external_references
+      @reference_manifest.external_references
+    end
+
+    def has_external_references?
+      !@reference_manifest.external_references.empty?
+    end
+
+    def unresolved_internal_references
+      @reference_manifest.unresolved_internal_references
+    end
+
+    def reference_statistics
+      @reference_manifest.statistics
+    end
+
     def apply_fixes
       return self unless fixable?
 
@@ -90,13 +116,14 @@ module SvgConform
 
     def to_h
       {
-        file: @document.file_path,
+        file: @document&.file_path,
         profile: @profile.name,
         valid: valid?,
         errors: @errors.map(&:to_h),
         warnings: @warnings.map(&:to_h),
         fixes_applied: @fixes_applied.size,
         fixable: fixable_count,
+        reference_manifest: @reference_manifest.to_h,
       }
     end
 
@@ -104,6 +131,20 @@ module SvgConform
       JSON.pretty_generate(to_h, *args)
     end
 
+    # Export manifest separately for detailed analysis
+    def export_manifest(format: :yaml)
+      case format
+      when :yaml
+        @reference_manifest.to_yaml
+      when :json
+        @reference_manifest.to_json
+      when :hash
+        @reference_manifest.to_h
+      else
+        @reference_manifest.to_yaml
+      end
+    end
+
     private
 
     def to_text

data/lib/svg_conform/validator.rb

@@ -31,25 +31,23 @@ module SvgConform
       end
     end
 
-    # Validate SVG content string
-    def validate(svg_content, profile: :svg_1_2_rfc, **options)
+    # Validate SVG content string or document object
+    # Accepts:
+    # - String (XML content) → uses SAX for efficient parsing
+    # - Moxml::Document or Moxml::Element → serializes once, then SAX validates
+    # - Nokogiri::XML::Document or Nokogiri::XML::Element → serializes once, then SAX validates
+    # - Any adapter document object (Ox, Oga, REXML, LibXML) → serializes once, then SAX validates
+    #
+    # IMPORTANT: Always uses SAX validation to safely handle large SVG files.
+    # DOM validation can hang on large files, so we serialize once and validate with SAX.
+    def validate(input, profile: :svg_1_2_rfc, **options)
       merged_options = @options.merge(options)
-      mode = merged_options[:mode]
 
-      # Default to SAX if not specified
-      mode = :sax if mode.nil?
+      # Normalize input to string, then use SAX validation
+      svg_content = normalize_input_to_string(input)
 
-      case mode
-      when :sax
-        validate_content_sax(svg_content, profile: profile, **merged_options)
-      when :dom
-        validate_content_dom(svg_content, profile: profile, **merged_options)
-      when :auto
-        # For content, we can't check file size, so default to SAX
-        validate_content_sax(svg_content, profile: profile, **merged_options)
-      else
-        validate_content_sax(svg_content, profile: profile, **merged_options)
-      end
+      # Always use SAX mode for safe validation (handles large files)
+      validate_content_sax(svg_content, profile: profile, **merged_options)
     end
 
     # Validate a Document object (DOM only)
@@ -87,6 +85,48 @@ module SvgConform
 
     private
 
+    # Normalize various input types to XML string
+    def normalize_input_to_string(input)
+      case input
+      when String
+        # Already a string, return as-is
+        input
+      else
+        # Try to detect and convert document objects
+        convert_document_to_string(input)
+      end
+    end
+
+    # Convert document object to XML string
+    def convert_document_to_string(input)
+      # Check for Moxml document or element
+      if input.respond_to?(:to_xml)
+        return input.to_xml
+      end
+
+      # Check for Nokogiri document or element
+      if defined?(Nokogiri) && input.is_a?(Nokogiri::XML::Node)
+        return input.to_xml
+      end
+
+      # Check for other adapter documents that respond to to_xml
+      if input.respond_to?(:to_s) && xml_like?(input)
+        return input.to_s
+      end
+
+      # If we can't convert, raise an error
+      raise ArgumentError,
+            "Invalid input type: #{input.class}. " \
+            "Expected String, Moxml document, Nokogiri document, or adapter document object. " \
+            "Input must respond to #to_xml or be a valid XML string."
+    end
+
+    # Check if object looks like an XML document
+    def xml_like?(obj)
+      # Basic heuristic: check if it has XML-like methods
+      obj.respond_to?(:name) && obj.respond_to?(:children)
+    end
+
     def determine_mode(file_path, requested_mode)
       case requested_mode
       when :sax

data/lib/svg_conform/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SvgConform
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end

data/lib/svg_conform.rb

@@ -10,16 +10,25 @@ Lutaml::Model::Config.configure do |config|
 end
 
 require_relative "svg_conform/version"
+require_relative "svg_conform/constants"
+require_relative "svg_conform/profile"
+require_relative "svg_conform/profiles"
 require_relative "svg_conform/document"
 require_relative "svg_conform/sax_document"
+require_relative "svg_conform/element_proxy"
 require_relative "svg_conform/validation_context"
 require_relative "svg_conform/validation_result"
-require_relative "svg_conform/profiles"
+require_relative "svg_conform/validator"
+require_relative "svg_conform/conformance_report"
+require_relative "svg_conform/batch_report"
 require_relative "svg_conform/requirements"
+require_relative "svg_conform/references"
 require_relative "svg_conform/remediations"
 require_relative "svg_conform/remediation_result"
+require_relative "svg_conform/remediation_engine"
+require_relative "svg_conform/remediation_runner"
+require_relative "svg_conform/fixer"
 require_relative "svg_conform/external_checkers"
-require_relative "svg_conform/cli"
 
 module SvgConform
   class Error < StandardError; end

data/spec/svg_conform/commands/svgcheck_compare_command_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "spec_helper"
+require "svg_conform/commands/svgcheck_compare"
 
 RSpec.describe SvgConform::Commands::SvgcheckCompare do
   describe "#execute" do

data/spec/svg_conform/commands/svgcheck_compatibility_command_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "spec_helper"
+require "svg_conform/commands/svgcheck_compatibility"
 
 RSpec.describe SvgConform::Commands::SvgcheckCompatibility do
   describe "#execute" do

data/spec/svg_conform/commands/svgcheck_generate_command_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "spec_helper"
+require "svg_conform/commands/svgcheck_generate"
 
 RSpec.describe SvgConform::Commands::SvgcheckGenerate do
   describe "#execute" do