markbridge 0.1.0 → 0.1.2

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

@@ -5,8 +5,21 @@ module Markbridge
     module MediaWiki
       # Parses inline MediaWiki markup within a line of text.
       # Handles bold ('''), italic (''), links ([[...]]), external links ([...]),
-      # and HTML inline tags (<code>, <nowiki>, <s>, <del>, <u>, <ins>, <sup>, <sub>, <br>).
+      # and HTML inline tags via an InlineTagRegistry.
+      #
+      # @example With custom registry
+      #   registry = InlineTagRegistry.build_from_default do |r|
+      #     r.register("mark", :formatting, AST::Bold)
+      #   end
+      #   parser = InlineParser.new(inline_tag_registry: registry)
       class InlineParser
+        MAX_INLINE_DEPTH = 20
+
+        def initialize(inline_tag_registry: nil, depth: 0)
+          @registry = inline_tag_registry || InlineTagRegistry.default
+          @depth = depth
+        end
+
         # Parse inline markup and append resulting AST nodes to the parent element.
         #
         # @param text [String] the text to parse for inline markup
@@ -19,20 +32,19 @@ module Markbridge
           @text_buffer = +""
 
           while @pos < @length
-            if @input[@pos] == "'" && @pos + 1 < @length && @input[@pos + 1] == "'"
-              parse_bold_italic
-            elsif @input[@pos] == "[" && @pos + 1 < @length && @input[@pos + 1] == "["
-              flush_text
-              parse_internal_link
-            elsif @input[@pos] == "[" && !(@pos + 1 < @length && @input[@pos + 1] == "[")
+            char = @input[@pos]
+
+            case char
+            when "'"
+              consecutive_apostrophes_at(@pos) >= 2 ? parse_bold_italic : append_literal(char)
+            when "["
               flush_text
-              parse_external_link
-            elsif @input[@pos] == "<"
+              @input[@pos + 1] == "[" ? parse_internal_link : parse_external_link
+            when "<"
               flush_text
               parse_html_tag
             else
-              @text_buffer << @input[@pos]
-              @pos += 1
+              append_literal(char)
             end
           end
 
@@ -41,77 +53,67 @@ module Markbridge
 
         private
 
-        # Count consecutive apostrophes and dispatch to bold/italic parsing.
+        def append_literal(char)
+          @text_buffer << char
+          @pos += 1
+        end
+
+        # Precondition: caller has verified @input[@pos..@pos+1] is "''".
         def parse_bold_italic
           start = @pos
-          count = 0
-          count += 1 while @pos + count < @length && @input[@pos + count] == "'"
-          count = 5 if count > 5
-
-          if count >= 5
-            flush_text
-            @pos += 5
-            parse_bold_italic_combo(start)
-          elsif count >= 3
-            flush_text
-            @pos += 3
-            parse_bold_content(start)
-          elsif count >= 2
-            flush_text
-            @pos += 2
-            parse_italic_content(start)
-          else
-            @text_buffer << @input[@pos]
-            @pos += 1
-          end
+          count = [consecutive_apostrophes_at(@pos), 5].min
+          flush_text
+          @pos += count
+          parse_apostrophe_formatting(count, start)
         end
 
-        # Parse '''''bold italic''''' content.
-        def parse_bold_italic_combo(start)
-          bold = AST::Bold.new
-          italic = AST::Italic.new
-          content = collect_until_apostrophes(5)
-
-          if content
-            inner_parser = InlineParser.new
-            inner_parser.parse(content, parent: italic)
-            bold << italic
-            @parent << bold
-          else
-            # No closing found - treat as literal text
-            @text_buffer << "'''''"
-            @pos = start + 5
+        # Parse apostrophe-delimited formatting (bold, italic, or bold+italic).
+        #
+        # @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)
+          content = collect_until_apostrophes(apostrophe_count)
+
+          unless content
+            @text_buffer << ("'" * apostrophe_count)
+            @pos = start + apostrophe_count
+            return
           end
