markbridge 0.2.0 → 0.3.0

data/lib/markbridge/parsers/html/parser.rb

@@ -22,7 +22,7 @@ module Markbridge
             if block_given?
               HandlerRegistry.build_from_default(&block)
             else
-              handlers || HandlerRegistry.default
+              handlers || HandlerRegistry.shared_default
             end
           @unknown_tags = Hash.new(0)
         end
@@ -64,6 +64,12 @@ module Markbridge
           # Create root AST document
           document = AST::Document.new
 
+          # Whitespace preservation is tracked during descent instead of
+          # walking node.ancestors per text node; seed the counter from
+          # the parse root's real ancestry so pre-parsed subtrees inside
+          # a <pre> keep their semantics.
+          @preserve_depth = initial_preserve_depth(doc)
+
           # Process all nodes
           children.each { |node| process_node(node, document) }
           trim_trailing_whitespace(document)
@@ -92,16 +98,29 @@ module Markbridge
           end
         end
 
+        # Anything WHITESPACE_RUN would actually change: a non-space
+        # whitespace character, or two-plus consecutive spaces. Prose with
+        # only single spaces passes through without the gsub copy.
+        COLLAPSIBLE_WHITESPACE = /[\t\r\n\f]| {2}/
+        private_constant :COLLAPSIBLE_WHITESPACE
+
+        # Anything String#rstrip would remove from the end (ASCII
+        # whitespace or NUL), or the empty string.
+        TRAILING_STRIPPABLE = /[\0\t\n\v\f\r ]\z|\A\z/
+        private_constant :TRAILING_STRIPPABLE
+
         # Process a text node
         # @param node [Nokogiri::XML::Text]
         # @param parent [AST::Element]
         def process_text_node(node, parent)
-          if preserves_whitespace?(node)
-            parent << AST::Text.new(node.text)
+          text = node.text
+
+          if @preserve_depth.positive?
+            parent << AST::Text.new(text)
             return
           end
 
-          text = node.text.gsub(WHITESPACE_RUN, " ")
+          text = text.gsub(WHITESPACE_RUN, " ") if text.match?(COLLAPSIBLE_WHITESPACE)
           # Drop leading whitespace at the start of an element's content,
           # matching the browser rule that whitespace at the beginning of a
           # block (or before any inline content) is collapsed away.
@@ -125,6 +144,21 @@ module Markbridge
           # still collapse the whitespace before them.
           trim_trailing_whitespace(parent) if @handlers.block_level_tags.include?(tag_name)
 
+          preserving = @handlers.whitespace_preserving_tags.include?(tag_name)
+          @preserve_depth += 1 if preserving
+
+          dispatch_element(node, tag_name, parent, preserving)
+
+          @preserve_depth -= 1 if preserving
+        end
+
+        # Dispatch an element to its handler (or the unknown-tag path) and
+        # process its children.
+        # @param node [Nokogiri::XML::Element]
+        # @param tag_name [String]
+        # @param parent [AST::Element]
+        # @param preserving [Boolean] whether this tag preserves whitespace
+        def dispatch_element(node, tag_name, parent, preserving)
           handler = @handlers[tag_name]
           return handle_unknown_tag(node, parent) unless handler
 
@@ -134,9 +168,7 @@ module Markbridge
           return unless ast_element
 
           process_children(node, ast_element)
-          unless @handlers.whitespace_preserving_tags.include?(tag_name)
-            trim_trailing_whitespace(ast_element)
-          end
+          trim_trailing_whitespace(ast_element) unless preserving
         end
 
         # Handle unknown tag by tracking it and ignoring the wrapper
@@ -148,12 +180,16 @@ module Markbridge
           process_children(node, parent)
         end
 
