markbridge 0.1.1 → 0.1.2

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

@@ -27,55 +27,38 @@ module Markbridge
         # Create the default handler registry with common HTML tags
         # @return [HandlerRegistry]
         def self.default
-          registry = new
-
-          # Simple formatting handlers
-          registry.register(%w[b strong], Handlers::SimpleHandler.new(AST::Bold))
-          registry.register(%w[i em], Handlers::SimpleHandler.new(AST::Italic))
-          registry.register(%w[s strike del], Handlers::SimpleHandler.new(AST::Strikethrough))
-          registry.register("u", Handlers::SimpleHandler.new(AST::Underline))
-          registry.register("sup", Handlers::SimpleHandler.new(AST::Superscript))
-          registry.register("sub", Handlers::SimpleHandler.new(AST::Subscript))
-
-          # Code handlers (raw content)
-          registry.register(%w[code pre tt], Handlers::RawHandler.new(AST::Code))
-
-          # Link and image handlers
-          registry.register("a", Handlers::UrlHandler.new)
-          registry.register("img", Handlers::ImageHandler.new)
-
-          # Blockquote handler
-          registry.register("blockquote", Handlers::QuoteHandler.new)
-
-          # Void elements - use simple inline handlers
-          registry.register(
-            "br",
-            lambda do |element:, parent:|
-              parent << AST::LineBreak.new
-              nil # Return nil - void element, no children
-            end,
-          )
-          registry.register(
-            "hr",
-            lambda do |element:, parent:|
-              parent << AST::HorizontalRule.new
-              nil # Return nil - void element, no children
-            end,
-          )
-
-          # List handlers
-          registry.register(%w[ul ol], Handlers::ListHandler.new)
-          registry.register("li", Handlers::ListItemHandler.new)
-
-          # Table handlers (thead/tbody/tfoot are transparent - unregistered tags pass through)
-          registry.register("table", Handlers::TableHandler.new)
-          registry.register("tr", Handlers::TableRowHandler.new)
-          registry.register(%w[td th], Handlers::TableCellHandler.new)
-
-          # Paragraph handler (transparent - doesn't create AST node)
-          registry.register("p", Handlers::ParagraphHandler.new)
-
-          registry
+          new.tap do |registry|
+            registry.register(%w[b strong], Handlers::SimpleHandler.new(AST::Bold))
+            registry.register(%w[i em], Handlers::SimpleHandler.new(AST::Italic))
+            registry.register(%w[s strike del], Handlers::SimpleHandler.new(AST::Strikethrough))
+            registry.register("u", Handlers::SimpleHandler.new(AST::Underline))
+            registry.register("sup", Handlers::SimpleHandler.new(AST::Superscript))
+            registry.register("sub", Handlers::SimpleHandler.new(AST::Subscript))
+            registry.register(%w[code pre tt], Handlers::RawHandler.new(AST::Code))
+            registry.register("a", Handlers::UrlHandler.new)
+            registry.register("img", Handlers::ImageHandler.new)
+            registry.register("blockquote", Handlers::QuoteHandler.new)
+            registry.register(
+              "br",
+              lambda do |element:, parent:|
+                parent << AST::LineBreak.new
+                nil
+              end,
+            )
+            registry.register(
+              "hr",
+              lambda do |element:, parent:|
+                parent << AST::HorizontalRule.new
+                nil
+              end,
+            )
+            registry.register(%w[ul ol], Handlers::ListHandler.new)
+            registry.register("li", Handlers::ListItemHandler.new)
+            registry.register("table", Handlers::TableHandler.new)
+            registry.register("tr", Handlers::TableRowHandler.new)
+            registry.register(%w[td th], Handlers::TableCellHandler.new)
+            registry.register("p", Handlers::ParagraphHandler.new)
+          end
         end
 
         # Build a registry from the default configuration with optional customization

data/lib/markbridge/parsers/html/handlers/base_handler.rb

@@ -11,8 +11,6 @@ module Markbridge
           # @param parent [AST::Element] the parent AST node
           # @return [AST::Element, nil] the created element if children should be processed, nil otherwise
           def process(element:, parent:)
-            # Default: do nothing, subclasses override
-            nil
           end
 
           # The element class created by this handler

data/lib/markbridge/parsers/html/handlers/image_handler.rb

@@ -26,12 +26,9 @@ module Markbridge
 
           private
 
-          # Convert dimension to positive integer or nil
           def sanitize_dimension(value)
-            return nil if value.nil?
-
             dim = value.to_i
-            dim.positive? ? dim : nil
+            dim if dim.positive?
           end
         end
       end

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

@@ -72,15 +72,14 @@ module Markbridge
         # @param node [Nokogiri::XML::Text]
         # @param parent [AST::Element]
         def process_text_node(node, parent)
