svg_conform 0.1.9 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4879f5648a06585ca68ae1430f928c327b267c3de96e92ae54333a002127243
-  data.tar.gz: 7fb876639e3d0d935020089981803d43e2648131bf7a074b0b127605c99009ff
+  metadata.gz: 8f59b89abd58959b19078c28ce450f6ee102a007176d102031a04233f924465e
+  data.tar.gz: 61e68396baf1673fcd8d764a2d141cd62006d1167d2cea0b9d8695a7bb7ea6c2
 SHA512:
-  metadata.gz: ca32f36fb1bcb98fc25be20fc237291f5fa0efedd55c71cb62b8862e60c3628f05673a0d16def9deda237e4a3b53312c78e39d3daf2bb42700e58f388a2d38c8
-  data.tar.gz: '0086cffd30f8c81aba4e157caf6a0bfe197f4ce597971941e4ddcc136f0ac7cf11460eb8e4103094a6636aa546c5d687c0f724697e441c509a94e1697bc41857'
+  metadata.gz: ffb22ae1a52cbf687b054dbe17ccf8aa44b17bbeeaad5122b57300e9562e73e9cbf005d0c330b2ce13c28a7e6f349ddd191b3d8e8918c6e8745d663debcbec7c
+  data.tar.gz: dedcb6619d41fc142b0bb6432f15a693b38699ca52b80ba0e255d38a7feca6a86fca6a52daa15f5e694b8f4ca1da323cf67289129305b99a3f15616df336415a

data/.gitignore

@@ -10,3 +10,7 @@
 # rspec failure tracking
 .rspec_status
 svgcheck-reference/
+
+.kilocode
+.claude
+

data/.rubocop_todo.yml

@@ -1,6 +1,6 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2026-01-22 08:33:31 UTC using RuboCop version 1.82.1.
+# on 2026-01-23 01:37:10 UTC using RuboCop version 1.82.1.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
@@ -14,7 +14,7 @@ Layout/BlockAlignment:
   Exclude:
     - 'spec/svg_conform/profiles/svg_1_2_rfc_profile_spec.rb'
 
-# Offense count: 647
+# Offense count: 620
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: Max, AllowHeredoc, AllowURI, AllowQualifiedName, URISchemes, AllowRBSInlineAnnotation, AllowCopDirectives, AllowedPatterns, SplitStrings.
 # URISchemes: http, https
@@ -70,7 +70,7 @@ Lint/UnreachableCode:
   Exclude:
     - 'lib/svg_conform/commands/check.rb'
 
-# Offense count: 151
+# Offense count: 146
 # Configuration parameters: AllowedMethods, AllowedPatterns, CountRepeatedAttributes, Max.
 Metrics/AbcSize:
   Enabled: false
@@ -81,17 +81,17 @@ Metrics/AbcSize:
 Metrics/BlockLength:
   Max: 253
 
-# Offense count: 6
+# Offense count: 2
 # Configuration parameters: CountBlocks, CountModifierForms.
 Metrics/BlockNesting:
   Max: 4
 
-# Offense count: 127
+# Offense count: 125
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/CyclomaticComplexity:
   Enabled: false
 
-# Offense count: 263
+# Offense count: 258
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
 Metrics/MethodLength:
   Max: 154
@@ -101,18 +101,11 @@ Metrics/MethodLength:
 Metrics/ParameterLists:
   Max: 9
 
-# Offense count: 101
+# Offense count: 99
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/PerceivedComplexity:
   Enabled: false
 
-# Offense count: 4
-# Configuration parameters: EnforcedStyle, AllowedIdentifiers, AllowedPatterns, ForbiddenIdentifiers, ForbiddenPatterns.
-# SupportedStyles: snake_case, camelCase
-Naming/VariableName:
-  Exclude:
-    - 'check_clippath_font.rb'
-
 # Offense count: 2
 # Configuration parameters: MinSize.
 Performance/CollectionLiteralInLoop:
@@ -144,6 +137,14 @@ RSpec/DescribeClass:
 RSpec/ExampleLength:
   Max: 53
 
+# Offense count: 1
+# This cop supports safe autocorrection (--autocorrect).
+# Configuration parameters: EnforcedStyle.
+# SupportedStyles: implicit, each, example
+RSpec/HookArgument:
+  Exclude:
+    - 'spec/spec_helper.rb'
+
 # Offense count: 2
 RSpec/LeakyConstantDeclaration:
   Exclude:

data/benchmark/performance_comparison.rb