-        # Whether `node` is inside a tag that preserves source whitespace.
-        # @param node [Nokogiri::XML::Node]
-        # @return [Boolean]
-        def preserves_whitespace?(node)
-          node.ancestors.any? do |ancestor|
-            @handlers.whitespace_preserving_tags.include?(ancestor.name)
+        # Number of whitespace-preserving elements enclosing the parse
+        # root, the root itself included. Computed once per parse; from
+        # there the counter is maintained during descent. Documents and
+        # fragments count themselves harmlessly — their #name
+        # ("document", "#document-fragment") never matches a tag set.
+        # @param root [Nokogiri::XML::Node]
+        # @return [Integer]
+        def initial_preserve_depth(root)
+          [root, *root.ancestors].count do |node|
+            @handlers.whitespace_preserving_tags.include?(node.name)
           end
         end
 
@@ -174,6 +210,11 @@ module Markbridge
           last = element.children.last
           return unless last.instance_of?(AST::Text)
 
+          # Fast exit when there is nothing to strip: no trailing byte
+          # rstrip would remove (ASCII whitespace or NUL), and not the
+          # empty string (which the pop below drops entirely).
+          return unless last.text.match?(TRAILING_STRIPPABLE)
+
           trimmed = last.text.rstrip
           element.children.pop
           element << AST::Text.new(trimmed) unless trimmed.empty?

data/lib/markbridge/parsers/media_wiki/inline_parser.rb

@@ -7,6 +7,14 @@ module Markbridge
       # Handles bold ('''), italic (''), links ([[...]]), external links ([...]),
       # and HTML inline tags via an InlineTagRegistry.
       #
+      # The parser works in *byte* offsets (byteindex/byteslice/getbyte):
+      # character indices are O(pos) on multibyte input in CRuby, and
+      # per-character probes allocate a String each. The main loop jumps
+      # between interesting bytes with a single regex search and copies
+      # the skipped span in one slice. Invariant: +@pos+ always sits on a
+      # character boundary — jumps land on ASCII matches and advances
+      # step over ASCII bytes or whole matches.
+      #
       # @example With custom registry
       #   registry = InlineTagRegistry.build_from_default do |r|
       #     r.register("mark", :formatting, AST::Bold)
@@ -15,6 +23,19 @@ module Markbridge
       class InlineParser
         MAX_INLINE_DEPTH = 20
 