-        end
 
-        # Parse '''bold''' content.
-        def parse_bold_content(start)
-          bold = AST::Bold.new
-          content = collect_until_apostrophes(3)
+          element = build_formatting_element(apostrophe_count)
+          parse_inner_content(content, parent: innermost_element(element))
+          @parent << element
+        end
 
-          if content
-            inner_parser = InlineParser.new
-            inner_parser.parse(content, parent: bold)
-            @parent << bold
-          else
-            @text_buffer << "'''"
-            @pos = start + 3
+        # Build the AST element(s) for the given apostrophe count.
+        def build_formatting_element(apostrophe_count)
+          case apostrophe_count
+          when 5
+            AST::Bold.new << AST::Italic.new
+          when 3
+            AST::Bold.new
+          when 2
+            AST::Italic.new
           end
         end
 
-        # Parse ''italic'' content.
-        def parse_italic_content(start)
-          italic = AST::Italic.new
-          content = collect_until_apostrophes(2)
+        # Return the innermost element to receive parsed content.
+        def innermost_element(element)
+          element.children.empty? ? element : element.children.last
+        end
 
-          if content
-            inner_parser = InlineParser.new
-            inner_parser.parse(content, parent: italic)
-            @parent << italic
-          else
-            @text_buffer << "''"
-            @pos = start + 2
+        # Parse inner content and append to a parent element.
+        # Respects MAX_INLINE_DEPTH to prevent stack overflow from deeply nested markup.
+        def parse_inner_content(content, parent:)
+          if @depth + 1 >= MAX_INLINE_DEPTH
+            parent << AST::Text.new(content)
+            return
           end
+
+          InlineParser.new(inline_tag_registry: @registry, depth: @depth + 1).parse(
+            content,
+            parent:,
+          )
         end
 
         # Collect text until we find n consecutive apostrophes.
@@ -122,14 +124,13 @@ module Markbridge
         def collect_until_apostrophes(count)
           start = @pos
           while @pos < @length
-            if @input[@pos] == "'" && consecutive_apostrophes_at(@pos) >= count
+            if consecutive_apostrophes_at(@pos) >= count
               content = @input[start...@pos]
               @pos += count
               return content
             end
             @pos += 1
           end
-          nil
         end
 
         # Count consecutive apostrophes starting at position.
@@ -137,9 +138,7 @@ module Markbridge
         # @param pos [Integer]
         # @return [Integer]
         def consecutive_apostrophes_at(pos)
-          count = 0
-          count += 1 while pos + count < @length && @input[pos + count] == "'"
-          count
+          @input[pos..].each_char.take_while { |c| c == "'" }.length
         end
 
         # Parse [[internal link]] or [[target|display text]].
@@ -191,7 +190,6 @@ module Markbridge
           @parent << url
         end
 
-        # Parse an HTML tag (<code>, <nowiki>, <pre>, <br>, <s>, <del>, <u>, <ins>, <sup>, <sub>).
         def parse_html_tag
           tag_match = @input[@pos..].match(%r{\A<(/?)([a-z]+)(?: [^>]*)?\s*(/?)>}i)
           unless tag_match
@@ -200,75 +198,67 @@ module Markbridge
             return
           end
 
+          full_match = tag_match[0]
           closing = !tag_match[1].empty?
-          tag_name = tag_match[2].downcase
           self_closing = !tag_match[3].empty?
-          full_match = tag_match[0]
+          tag_name = tag_match[2].downcase
 