@@ -0,0 +1,120 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Performance benchmark for svg_conform optimizations
+# Measures validation speed for single and batch operations
+
+require "bundler/setup"
+require "benchmark"
+require_relative "../lib/svg_conform"
+
+# Helper method to create test SVG content
+def create_test_svg(element_count: 10, attribute_count: 5)
+  elements = (1..element_count).map do |i|
+    attrs = (1..attribute_count).map { |j| "attr#{j}='value#{j}'" }.join(" ")
+    "<rect id='rect#{i}' x='#{i * 10}' y='#{i * 10}' width='10' height='10' #{attrs}/>"
+  end
+
+  <<~SVG
+    <?xml version="1.0"?>
+    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1000 1000">
+      #{elements.join("\n      ")}
+    </svg>
+  SVG
+end
+
+puts "=" * 80
+puts "svg_conform Performance Benchmark"
+puts "=" * 80
+puts
+
+# Test configurations
+test_cases = [
+  { name: "Small document", elements: 10, attributes: 3 },
+  { name: "Medium document", elements: 50, attributes: 5 },
+  { name: "Large document", elements: 100, attributes: 8 },
+]
+
+validator = SvgConform::Validator.new
+
+test_cases.each do |test_case|
+  puts "Test: #{test_case[:name]}"
+  puts "  Elements: #{test_case[:elements]}, Attributes per element: #{test_case[:attributes]}"
+  puts
+
+  svg_content = create_test_svg(element_count: test_case[:elements],
+                                attribute_count: test_case[:attributes])
+
+  # Warmup run
+  validator.validate(svg_content, profile: :svg_1_2_rfc)
+
+  # Benchmark single validation
+  single_time = Benchmark.measure do
+    100.times do
+      validator.validate(svg_content, profile: :svg_1_2_rfc)
+    end
+  end
+
+  puts "  Single validation (100 runs): #{(single_time.real * 1000).round(2)}ms"
+  puts "    Average per validation: #{(single_time.real * 10).round(2)}ms"
+
+  # Benchmark batch validation
+  contents = Array.new(10) do
+    create_test_svg(element_count: test_case[:elements],
+                    attribute_count: test_case[:attributes])
+  end
+
+  batch_time = Benchmark.measure do
+    10.times do
+      contents.each do |content|
+        validator.validate(content, profile: :svg_1_2_rfc)
+      end
+    end
+  end
+
+  puts "  Batch validation (10 files × 10 runs): #{(batch_time.real * 1000).round(2)}ms"
+  puts "    Average per file: #{(batch_time.real * 100).round(2)}ms"
+  puts
+end
+
+puts "=" * 80
+puts "Memory Profiling"
+puts "=" * 80
+puts
+
+if Object.const_defined?(:GC)
+  GC.start
+  before_mem = `ps -o rss= -p #{Process.pid}`.to_i
+
+  # Create and validate 100 documents
+  100.times do
+    svg = create_test_svg(element_count: 50, attribute_count: 5)
+    validator.validate(svg, profile: :svg_1_2_rfc)
+  end
+
+  GC.start
+  after_mem = `ps -o rss= -p #{Process.pid}`.to_i
+
+  mem_increase = after_mem - before_mem
+  puts "  RSS memory increase: #{mem_increase} KB"
+  puts "  Per validation: #{(mem_increase / 100.0).round(2)} KB"
+else
+  puts "  Memory profiling not available on this platform"
+end
+
+puts
+puts "=" * 80
+puts "Benchmark Complete"
+puts "=" * 80
+puts
+puts "Optimizations tested:"
+puts "  ✓ Phase 1.1: ElementProxy#path_id memoization"
+puts "  ✓ Phase 1.2: Element configuration index"
+puts "  ✓ Phase 2.1: Requirement classification cache"
+puts "  ✓ Phase 2.2: Global properties constant"
+puts "  ✓ Phase 2.3: ElementProxy attributes cache"
+puts "  ✓ Phase 3.1: Configuration validation cache"
+puts "  ✓ Phase 3.3: ProfileCompiler class"
+puts "  ✓ Phase 4.1: TrackerFactory extraction"
+puts "  ✓ Phase 5.1: Batch validation optimization"
+puts

data/docs/performance.adoc