+        # Bytes the main loop reacts to: apostrophes ('), link openers ([)
+        # and HTML tag openers (<). ASCII-only, so a byteindex match always
+        # lands on a character boundary.
+        INTERESTING = /['\[<]/
+        APOSTROPHE = 39 # '
+        BRACKET_OPEN = 91 # [
+        private_constant :INTERESTING, :APOSTROPHE, :BRACKET_OPEN
+
+        # Matches an HTML-like tag at the search position (\G with
+        # byteindex anchors at the offset).
+        HTML_TAG_AT_CURSOR = %r{\G<(/?)([a-z]+)(?: [^>]*)?\s*(/?)>}i
+        private_constant :HTML_TAG_AT_CURSOR
+
         # @return [Hash{String => Integer}] tag-name → occurrence count for
         #   HTML-like inline tags whose names are not registered. Shared
         #   with nested InlineParser instances so depth-recursive parses
@@ -22,7 +43,7 @@ module Markbridge
         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
@@ -34,56 +55,66 @@ module Markbridge
         def parse(text, parent:)
           @input = text
           @pos = 0
-          @length = text.length
+          @length = text.bytesize
           @parent = parent
           @text_buffer = +""
 
-          while @pos < @length
-            char = @input[@pos]
-
-            case char
-            when "'"
-              consecutive_apostrophes_at(@pos) >= 2 ? parse_bold_italic : append_literal(char)
-            when "["
-              flush_text
-              @input[@pos + 1] == "[" ? parse_internal_link : parse_external_link
-            when "<"
-              flush_text
-              parse_html_tag
-            else
-              append_literal(char)
-            end
+          while (span_end = @input.byteindex(INTERESTING, @pos))
+            # Unconditional on purpose: when the interesting byte sits at
+            # @pos the slice is empty and both lines are no-ops.
+            @text_buffer << @input.byteslice(@pos, span_end - @pos)
+            @pos = span_end
+
+            dispatch_interesting_byte
           end
 
+          # Trailing text after the last interesting byte; appending the
+          # empty slice at end-of-input is a no-op.
+          @text_buffer << @input.byteslice(@pos, @length - @pos)
           flush_text
         end
 
         private
 
-        def append_literal(char)
-          @text_buffer << char
-          @pos += 1
+        # Precondition: the byte at +@pos+ matched INTERESTING.
+        def dispatch_interesting_byte
+          case @input.getbyte(@pos)
+          when APOSTROPHE
+            if consecutive_apostrophes_at(@pos) >= 2
+              parse_bold_italic
+            else
+              @text_buffer << "'"
+              @pos += 1
+            end
+          when BRACKET_OPEN
+            flush_text
+            @input.getbyte(@pos + 1) == BRACKET_OPEN ? parse_internal_link : parse_external_link
+          else # "<" — the only remaining INTERESTING byte
+            flush_text
+            parse_html_tag
+          end
         end
 
-        # Precondition: caller has verified @input[@pos..@pos+1] is "''".
+        # Precondition: caller has verified at least two apostrophes at @pos.
         def parse_bold_italic
-          start = @pos
           count = [consecutive_apostrophes_at(@pos), 5].min
           flush_text
           @pos += count
-          parse_apostrophe_formatting(count, start)
+          parse_apostrophe_formatting(count)
         end
 
         # Parse apostrophe-delimited formatting (bold, italic, or bold+italic).
+        # Entered with @pos just past the opening apostrophes.
         #
         # @param apostrophe_count [Integer] number of apostrophes (2, 3, or 5)
-        # @param start [Integer] position before the opening apostrophes
-        def parse_apostrophe_formatting(apostrophe_count, start)
+        def parse_apostrophe_formatting(apostrophe_count)
           content = collect_until_apostrophes(apostrophe_count)
 
           unless content
+            # @pos already sits just past the opening apostrophes
+            # (start + apostrophe_count): the caller advanced it, and
+            # collect_until_apostrophes leaves it untouched on failure.
             @text_buffer << ("'" * apostrophe_count)
-            @pos = start + apostrophe_count
             return
           end
 
@@ -124,29 +155,36 @@ module Markbridge
           ).parse(content, parent:)
         end
 
-        # Collect text until we find n consecutive apostrophes.
-        # Returns the collected content string or nil if not found.
+        # Collect text until we find n consecutive apostrophes, hopping
+        # from apostrophe run to apostrophe run instead of scanning per
+        # position. Returns the collected content string, or nil (the
+        # exhausted while loop) if no closing run exists.
         #
         # @param count [Integer] number of consecutive apostrophes to match
         # @return [String, nil]
         def collect_until_apostrophes(count)
           start = @pos
-          while @pos < @length
-            if consecutive_apostrophes_at(@pos) >= count
-              content = @input[start...@pos]
-              @pos += count
+          probe = @pos
+          while (index = @input.byteindex("'", probe))
+            run = consecutive_apostrophes_at(index)
+            if run >= count
+              content = @input.byteslice(start, index - start)
+              @pos = index + count
               return content
             end
-            @pos += 1
+            probe = index + run
           end
         end
 
         # Count consecutive apostrophes starting at position.
+        # getbyte past end-of-input returns nil, which ends the run.
         #
         # @param pos [Integer]
         # @return [Integer]
         def consecutive_apostrophes_at(pos)
-          @input[pos..].each_char.take_while { |c| c == "'" }.length
+          count = 0
+          count += 1 while @input.getbyte(pos + count) == APOSTROPHE
+          count
         end
 
         # Parse [[internal link]] or [[target|display text]].