-          case tag_name
-          when "nowiki"
-            handle_nowiki_tag(closing, full_match)
-          when "code"
-            handle_paired_raw_tag(tag_name, closing, full_match, AST::Code)
-          when "pre"
-            handle_paired_raw_tag(tag_name, closing, full_match, AST::Code)
-          when "br"
-            @pos += full_match.length
-            @parent << AST::LineBreak.new
-          when "s", "del"
-            handle_paired_tag(tag_name, closing, self_closing, full_match, AST::Strikethrough)
-          when "u", "ins"
-            handle_paired_tag(tag_name, closing, self_closing, full_match, AST::Underline)
-          when "sup"
-            handle_paired_tag(tag_name, closing, self_closing, full_match, AST::Superscript)
-          when "sub"
-            handle_paired_tag(tag_name, closing, self_closing, full_match, AST::Subscript)
-          else
-            # Unknown HTML tag - treat as text
-            @text_buffer << full_match
-            @pos += full_match.length
+          # Closing/self-closing tags and unknown tags are treated as literal text
+          entry = @registry[tag_name]
+          if closing || self_closing || !entry
+            advance_as_text(full_match)
+            return
           end
+
+          dispatch_html_tag(entry, tag_name, full_match)
         end
 
-        # Handle <nowiki>...</nowiki> - preserves content as literal text.
-        def handle_nowiki_tag(closing, full_match)
-          if closing
-            @text_buffer << full_match
+        # Dispatch an HTML-like tag based on its registry entry type.
+        def dispatch_html_tag(entry, tag_name, full_match)
+          case entry.type
+          when :raw
+            if entry.element_class.nil?
+              handle_nowiki_tag(full_match)
+            else
+              handle_paired_raw_tag(tag_name, full_match, entry.element_class)
+            end
+          when :formatting
+            handle_paired_tag(tag_name, full_match, entry.element_class)
+          when :self_closing
             @pos += full_match.length
-            return
+            @parent << entry.element_class.new
           end
+        end
 
+        # Advance position and buffer the match as literal text.
+        def advance_as_text(full_match)
+          @text_buffer << full_match
           @pos += full_match.length
-          close_tag = "</nowiki>"
-          close_pos = @input.index(close_tag, @pos)
+        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)
 
           if close_pos
-            raw_content = @input[@pos...close_pos]
-            @text_buffer << raw_content
-            @pos = close_pos + close_tag.length
+            @text_buffer << @input[@pos...close_pos]
+            @pos = close_pos + "</nowiki>".length
           else
-            # No closing tag found - treat opening tag as text
             @text_buffer << full_match
           end
         end
 
         # 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, closing, full_match, element_class)
-          if closing
-            @text_buffer << full_match
-            @pos += full_match.length
-            return
-          end
-
+        def handle_paired_raw_tag(tag_name, full_match, element_class)
           @pos += full_match.length
           close_tag = "</#{tag_name}>"
           close_pos = @input.index(close_tag, @pos)
 
           if close_pos
-            raw_content = @input[@pos...close_pos]
             element = element_class.new
-            element << AST::Text.new(raw_content)
+            element << AST::Text.new(@input[@pos...close_pos])
             @parent << element
             @pos = close_pos + close_tag.length
           else
@@ -278,47 +268,21 @@ module Markbridge
 
         # Handle paired formatting tags like <s>, <u>, <sup>, <sub>.
         # Content inside IS parsed for wiki markup.
-        def handle_paired_tag(tag_name, closing, self_closing, full_match, element_class)
-          if closing || self_closing
-            @text_buffer << full_match
-            @pos += full_match.length
-            return
-          end
-
+        def handle_paired_tag(tag_name, full_match, element_class)
           @pos += full_match.length
-          # Find matching close tag, accounting for the alias tags
-          close_tags = close_tags_for(tag_name)
-          close_pos = nil
-          close_tag_length = 0
-
-          close_tags.each do |ct|
-            pos = @input.index(ct, @pos)
-            if pos && (close_pos.nil? || pos < close_pos)
-              close_pos = pos
-              close_tag_length = ct.length
-            end
-          end
+          close_tag = "</#{tag_name}>"
+          close_pos = @input.index(close_tag, @pos)
 
           if close_pos
-            inner_content = @input[@pos...close_pos]
             element = element_class.new