@@ -0,0 +1,239 @@
+= Performance Optimization Guide
+
+This guide documents the performance optimization patterns used in svg_conform.
+
+== Goals
+
+The performance optimization strategy focuses on:
+
+* Reducing validation time for repeated operations
+* Minimizing memory allocations during SAX parsing
+* Caching expensive operations without introducing complexity
+* Maintaining clean separation of concerns
+
+== Optimization Patterns
+
+=== Memoization
+
+Cache computed values to avoid repeated calculations.
+
+*Example:* `ElementProxy#path_id` uses `@cached_path_id` to store the computed path:
+
+[source,ruby]
+----
+def path_id
+  @cached_path_id ||= begin
+    parts = @path + ["#{@name}[#{@position]}"]
+    "/#{parts.join('/')}"
+  end
+end
+----
+
+*When to use:* When a method is called multiple times with the same result and the computation is expensive.
+
+*When to avoid:* When the result changes between calls, or the computation is trivial.
+
+=== Class-Level Caching with Thread Safety
+
+Use class-level caches with Mutex for thread-safe shared state.
+
+*Example:* Requirement classification cache in `SaxValidationHandler`:
+
+[source,ruby]
+----
+@classification_cache = {}
+@classification_cache_mutex = Mutex.new
+
+def classify_requirements_with_cache
+  profile_key = @profile.class.name
+  classified = self.class.classification_cache_mutex.synchronize do
+    self.class.classification_cache[profile_key]
+  end
+
+  # ... compute and cache if not found
+end
+----
+
+*When to use:* When the cached value is shared across all instances and doesn't change.
+
+*When to avoid:* When the cached value is instance-specific or changes frequently.
+
+=== Frozen Constants
+
+Define immutable data as frozen constants to avoid reallocations.
+
+*Example:* `GLOBAL_PROPERTIES` constant in `AllowedElementsRequirement`:
+
+[source,ruby]
+----
+GLOBAL_PROPERTIES = %w[
+  about base baseprofile d break class content cx cy
+  # ... full list of properties
+].freeze
+----
+
+*When to use:* For lookup tables, configuration data, and other immutable collections.
+
+*When to avoid:* When the data needs to be modified at runtime.
+
+=== Hash Indexes for O(1) Lookups
+
+Pre-build hash indexes for fast lookups instead of linear array searches.
+
+*Example:* Element configuration index in `AllowedElementsRequirement`:
+
+[source,ruby]
+----
+def after_initialize
+  build_element_config_index if element_configs&.any?
+end
+
+def build_element_config_index
+  @element_config_index = {}
+  element_configs.each do |config|
+    @element_config_index[config.tag] = config
+  end
+end
+
+# Usage - O(1) instead of O(n)
+element_config = @element_config_index&.dig(element_name)
+----
+
+*When to use:* When frequently looking up items by key in a collection.
+
+*When to avoid:* When the collection is small or accessed sequentially.
+
+=== Lazy Initialization with `||=`
+
+Use the "or-equals" operator for lazy initialization.
+
+*Example:* Cached attributes array in `ElementProxy`:
+
+[source,ruby]
+----
+def attributes
+  @cached_attributes ||= @raw_attributes.map { |name, value| SaxAttribute.new(name, value) }
+end
+----
+
+*When to use:* When a value is expensive to compute and may not be needed.
+
+*When to avoid:* When `nil` or `false` are valid cached values (use explicit nil check instead).
+
+=== Batch Processing Optimization
+
+Amortize fixed costs across multiple operations.
+
+*Example:* Batch file validation in `Validator`:
+
+[source,ruby]
+----
+def validate_files(file_paths, profile: :svg_1_2_rfc, **options)
+  # Load profile once
+  profile_obj = resolve_profile(profile)
+
+  file_paths.each do |file_path|
+    validate_file_with_profile(file_path, profile_obj, **options)
+  end
+end
+----
+
+*When to use:* When processing multiple items with shared setup costs.
+
+*When to avoid:* When processing single items or when items have different configurations.
+
+=== Factory Pattern for Complex Initialization
+
+Centralize object creation for cleaner initialization.
+
+*Example:* `TrackerFactory` for creating validation trackers:
+
+[source,ruby]
+----
+module Validation
+  module TrackerFactory
+    def self.create_all_trackers(document)
+      node_id_manager = create_node_id_manager(document)
+
+      {
+        error_tracker: create_error_tracker,
+        node_id_manager: node_id_manager,
+        # ... other trackers
+      }
+    end
+  end
+end
+----
+
+*When to use:* When initialization involves multiple related objects or complex logic.
+
+*When to avoid:* For simple object creation that doesn't benefit from centralization.
+
+== Anti-Patterns to Avoid
+
+=== Premature Optimization
+
+Don't optimize without benchmarks. Measure first, then optimize.
+
+=== Global Mutable State
+
+Avoid mutable global state. Use class-level caches with thread-safe access.
+
+=== Over-Abstraction
+
+Don't create abstractions just for the sake of it. Each abstraction should pull its weight.
+
+=== Optimizing Uncommon Paths
+
+Focus on hot paths. Don't optimize code that rarely runs.
+
+=== Sacrificing Readability
+
+Performance gains should not come at the cost of code clarity.
+
+== Performance Metrics
+
+The `benchmark/performance_comparison.rb` script measures:
+
+* Single validation speed (average time per document)
+* Batch validation speed (average time per file)
+* Memory usage per validation
+
+Run benchmarks before and after optimizations to measure impact:
+
+[source,shell]
+----
+ruby benchmark/performance_comparison.rb
+----
+
+== Architecture Considerations
+
+=== SAX vs DOM Validation
+
+svg_conform uses SAX validation by default for better performance:
+
+* *SAX mode*: Constant memory, streaming parser, handles large files
+* *DOM mode*: Loads full document, uses more memory, slower for large files
+
+Always prefer SAX for validation. Only use DOM when applying remediations.
+
+=== Caching Strategy
+
+* *Instance-level cache*: Use for data specific to a validation run
+* *Class-level cache*: Use for data shared across all instances
+* *Thread safety*: Always use Mutex for class-level shared state
+
+== Future Optimization Opportunities
+
+Areas that may benefit from future optimization:
+
+* Parallel batch validation for multi-core systems
+* Compiled profiles with pre-computed lookup tables
+* Streaming remediation to avoid full DOM load
+* Attribute name interning for reduced memory
+
+== Further Reading
+
+* `PERFORMANCE_OPTIMIZATION_PLAN.md` - Detailed optimization plan
+* `CLAUDE.md` - Architecture overview
+* `benchmark/performance_comparison.rb` - Performance benchmarks

data/lib/svg_conform/element_proxy.rb

@@ -32,15 +32,20 @@ module SvgConform
       @child_counters = {} # Track child element positions
     end
 
-    # Build full path ID for this element
+    # Build full path ID for this element (memoized for performance)
     def path_id
-      parts = @path + ["#{@name}[#{@position}]"]
-      "/#{parts.join('/')}"
+      @path_id ||= begin
+        parts = @path + ["#{@name}[#{@position}]"]
+        "/#{parts.join('/')}"
+      end
     end
 
-    # Return attributes as array of SaxAttribute objects (for compatibility)
+    # Return attributes as array of SaxAttribute objects (memoized for performance)
+    # Cached to avoid repeated object allocations during SAX parsing
     def attributes