@@ -154,14 +192,13 @@ module Markbridge
           @pos += 2 # skip [[
           start = @pos
 
-          # Find closing ]]
-          close_pos = @input.index("]]", @pos)
+          close_pos = @input.byteindex("]]", @pos)
           unless close_pos
             @text_buffer << "[["
             return
           end
 
-          content = @input[start...close_pos]
+          content = @input.byteslice(start, close_pos - start)
           @pos = close_pos + 2
 
           target, display = content.split("|", 2)
@@ -178,14 +215,13 @@ module Markbridge
           @pos += 1 # skip [
           start = @pos
 
-          # Find closing ]
-          close_pos = @input.index("]", @pos)
+          close_pos = @input.byteindex("]", @pos)
           unless close_pos
             @text_buffer << "["
             return
           end
 
-          content = @input[start...close_pos]
+          content = @input.byteslice(start, close_pos - start)
           @pos = close_pos + 1
 
           # Split on first space: URL followed by optional display text
@@ -199,13 +235,13 @@ module Markbridge
         end
 
         def parse_html_tag
-          tag_match = @input[@pos..].match(%r{\A<(/?)([a-z]+)(?: [^>]*)?\s*(/?)>}i)
-          unless tag_match
+          unless @input.byteindex(HTML_TAG_AT_CURSOR, @pos)
             @text_buffer << "<"
             @pos += 1
             return
           end
 
+          tag_match = Regexp.last_match
           full_match = tag_match[0]
           closing = !tag_match[1].empty?
           self_closing = !tag_match[3].empty?
@@ -238,7 +274,7 @@ module Markbridge
           when :formatting
             handle_paired_tag(tag_name, full_match, entry.element_class)
           when :self_closing
-            @pos += full_match.length
+            @pos += full_match.bytesize
             @parent << entry.element_class.new
           end
         end
@@ -246,17 +282,17 @@ module Markbridge
         # Advance position and buffer the match as literal text.
         def advance_as_text(full_match)
           @text_buffer << full_match
-          @pos += full_match.length
+          @pos += full_match.bytesize
         end
 
         # Handle <nowiki>...</nowiki> - preserves content as literal text.
         def handle_nowiki_tag(full_match)
-          @pos += full_match.length
-          close_pos = @input.index("</nowiki>", @pos)
+          @pos += full_match.bytesize
+          close_pos = @input.byteindex("</nowiki>", @pos)
 
           if close_pos
-            @text_buffer << @input[@pos...close_pos]
-            @pos = close_pos + "</nowiki>".length
+            @text_buffer << @input.byteslice(@pos, close_pos - @pos)
+            @pos = close_pos + "</nowiki>".bytesize
           else
             @text_buffer << full_match
           end
@@ -265,15 +301,15 @@ module Markbridge
         # Handle paired raw tags like <code>...</code> and <pre>...</pre>.
         # Content inside is not parsed for wiki markup.
         def handle_paired_raw_tag(tag_name, full_match, element_class)
-          @pos += full_match.length
+          @pos += full_match.bytesize
           close_tag = "</#{tag_name}>"
-          close_pos = @input.index(close_tag, @pos)
+          close_pos = @input.byteindex(close_tag, @pos)
 
           if close_pos
             element = element_class.new
-            element << AST::Text.new(@input[@pos...close_pos])
+            element << AST::Text.new(@input.byteslice(@pos, close_pos - @pos))
             @parent << element
-            @pos = close_pos + close_tag.length
+            @pos = close_pos + close_tag.bytesize
           else
             @text_buffer << full_match
           end
@@ -282,26 +318,28 @@ module Markbridge
         # Handle paired formatting tags like <s>, <u>, <sup>, <sub>.
         # Content inside IS parsed for wiki markup.
         def handle_paired_tag(tag_name, full_match, element_class)
-          @pos += full_match.length
+          @pos += full_match.bytesize
           close_tag = "</#{tag_name}>"