-          text = node.text
-          parent << AST::Text.new(text) unless text.empty?
+          parent << AST::Text.new(node.text)
         end
 
         # Process an element node
         # @param node [Nokogiri::XML::Element]
         # @param parent [AST::Element]
         def process_element_node(node, parent)
-          tag_name = node.name.downcase
+          tag_name = node.name
           return if IGNORED_TAGS.include?(tag_name)
 
           handler = @handlers[tag_name]
@@ -106,18 +105,9 @@ module Markbridge
         # @param node [Nokogiri::XML::Element]
         # @param parent [AST::Element]
         def handle_unknown_tag(node, parent)
-          @unknown_tags[node.name.downcase] += 1
+          @unknown_tags[node.name] += 1
           process_children(node, parent)
         end
-
-        # Check if an element is a void element (self-closing)
-        # @param tag_name [String]
-        # @return [Boolean]
-        def void_element?(tag_name)
-          %w[area base br col embed hr img input link meta param source track wbr].include?(
-            tag_name.downcase,
-          )
-        end
       end
     end
   end

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

@@ -5,14 +5,19 @@ 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
-        def initialize
-          @input = nil
-          @pos = 0
-          @length = 0
-          @parent = nil
-          @text_buffer = +""
+        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.
@@ -28,29 +33,18 @@ module Markbridge
 
           while @pos < @length
             char = @input[@pos]
-            next_char = @pos + 1 < @length ? @input[@pos + 1] : nil
 
             case char
             when "'"
-              if next_char == "'"
-                parse_bold_italic
-              else
-                @text_buffer << char
-                @pos += 1
-              end
+              consecutive_apostrophes_at(@pos) >= 2 ? parse_bold_italic : append_literal(char)
             when "["
               flush_text
-              if next_char == "["
-                parse_internal_link
-              else
-                parse_external_link
-              end
+              @input[@pos + 1] == "[" ? parse_internal_link : parse_external_link
             when "<"
               flush_text
               parse_html_tag
             else
-              @text_buffer << char
-              @pos += 1
+              append_literal(char)
             end
           end
 
@@ -59,22 +53,18 @@ 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] == "'"
-          # Clamp: 5 = bold+italic, 3 = bold, 2 = italic
-          count = [count, 5].min
-
-          if count < 2
-            @text_buffer << @input[@pos]
-            @pos += 1
-          else
-            flush_text
-            @pos += count
-            parse_apostrophe_formatting(count, start)
-          end
+          count = [consecutive_apostrophes_at(@pos), 5].min
+          flush_text
+          @pos += count
+          parse_apostrophe_formatting(count, start)
         end
 
         # Parse apostrophe-delimited formatting (bold, italic, or bold+italic).
@@ -99,9 +89,7 @@ module Markbridge
         def build_formatting_element(apostrophe_count)
           case apostrophe_count
           when 5
-            bold = AST::Bold.new
-            bold << AST::Italic.new
-            bold
+            AST::Bold.new << AST::Italic.new
           when 3
             AST::Bold.new
           when 2
@@ -115,8 +103,17 @@ module Markbridge
         end
 
         # 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:)
-          InlineParser.new.parse(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.
@@ -127,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.
@@ -142,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]].
@@ -196,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
@@ -211,34 +204,30 @@ module Markbridge
           tag_name = tag_match[2].downcase
 
           # Closing/self-closing tags and unknown tags are treated as literal text
-          if closing || self_closing || !known_html_tag?(tag_name)
+          entry = @registry[tag_name]
+          if closing || self_closing || !entry
             advance_as_text(full_match)
             return
           end
 
-          case tag_name
-          when "nowiki"
-            handle_nowiki_tag(full_match)
-          when "code", "pre"
-            handle_paired_raw_tag(tag_name, full_match, AST::Code)
-          when "br"
-            @pos += full_match.length
-            @parent << AST::LineBreak.new
-          when "s", "del"
-            handle_paired_tag(tag_name, full_match, AST::Strikethrough)
-          when "u", "ins"
-            handle_paired_tag(tag_name, full_match, AST::Underline)
-          when "sup"
-            handle_paired_tag(tag_name, full_match, AST::Superscript)
-          when "sub"
-            handle_paired_tag(tag_name, full_match, AST::Subscript)
-          end
+          dispatch_html_tag(entry, tag_name, full_match)
         end
 
-        KNOWN_HTML_TAGS = %w[nowiki code pre br s del u ins sup sub].freeze
-
-        def known_html_tag?(tag_name)
-          KNOWN_HTML_TAGS.include?(tag_name)
+        # 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
+            @parent << entry.element_class.new
+          end
         end
 
         # Advance position and buffer the match as literal text.

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