-      @raw_attributes.map { |name, value| SaxAttribute.new(name, value) }
+      @attributes ||= @raw_attributes.map do |name, value|
+        SaxAttribute.new(name, value)
+      end
     end
 
     # Check if this element has a specific attribute
@@ -75,8 +80,8 @@ module SvgConform
         # Boolean check
         has_attribute?(method.to_s.chomp("?"))
       else
-        # Attribute access
-        @attributes[method.to_s] || @attributes[method.to_sym]
+        # Attribute access - use raw_attributes hash, not cached array
+        @raw_attributes[method.to_s] || @raw_attributes[method.to_sym]
       end
     end
 

data/lib/svg_conform/profile.rb

@@ -7,6 +7,8 @@ require_relative "remediations"
 module SvgConform
   # Base class for SVG validation profiles using lutaml-model serialization
   class Profile < Lutaml::Model::Serializable
+    PROFILES_DIR = File.expand_path("../../config/profiles", __dir__)
+
     attribute :name, :string
     attribute :description, :string
     attribute :import, :string

data/lib/svg_conform/profile_compiler.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require_relative "profile"
+
+module SvgConform
+  # Compiles and prepares SVG validation profiles
+  # Centralizes profile loading logic for better separation of concerns
+  class ProfileCompiler
+    @compile_cache = {}
+    @compile_mutex = Mutex.new
+
+    class << self
+      attr_reader :compile_cache, :compile_mutex
+
+      # Compile a profile by name
+      # Returns a cached profile if already compiled
+      def compile(profile_id)
+        profile_key = profile_id.to_s
+
+        # Check cache (thread-safe)
+        compile_mutex.synchronize do
+          return compile_cache[profile_key] if compile_cache[profile_key]
+        end
+
+        # Load and compile profile
+        profile = load_profile(profile_key)
+        compiled_profile = prepare_profile(profile)
+
+        # Cache result (thread-safe)
+        compile_mutex.synchronize do
+          compile_cache[profile_key] = compiled_profile
+        end
+
+        compiled_profile
+      end
+
+      # Compile from YAML content
+      def compile_from_yaml(yaml_content)
+        profile = Profile.from_yaml(yaml_content)
+        prepare_profile(profile)
+      end
+
+      # Compile from file path
+      def compile_from_file(file_path)
+        profile = Profile.load_from_file(file_path)
+        prepare_profile(profile)
+      end
+
+      # Clear compilation cache
+      def clear_cache!
+        compile_mutex.synchronize do
+          compile_cache.clear
+        end
+      end
+
+      private
+
+      # Load profile from profiles directory
+      def load_profile(profile_name)
+        profile_file = File.join(Profile::PROFILES_DIR, "#{profile_name}.yml")
+
+        unless File.exist?(profile_file)
+          raise ProfileError,
+                "Profile not found: #{profile_name} (expected: #{profile_file})"
+        end
+
+        Profile.load_from_file(profile_file)
+      end
+
+      # Prepare profile for use (validation and preprocessing)
+      def prepare_profile(profile)
+        # Validate profile has required fields
+        validate_profile(profile)
+
+        # Pre-compute requirement classifications for SAX validation
+        precompute_requirement_metadata(profile)
+
+        profile
+      end
+
+      # Validate profile structure
+      def validate_profile(profile)
+        if profile.name.nil? || profile.name.empty?
+          raise ProfileError,
+                "Profile must have a name"
+        end
+      end
+
+      # Pre-compute metadata for faster validation
+      def precompute_requirement_metadata(profile)
+        # Trigger requirement classification to populate caches
+        profile.requirements.each do |req|
+          # Access classification method to populate SaxValidationHandler cache
+          if req.respond_to?(:needs_deferred_validation?)
+            req.needs_deferred_validation?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/svg_conform/profiles.rb

@@ -4,7 +4,6 @@ require_relative "profile"
 
 module SvgConform
   module Profiles
-    PROFILES_DIR = File.expand_path("../../config/profiles", __dir__)
     @@cache = {}
 
     def self.get(profile_id)
@@ -21,7 +20,7 @@ module SvgConform
     def self.available_profiles
       return @@cache.keys.map(&:to_sym) if @@cache.any?
 
-      profile_files = Dir.glob(File.join(PROFILES_DIR, "*.yml"))
+      profile_files = Dir.glob(File.join(Profile::PROFILES_DIR, "*.yml"))
       profile_files.map { |file| File.basename(file, ".yml").to_sym }
     end
 
@@ -40,7 +39,7 @@ module SvgConform
     def self.load_profile(profile_name)
       return @@cache[profile_name] if @@cache[profile_name]
 
-      profile_file = File.join(PROFILES_DIR, "#{profile_name}.yml")
+      profile_file = File.join(Profile::PROFILES_DIR, "#{profile_name}.yml")
 
       unless File.exist?(profile_file)
         raise ProfileError,

data/lib/svg_conform/requirements/allowed_elements_requirement.rb

@@ -32,6 +32,32 @@ module SvgConform
         "http://www.w3.org/2000/01/rdf-schema#",
       ].freeze
 