-          close_pos = @input.index(close_tag, @pos)
+          close_pos = @input.byteindex(close_tag, @pos)
 
           if close_pos
             element = element_class.new
-            parse_inner_content(@input[@pos...close_pos], parent: element)
+            parse_inner_content(@input.byteslice(@pos, close_pos - @pos), parent: element)
             @parent << element
-            @pos = close_pos + close_tag.length
+            @pos = close_pos + close_tag.bytesize
           else
             @text_buffer << full_match
           end
         end
 
         # Flush accumulated text buffer to the parent as a Text node.
+        # AST::Text copies the (mutable) buffer, so clearing it afterwards
+        # reuses the allocated capacity for the next span.
         def flush_text
           return if @text_buffer.empty?
 
           @parent << AST::Text.new(@text_buffer)
-          @text_buffer = +""
+          @text_buffer.clear
         end
       end
     end

data/lib/markbridge/parsers/media_wiki/inline_tag_registry.rb

@@ -44,7 +44,11 @@ module Markbridge
         # @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 @@ module Markbridge
           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

data/lib/markbridge/parsers/media_wiki/parser.rb

@@ -56,12 +56,15 @@ module Markbridge
 
         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.

data/lib/markbridge/parsers/text_formatter/handler_registry.rb

@@ -32,6 +32,25 @@ module Markbridge
           default.tap { |registry| yield registry if block_given? }
         end
 
+        # Shared, deep-frozen default registry for the no-customization
+        # fast path. Built once per process; {Parser} falls back to it
+        # when no +handlers:+ are given, skipping the full registry
+        # construction on every parse. Handlers are stateless after
+        # construction, so sharing is safe across parsers and threads.
+        #
+        # @return [HandlerRegistry] 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
+          @mappings.freeze
+          super
+        end
+
         def initialize
           @mappings = {}
         end
@@ -47,7 +66,10 @@ module Markbridge
         # @param element_name [String]
         # @return [#process, nil]
         def [](element_name)
-          @mappings[element_name.upcase]
+          # Keys are always upcased and s9e/TextFormatter stores its tag
+          # names in uppercase, so the fetch hits directly on the hot
+          # path; the block normalizes only unusual lookups.
+          @mappings.fetch(element_name) { @mappings[element_name.upcase] }
         end
 
         # Replace the handler bound to one or more element names by

data/lib/markbridge/parsers/text_formatter/handlers/quote_handler.rb

@@ -5,6 +5,20 @@ module Markbridge
     module TextFormatter
       module Handlers
         # Handler for QUOTE elements in s9e/TextFormatter XML
+        #
+        # Maps phpBB-style attribution attributes: +post_id+ and
+        # +user_id+ are database ids and land in {AST::Quote#post_id} /
+        # {AST::Quote#user_id} — deliberately not in
+        # {AST::Quote#post_number}, which carries Discourse post-number
+        # semantics that s9e exports don't provide.
+        #
+        # A bare +topic+ attribute feeds {AST::Quote#topic_id} (a topic
+        # reference is an id in every dialect we know). A bare +post+
+        # attribute is deliberately NOT mapped: without knowing the
+        # exporting platform it is undecidable whether it holds a post
+        # id or a post number, and guessing wrong produces attributions
+        # that link the wrong post. Register a custom handler when your
+        # export carries one and you know its semantics.
         class QuoteHandler < BaseHandler
           def initialize
             @element_class = AST::Quote
@@ -15,9 +29,10 @@ module Markbridge
             node =
               AST::Quote.new(
                 author: attrs[:author],
-                post: attrs[:post_id] || attrs[:post],
-                topic: attrs[:topic_id] || attrs[:topic],
+                post_id: integer_or_nil(attrs[:post_id]),
+                topic_id: integer_or_nil(attrs[:topic_id] || attrs[:topic]),
                 username: attrs[:username],
+                user_id: integer_or_nil(attrs[:user_id]),
               )
             parent << node
 
