PERF: Build the MediaWiki inline tag registry only once

Every Parser#parse call created an InlineParser without handlers,
which built a full InlineTagRegistry.default — 10 registrations plus
Entry objects, ~30 objects per parse. Same pattern and fix as the
BBCode registries: a shared, deep-frozen instance built once per
process, used only by the no-customization path. Entries are immutable
Data objects, so sharing is safe across parsers and threads.

Also mirrors two smaller BBCode-parser optimizations: registry lookups
fetch directly instead of allocating a downcased key per probe, and
normalize_line_endings skips the gsub copy when the input is already
LF-only. Both fast paths are output-equivalent to their slow paths, so
their subjects join the existing mutant ignore entries.

Corpus bench: mw_parse 35 → 32 µs/post ASCII, mw_fresh 55 → 50;
mw_parse allocations 211 → 167 objects/post.

Author: gschlager

lib/markbridge/parsers/media_wiki/inline_parser.rb

@@ -43,7 +43,7 @@ class InlineParser
         attr_reader :unknown_tags
 
         def initialize(handlers: nil, depth: 0, unknown_tags: nil)
-          @registry = handlers || InlineTagRegistry.default
+          @registry = handlers || InlineTagRegistry.shared_default
           @depth = depth
           @unknown_tags = unknown_tags || Hash.new(0)
         end

lib/markbridge/parsers/media_wiki/inline_tag_registry.rb

@@ -44,7 +44,11 @@ def register(tag_name, type, element_class)
         # @param tag_name [String]
         # @return [Entry, nil]
         def [](tag_name)
-          @entries[tag_name.downcase]
+          # Keys are always downcased and the inline parser downcases tag
+          # names before lookup, so the fetch hits directly on the hot
+          # path; the block normalizes only mixed-case lookups instead of
+          # allocating a downcased copy per probe.
+          @entries.fetch(tag_name) { @entries[tag_name.downcase] }
         end
 
         # Check if a tag name is registered.
@@ -88,6 +92,25 @@ def self.build_from_default
           registry
         end
 
+        # Shared, deep-frozen default registry for the no-customization
+        # fast path. Built once per process; {InlineParser} falls back to
+        # it when no +handlers:+ are given, skipping the full registry
+        # construction on every parse. Entries are immutable Data objects,
+        # so sharing is safe across parsers and threads.
+        #
+        # @return [InlineTagRegistry] the same frozen instance on every call
+        def self.shared_default
+          @shared_default ||= default.freeze
+        end
+
+        # Freeze the registry together with its internal Hash so that
+        # registration on a shared instance fails loudly instead of
+        # silently mutating state visible to every parser.
+        def freeze
+          @entries.freeze
+          super
+        end
+
         private
 
         VALID_TYPES = %i[raw formatting self_closing].freeze

lib/markbridge/parsers/media_wiki/parser.rb

@@ -56,12 +56,15 @@ def parse(input)
 
         private
 
+        LINE_ENDING_RE = /\r\n?|[\u2028\u2029]+/
+        private_constant :LINE_ENDING_RE
+
         # Normalize line endings (CR, CRLF, and Unicode separators).
         #
         # @param input [String]
-        # @return [String]
+        # @return [String] the input itself when already normalized (LF-only)
         def normalize_line_endings(input)
-          input.gsub(/\r\n?|[\u2028\u2029]+/, "\n")
+          input.match?(LINE_ENDING_RE) ? input.gsub(LINE_ENDING_RE, "\n") : input
         end
 
         # Process all lines of input.

mutant.yml

@@ -48,7 +48,11 @@ matcher:
     # differ in per-token allocations. The fetch exists purely to skip
     # the `to_s.downcase` copy on the hot path; no test can observe
     # the difference through the public API. Bucket A.
+    # MediaWiki::InlineTagRegistry#[] has the identical fetch-with-
+    # downcasing-fallback shape (the inline parser downcases tag names
+    # before lookup) and the same equivalence.
     - Markbridge::Parsers::BBCode::HandlerRegistry#[]
+    - Markbridge::Parsers::MediaWiki::InlineTagRegistry#[]
 
     # HandlerRegistry#freeze deep-freezes three internal collections.
     # `register` writes @handlers first and raises FrozenError there,
@@ -66,8 +70,10 @@ matcher:
     # `if LINE_ENDING_RE`, conditional drop) return an equal string
     # that differs only in object identity, which parse() never
     # exposes. Bucket A — the guard exists purely to avoid a
-    # full-document copy per post.
+    # full-document copy per post. Same guard, same equivalence in the
+    # MediaWiki parser.
     - Markbridge::Parsers::BBCode::Parser#normalize_line_endings
+    - Markbridge::Parsers::MediaWiki::Parser#normalize_line_endings
 
     # RenderingInterface#apply_markers' EDGE_WHITESPACE fast path.
     # The capture-group sub handles flush content identically (its

spec/unit/markbridge/parsers/media_wiki/inline_tag_registry_spec.rb

@@ -179,4 +179,38 @@
       expect(registry["code"].element_class).to eq(Markbridge::AST::Bold)
     end
   end
+
+  describe ".shared_default" do
+    it "returns the same instance on every call" do
+      expect(described_class.shared_default).to be(described_class.shared_default)
+    end
+
+    it "is frozen" do
+      expect(described_class.shared_default).to be_frozen
+    end
+
+    it "resolves the default tags" do
+      expect(described_class.shared_default["code"].element_class).to eq(Markbridge::AST::Code)
+    end
+
+    it "is a different instance from .default" do
+      expect(described_class.shared_default).not_to be(described_class.default)
+    end
+  end
+
+  describe "#freeze" do
+    it "makes register raise instead of silently mutating shared state" do
+      frozen = described_class.new.freeze
+
+      expect { frozen.register("mark", :formatting, Markbridge::AST::Bold) }.to raise_error(
+        FrozenError,
+      )
+    end
+
+    it "returns self" do
+      registry = described_class.new
+
+      expect(registry.freeze).to be(registry)
+    end
+  end
 end