+      # Global properties allowed on any element (from svgcheck word_properties.py)
+      # Defined once at class level to avoid repeated array allocations
+      GLOBAL_PROPERTIES = %w[
+        about base baseprofile d break class content cx cy datatype height href
+        label lang pathlength points preserveaspectratio property r rel resource
+        rev role rotate rx ry space snapshottime transform typeof version width
+        viewbox x x1 x2 y y1 y2 stroke stroke-width stroke-linecap stroke-linejoin
+        stroke-miterlimit stroke-dasharray stroke-dashoffset stroke-opacity
+        vector-effect viewport-fill display viewport-fill-opacity visibility
+        image-rendering color-rendering shape-rendering text-rendering
+        buffered-rendering solid-opacity solid-color color stop-color stop-opacity
+        line-increment text-align display-align font-size font-family font-weight
+        font-style font-variant direction unicode-bidi text-anchor fill fill-rule
+        fill-opacity requiredfeatures requiredformats requiredextensions
+        requiredfonts systemlanguage
+      ].freeze
+
+      # Class-level cache for validated configurations
+      @configuration_validation_cache = {}
+      @configuration_validation_mutex = Mutex.new
+
+      class << self
+        attr_reader :configuration_validation_cache,
+                    :configuration_validation_mutex
+      end
+
       yaml do
         map "id", to: :id
         map "description", to: :description
@@ -47,10 +73,48 @@ module SvgConform
         map "allow_rdf_metadata", to: :allow_rdf_metadata
       end
 
+      def after_initialize
+        build_element_config_index if element_configs&.any?
+      end
+
+      # Ensure element config index is built (lazy initialization)
+      def element_config_index
+        @element_config_index ||= build_element_config_index
+      end
+
+      # Build element configuration index for O(1) lookup
+      def build_element_config_index
+        return {} unless element_configs&.any?
+
+        index = {}
+        element_configs.each do |config|
+          index[config.tag] = config
+          index["*"] = config if config.tag == "*"
+        end
+        index
+      end
+
       # Check for configuration conflicts and emit warnings
+      # Uses class-level cache to skip validation for identical configurations
       def validate_configuration
         return if allowed_attribute_patterns.empty? || !element_configs&.any?
 
+        # Create cache key from configuration
+        config_key = {
+          patterns: allowed_attribute_patterns.sort,
+          element_configs: element_configs.map do |ec|
+            { tag: ec.tag, attr: ec.attr&.sort }
+          end,
+        }.hash
+
+        # Check cache (thread-safe)
+        already_validated = self.class.configuration_validation_mutex.synchronize do
+          self.class.configuration_validation_cache[config_key]
+        end
+
+        return if already_validated
+
+        # Perform validation
         element_configs.each do |element_config|
           next unless element_config&.attr
 
@@ -75,15 +139,16 @@ module SvgConform
                  "Allowed patterns take precedence over element-specific disallowed attributes."
           end
         end
+
+        # Mark as validated (thread-safe)
+        self.class.configuration_validation_mutex.synchronize do
+          self.class.configuration_validation_cache[config_key] = true
+        end
       end
 
       def check(node, context)
-        # Validate configuration once on first use
-        @_config_validated ||= false
-        unless @_config_validated
-          validate_configuration
-          @_config_validated = true
-        end
+        # Validate configuration (uses class-level cache to skip redundant validations)
+        validate_configuration
 
         return unless element?(node)
 
@@ -158,12 +223,8 @@ module SvgConform
       end
 
       def validate_sax_element(element, context)
-        # Validate configuration once on first use
-        @_config_validated ||= false
-        unless @_config_validated
-          validate_configuration
-          @_config_validated = true
-        end
+        # Validate configuration (uses class-level cache to skip redundant validations)
+        validate_configuration
 
         # Skip if parent is structurally invalid (matches DOM behavior)
         if element.parent && context.node_structurally_invalid?(element.parent)
@@ -261,10 +322,8 @@ module SvgConform
       def invalid_parent_child?(parent_name, child_name)
         return false unless element_configs&.any?
 
-        # Find the configuration for the parent element
-        parent_config = element_configs.find do |config|
-          config.tag == parent_name
-        end
+        # Find the configuration for the parent element (O(1) with index)
+        parent_config = element_config_index&.dig(parent_name)
         return false unless parent_config
 
         # If allowed_children is defined and not empty, use it
@@ -296,9 +355,7 @@ module SvgConform
 
         return errors unless element_configs&.any?
 
-        element_config = element_configs.find do |config|
-          config.tag == element_name
-        end
+        element_config = element_config_index&.dig(element_name)
 
         return errors unless element_config&.attr
 
@@ -319,21 +376,8 @@ module SvgConform
         allowed_attrs = (allowed_attrs + common_attrs).uniq
 
         # Add global properties that svgcheck allows on any element (from word_properties.py)
-        global_properties = %w[
-          about base baseprofile d break class content cx cy datatype height href
-          label lang pathlength points preserveaspectratio property r rel resource
-          rev role rotate rx ry space snapshottime transform typeof version width
-          viewbox x x1 x2 y y1 y2 stroke stroke-width stroke-linecap stroke-linejoin
-          stroke-miterlimit stroke-dasharray stroke-dashoffset stroke-opacity
-          vector-effect viewport-fill display viewport-fill-opacity visibility
-          image-rendering color-rendering shape-rendering text-rendering
-          buffered-rendering solid-opacity solid-color color stop-color stop-opacity
-          line-increment text-align display-align font-size font-family font-weight
-          font-style font-variant direction unicode-bidi text-anchor fill fill-rule
-          fill-opacity requiredfeatures requiredformats requiredextensions
-          requiredfonts systemlanguage
-        ]
-        allowed_attrs = (allowed_attrs + global_properties).uniq
+        # GLOBAL_PROPERTIES is defined at class level to avoid repeated allocations
+        allowed_attrs = (allowed_attrs + GLOBAL_PROPERTIES).uniq
 
         node.attributes.each do |attr|
           attr_name = attr.name.downcase