@@ -26,6 +41,20 @@ module Markbridge
           end
 
           attr_reader :element_class
+
+          private
+
+          # Coerce an attribute value to Integer; nil and non-numeric
+          # values (which would make a useless attribution anyway)
+          # become nil. Base 10 is explicit so leading zeros ("099")
+          # don't trip Integer()'s octal mode and prefix forms ("0x1A")
+          # don't smuggle in surprise values. The result is an unbounded
+          # Ruby Integer — a runaway digit string parses to a bignum,
+          # so consumers binding these into fixed-width storage (int64
+          # columns) need their own bounds check.
+          def integer_or_nil(value)
+            Integer(value, 10, exception: false)
+          end
         end
       end
     end

data/lib/markbridge/parsers/text_formatter/parser.rb

@@ -33,7 +33,7 @@ module Markbridge
             if block_given?
               HandlerRegistry.build_from_default(&block)
             else
-              handlers || HandlerRegistry.default
+              handlers || HandlerRegistry.shared_default
             end
           @unknown_tags = Hash.new(0)
         end
@@ -75,6 +75,13 @@ module Markbridge
           AST::Document.new << AST::Text.new(input)
         end
 
+        # <s>/<e> hold the original BBCode markup for unparsing; <t>/<r>
+        # are the plain-text/rich-text roots. Frozen constants — the
+        # membership checks run once per element node.
+        MARKUP_PRESERVATION_TAGS = %w[s e].freeze
+        ROOT_TAGS = %w[t r].freeze
+        private_constant :MARKUP_PRESERVATION_TAGS, :ROOT_TAGS
+
         # Process children of an XML element (public for handler access)
         # @param element [Nokogiri::XML::Element]
         # @param ast_parent [AST::Element]
@@ -102,10 +109,10 @@ module Markbridge
           tag_name = element.name
 
           # Skip markup preservation elements and their content (used for unparsing)
-          return if %w[s e].include?(tag_name)
+          return if MARKUP_PRESERVATION_TAGS.include?(tag_name)
 
           # Handle root nodes
-          return process_children(element, ast_parent) if %w[t r].include?(tag_name)
+          return process_children(element, ast_parent) if ROOT_TAGS.include?(tag_name)
 
           # Handle line breaks
           if tag_name == "br"

data/lib/markbridge/renderers/discourse/markdown_escaper.rb

@@ -178,6 +178,12 @@ module Markbridge
         end
 
         def escape_text(text)
+          # Single-line fast path (the common case for inline text nodes):
+          # skip the split and its Array + line-String allocations. A lone
+          # `\r` without `\n` stays on the line either way — `/\r?\n/`
+          # needs the `\n` — so `include?("\n")` alone decides correctly.
+          return escape_line(text, false) unless text.include?("\n")
+
           # On CRLF input, consume `\r` as part of the line terminator instead
           # of leaving it on the line. A trailing `\r` breaks line-end anchored
           # regexes (e.g. SETEXT_UNDERLINE_*) and the `ws_end >= line_length`
@@ -186,7 +192,6 @@ module Markbridge
           # LF-only fast path on a string split (regex split is ~20% slower
           # on the indented-code hot path).
           lines = text.include?("\r") ? text.split(/\r?\n/, -1) : text.split("\n", -1)
-          return escape_line(lines[0], false) if lines.size == 1
 
           # Pre-allocate result buffer
           bytesize = text.bytesize
@@ -231,6 +236,12 @@ module Markbridge
             result = String.new(encoding: line.encoding)
             result << line[0, indent_len] << escaped
             result
+          elsif escaped.equal?(line)
+            # Nothing needed escaping, so `escaped` IS the input line: its
+            # encoding is already right, and since escape_text's
+            # single-line fast path that input can be the caller's own
+            # (possibly frozen) string — force_encoding would raise.
+            line
           else
             escaped.force_encoding(line.encoding)
           end