-            inner_parser = InlineParser.new
-            inner_parser.parse(inner_content, parent: element)
+            parse_inner_content(@input[@pos...close_pos], parent: element)
             @parent << element
-            @pos = close_pos + close_tag_length
+            @pos = close_pos + close_tag.length
           else
             @text_buffer << full_match
           end
         end
 
-        # Return the possible closing tags for a given tag name.
-        #
-        # @param tag_name [String]
-        # @return [Array<String>]
-        def close_tags_for(tag_name)
-          ["</#{tag_name}>"]
-        end
-
         # Flush accumulated text buffer to the parent as a Text node.
         def flush_text
           return if @text_buffer.empty?

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Parsers
+    module MediaWiki
+      # Registry of inline HTML-like tag handlers for the MediaWiki parser.
+      #
+      # Supports three tag types:
+      # - :raw - content is preserved verbatim (e.g., <code>, <nowiki>)
+      # - :formatting - content is parsed for inline wiki markup (e.g., <s>, <u>)
+      # - :self_closing - no content, produces a leaf AST node (e.g., <br>)
+      #
+      # @example Default usage
+      #   registry = InlineTagRegistry.default
+      #   entry = registry["s"]
+      #   entry.type           # => :formatting
+      #   entry.element_class  # => AST::Strikethrough
+      #
+      # @example Custom registration
+      #   registry = InlineTagRegistry.build_from_default do |r|
+      #     r.register("mark", :formatting, AST::Bold)
+      #   end
+      class InlineTagRegistry
+        Entry = Data.define(:type, :element_class)
+
+        def initialize
+          @entries = {}
+        end
+
+        # Register a handler for an inline HTML-like tag.
+        #
+        # @param tag_name [String] the tag name (case-insensitive)
+        # @param type [:raw, :formatting, :self_closing] how the tag content is handled
+        # @param element_class [Class] the AST node class to create
+        # @return [self]
+        def register(tag_name, type, element_class)
+          validate_type!(type)
+          @entries[tag_name.downcase] = Entry.new(type:, element_class:)
+          self
+        end
+
+        # Look up a tag entry by name.
+        #
+        # @param tag_name [String]
+        # @return [Entry, nil]
+        def [](tag_name)
+          @entries[tag_name.downcase]
+        end
+
+        # Check if a tag name is registered.
+        #
+        # @param tag_name [String]
+        # @return [Boolean]
+        def known?(tag_name)
+          @entries.key?(tag_name.downcase)
+        end
+
+        # Create the default registry with standard MediaWiki inline tags.
+        #
+        # @return [InlineTagRegistry]
+        def self.default
+          registry = new
+
+          # Raw tags -content preserved verbatim, not parsed for wiki markup
+          registry.register("nowiki", :raw, nil)
+          registry.register("code", :raw, AST::Code)
+          registry.register("pre", :raw, AST::Code)
+
+          # Formatting tags -content parsed for inline wiki markup
+          registry.register("s", :formatting, AST::Strikethrough)
+          registry.register("del", :formatting, AST::Strikethrough)
+          registry.register("u", :formatting, AST::Underline)
+          registry.register("ins", :formatting, AST::Underline)
+          registry.register("sup", :formatting, AST::Superscript)
+          registry.register("sub", :formatting, AST::Subscript)
+
+          # Self-closing tags -produce a leaf node, no content
+          registry.register("br", :self_closing, AST::LineBreak)
+        end
+
+        # Build a registry from the default with optional customization.
+        #
+        # @yield [InlineTagRegistry] the registry to customize
+        # @return [InlineTagRegistry]
+        def self.build_from_default
+          registry = default
+          yield(registry) if block_given?
+          registry
+        end
+
+        private
+
+        VALID_TYPES = %i[raw formatting self_closing].freeze
+
+        def validate_type!(type)
+          return if VALID_TYPES.include?(type)
+
+          raise ArgumentError, "type must be one of #{VALID_TYPES}, got #{type.inspect}"
+        end
+      end
+    end
+  end
+end