@@ -378,7 +422,7 @@ module SvgConform
         # Check for globally disallowed attributes (using * tag)
         return errors unless element_configs&.any?
 
-        global_config = element_configs.find { |config| config.tag == "*" }
+        global_config = element_config_index&.dig("*")
         return errors unless global_config&.attr
 
         global_disallowed = []
@@ -446,9 +490,7 @@ module SvgConform
 
         return errors unless element_configs&.any?
 
-        element_config = element_configs.find do |config|
-          config.tag == element_name
-        end
+        element_config = element_config_index&.dig(element_name)
         return errors unless element_config&.attr
 
         allowed_attrs = []
@@ -467,22 +509,9 @@ module SvgConform
         common_attrs = %w[id class style xmlns]
         allowed_attrs = (allowed_attrs + common_attrs).uniq
 
-        # Add global properties
-        global_properties = %w[
-          about base baseprofile d break class content cx cy datatype height href
-          label lang pathlength points preserveaspectratio property r rel resource
-          rev role rotate rx ry space snapshottime transform typeof version width
-          viewbox x x1 x2 y y1 y2 stroke stroke-width stroke-linecap stroke-linejoin
-          stroke-miterlimit stroke-dasharray stroke-dashoffset stroke-opacity
-          vector-effect viewport-fill display viewport-fill-opacity visibility
-          image-rendering color-rendering shape-rendering text-rendering
-          buffered-rendering solid-opacity solid-color color stop-color stop-opacity
-          line-increment text-align display-align font-size font-family font-weight
-          font-style font-variant direction unicode-bidi text-anchor fill fill-rule
-          fill-opacity requiredfeatures requiredformats requiredextensions
-          requiredfonts systemlanguage
-        ]
-        allowed_attrs = (allowed_attrs + global_properties).uniq
+        # Add global properties that svgcheck allows on any element (from word_properties.py)
+        # GLOBAL_PROPERTIES is defined at class level to avoid repeated allocations
+        allowed_attrs = (allowed_attrs + GLOBAL_PROPERTIES).uniq
 
         element.attributes.each do |attr|
           attr_name = attr.name.downcase
@@ -527,7 +556,7 @@ module SvgConform
 
         return errors unless element_configs&.any?
 
-        global_config = element_configs.find { |config| config.tag == "*" }
+        global_config = element_config_index&.dig("*")
         return errors unless global_config&.attr
 
         global_disallowed = []

data/lib/svg_conform/sax_validation_handler.rb

@@ -15,6 +15,14 @@ module SvgConform
   class SaxValidationHandler < Nokogiri::XML::SAX::Document
     attr_reader :result, :context
 
+    # Class-level cache for requirement classifications by profile class
+    @classification_cache = {}
+    @classification_cache_mutex = Mutex.new
+
+    class << self
+      attr_reader :classification_cache, :classification_cache_mutex
+    end
+
     def initialize(profile)
       @profile = profile
       @element_stack = [] # Track parent-child hierarchy
@@ -26,10 +34,8 @@ module SvgConform
       # Create validation context (without document reference for SAX)
       @context = create_sax_context
 
-      # Classify requirements into immediate vs deferred
-      @immediate_requirements = []
-      @deferred_requirements = []
-      classify_requirements
+      # Classify requirements into immediate vs deferred (use cache if available)
+      @immediate_requirements, @deferred_requirements = classify_requirements_with_cache
     end
 
     # SAX Event: Document start
@@ -138,28 +144,77 @@ module SvgConform
 
     # Create a SAX-compatible validation context
     def create_sax_context
-      # Create context without triggering DOM operations
+      # Create context using TrackerFactory for cleaner initialization
+      trackers = Validation::TrackerFactory.create_all_trackers(nil)
+
       context = ValidationContext.allocate
       context.instance_variable_set(:@document, nil)
       context.instance_variable_set(:@profile, @profile)
-      context.instance_variable_set(:@error_tracker, Validation::ErrorTracker.new)
-      context.instance_variable_set(:@fixes, [])
-      context.instance_variable_set(:@data, {})
-      # Create NodeIdManager without a document (SAX mode)
-      node_id_manager = Validation::NodeIdManager.new(nil)
-      context.instance_variable_set(:@node_id_manager, node_id_manager)
-      # Create StructuralInvalidityTracker with a node ID generator
+      context.instance_variable_set(:@error_tracker, trackers[:error_tracker])
+      context.instance_variable_set(:@node_id_manager,
+                                    trackers[:node_id_manager])
       context.instance_variable_set(:@structural_invalidity_tracker,
-                                    Validation::StructuralInvalidityTracker.new(
-                                      node_id_generator: ->(node) {
-                                        node_id_manager.generate_node_id(node)
-                                      },
-                                    ))
+                                    trackers[:structural_invalidity_tracker])
       context.instance_variable_set(:@reference_manifest,
-                                    References::ReferenceManifest.new(source_document: nil))
+                                    trackers[:reference_manifest])
+      context.instance_variable_set(:@fixes, [])
+      context.instance_variable_set(:@data, {})
       context
     end
 
+    # Classify requirements based on validation needs (with caching)
+    def classify_requirements_with_cache
+      profile_key = @profile.class.name
+      profile_requirements = @profile.requirements
+
+      # Check cache first (thread-safe)
+      @immediate_requirements = []
+      @deferred_requirements = []
+
+      classified = self.class.classification_cache_mutex.synchronize do
+        self.class.classification_cache[profile_key]
+      end
+
+      if classified
+        @immediate_requirements = classified[:immediate].map do |req_class|
+          # Find the actual instance from profile requirements
+          profile_requirements.find { |r| r.is_a?(req_class) }
+        end.compact
+        @deferred_requirements = classified[:deferred].map do |req_class|
+          profile_requirements.find { |r| r.is_a?(req_class) }
+        end.compact
+      else
+        # Classify and cache
+        immediate_classes = []
+        deferred_classes = []
+
+        profile_requirements.each do |req|
+          if req.respond_to?(:needs_deferred_validation?) && req.needs_deferred_validation?
+            deferred_classes << req.class
+          else
+            immediate_classes << req.class
+          end
+        end
+
+        # Store in cache
+        self.class.classification_cache_mutex.synchronize do
+          self.class.classification_cache[profile_key] = {
+            immediate: immediate_classes,
+            deferred: deferred_classes,
+          }
+        end
+
+        @immediate_requirements = profile_requirements.select do |req|
+          immediate_classes.include?(req.class)
+        end
+        @deferred_requirements = profile_requirements.select do |req|
+          deferred_classes.include?(req.class)
+        end
+      end
+
+      [@immediate_requirements, @deferred_requirements]
+    end
+
     # Classify requirements based on validation needs
     def classify_requirements
       return unless @profile&.requirements

data/lib/svg_conform/validation/tracker_factory.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "../references"
+require_relative "error_tracker"
+require_relative "structural_invalidity_tracker"
+require_relative "node_id_manager"
+
+module SvgConform
+  module Validation
+    # Factory for creating tracker objects used in ValidationContext
+    # Centralizes tracker object creation for cleaner initialization
+    module TrackerFactory
+      # Create a new ErrorTracker instance
+      def self.create_error_tracker
+        ErrorTracker.new
+      end
+
+      # Create a new NodeIdManager instance
+      # @param document [Document, nil] The document (nil for SAX mode)
+      def self.create_node_id_manager(document)
+        NodeIdManager.new(document)
+      end
+
+      # Create a new StructuralInvalidityTracker instance
+      # @param node_id_generator [Proc] Callable that generates node IDs
+      def self.create_structural_invalidity_tracker(node_id_generator:)
+        StructuralInvalidityTracker.new(node_id_generator: node_id_generator)
+      end
+
+      # Create a new ReferenceManifest instance
+      # @param source_document [String, nil] Optional source document path
+      def self.create_reference_manifest(source_document: nil)
+        References::ReferenceManifest.new(source_document: source_document)
+      end
+
+      # Create all trackers for a ValidationContext
+      # @param document [Document, nil] The document (nil for SAX mode)
+      # @return [Hash] Hash of tracker instances
+      def self.create_all_trackers(document)
+        node_id_manager = create_node_id_manager(document)
+
+        {
+          error_tracker: create_error_tracker,
+          node_id_manager: node_id_manager,
+          structural_invalidity_tracker: create_structural_invalidity_tracker(
+            node_id_generator: ->(node) {
+              node_id_manager.generate_node_id(node)
+            },
+          ),
+          reference_manifest: create_reference_manifest(source_document: document&.file_path),
+        }
+      end
+    end
+  end
+end

data/lib/svg_conform/validation_context.rb

@@ -7,6 +7,7 @@ require_relative "errors/validation_notice"
 require_relative "validation/error_tracker"
 require_relative "validation/structural_invalidity_tracker"
 require_relative "validation/node_id_manager"
+require_relative "validation/tracker_factory"
 
 module SvgConform
   # Context object passed to requirements during validation
@@ -91,16 +92,16 @@ module SvgConform
     def initialize(document, profile)
       @document = document
       @profile = profile
-      @error_tracker = Validation::ErrorTracker.new
+
+      # Use TrackerFactory to create all tracker instances
+      trackers = Validation::TrackerFactory.create_all_trackers(document)
+      @error_tracker = trackers[:error_tracker]
+      @node_id_manager = trackers[:node_id_manager]
+      @structural_invalidity_tracker = trackers[:structural_invalidity_tracker]
+      @reference_manifest = trackers[:reference_manifest]
+
       @fixes = []
       @data = {}
-      @node_id_manager = Validation::NodeIdManager.new(document)
-      @structural_invalidity_tracker = Validation::StructuralInvalidityTracker.new(
-        node_id_generator: ->(node) { @node_id_manager.generate_node_id(node) },
-      )
-      @reference_manifest = References::ReferenceManifest.new(
-        source_document: document&.file_path,
-      )
     end
 
     # Mark a node as structurally invalid (e.g., invalid parent-child relationship)

data/lib/svg_conform/validator.rb

@@ -64,13 +64,19 @@ module SvgConform
       result
     end
 
-    # Validate multiple files
+    # Validate multiple files efficiently
+    # Loads profile once and reuses across all validations for better performance
     def validate_files(file_paths, profile: :svg_1_2_rfc, **options)
+      merged_options = @options.merge(options)
+
+      # Load profile once to amortize cost across all validations
+      profile_obj = resolve_profile(profile)
+
       results = {}
 
       file_paths.each do |file_path|
         results[file_path] =
-          validate_file(file_path, profile: profile, **options)
+          validate_file_with_profile(file_path, profile_obj, **merged_options)
       rescue StandardError => e
         results[file_path] = create_error_result(file_path, e)
       end
@@ -144,27 +150,42 @@ module SvgConform
 
     def validate_file_sax(file_path, profile:, **options)
       profile_obj = resolve_profile(profile)
-      sax_doc = SvgConform::SaxDocument.from_file(file_path)
-      result = sax_doc.validate_with_profile(profile_obj)
+      validate_file_with_profile(file_path, profile_obj, **options)
+    end
 
-      # If fixing is requested, load DOM and apply remediations directly
-      # Skip re-validation to avoid DOM performance penalty
-      if options[:fix] && result.has_errors?
-        dom_doc = SvgConform::Document.from_file(file_path)
+    # Validate file using pre-loaded profile object
+    # Used internally by validate_files for efficient batch processing
+    def validate_file_with_profile(file_path, profile_obj, **options)
+      unless File.exist?(file_path)
+        raise ValidationError,
+              "File not found: #{file_path}"
+      end
 
-        # Apply remediations directly without re-validating
-        changes = profile_obj.apply_remediations(dom_doc)
+      mode = determine_mode(file_path, options[:mode])
 
-        # Write fixed output if specified
-        if options[:fix_output] && changes.any?
-          File.write(options[:fix_output], dom_doc.to_xml)
+      case mode
+      when :sax
+        sax_doc = SvgConform::SaxDocument.from_file(file_path)
+        result = sax_doc.validate_with_profile(profile_obj)
+
+        # If fixing is requested, load DOM and apply remediations directly
+        if options[:fix] && result.has_errors?
+          dom_doc = SvgConform::Document.from_file(file_path)
+          changes = profile_obj.apply_remediations(dom_doc)
+
+          # Write fixed output if specified
+          if options[:fix_output] && changes.any?
+            File.write(options[:fix_output], dom_doc.to_xml)
+          end
         end
 
-        # Return original SAX validation result (errors already detected)
-        # Note: We don't re-validate to avoid DOM performance cost
+        result
+      when :dom
+        document = SvgConform::Document.from_file(file_path)
+        profile_obj.validate(document).tap do |result|
+          result.apply_fixes if options[:fix] && result.fixable?
+        end
       end
-
-      result
     end
 
     def validate_file_dom(file_path, profile:, **options)

data/lib/svg_conform/version.rb

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

data/spec/spec_helper.rb

@@ -16,4 +16,27 @@ RSpec.configure do |config|
   config.expect_with :rspec do |c|
     c.syntax = :expect
   end
+
+  # Clear class-level caches before each test to prevent pollution
+  config.before do
+    # Clear AllowedElementsRequirement configuration cache
+    if defined?(SvgConform::Requirements::AllowedElementsRequirement)
+      SvgConform::Requirements::AllowedElementsRequirement.configuration_validation_cache.clear
+    end
+
+    # Clear SaxValidationHandler classification cache
+    if defined?(SvgConform::SaxValidationHandler)
+      SvgConform::SaxValidationHandler.classification_cache.clear
+    end
+
+    # Clear ProfileCompiler compile cache
+    if defined?(SvgConform::ProfileCompiler)
+      SvgConform::ProfileCompiler.compile_cache.clear
+    end
+
+    # Clear Profiles module cache
+    if defined?(SvgConform::Profiles)
+      SvgConform::Profiles.clear_cache!
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: svg_conform
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.10
 platform: ruby
 authors:
 - Ribose
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-22 00:00:00.000000000 Z
+date: 2026-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -91,6 +91,7 @@ files:
 - Gemfile
 - README.adoc
 - Rakefile
+- benchmark/performance_comparison.rb
 - config/profiles/base.yml
 - config/profiles/lucid_fix.yml
 - config/profiles/metanorma.yml
@@ -100,6 +101,7 @@ files:
 - config/svgcheck_mapping.yml
 - docs/api_reference.adoc
 - docs/cli_guide.adoc
+- docs/performance.adoc
 - docs/profiles.adoc
 - docs/rdf_metadata_support.adoc
 - docs/reference_manifest.adoc
@@ -152,6 +154,7 @@ files:
 - lib/svg_conform/node_helpers.rb
 - lib/svg_conform/node_index_builder.rb
 - lib/svg_conform/profile.rb
+- lib/svg_conform/profile_compiler.rb
 - lib/svg_conform/profiles.rb
 - lib/svg_conform/references.rb
 - lib/svg_conform/references/base_reference.rb
@@ -199,6 +202,7 @@ files:
 - lib/svg_conform/validation/error_tracker.rb
 - lib/svg_conform/validation/node_id_manager.rb
 - lib/svg_conform/validation/structural_invalidity_tracker.rb
+- lib/svg_conform/validation/tracker_factory.rb
 - lib/svg_conform/validation_context.rb
 - lib/svg_conform/validation_issue.rb
 - lib/svg_conform/validation_result.rb