markbridge 0.1.0 → 0.1.1

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 (<code>, <nowiki>, <s>, <del>, <u>, <ins>, <sup>, <sub>, <br>).
       class InlineParser
+        def initialize
+          @input = nil
+          @pos = 0
+          @length = 0
+          @parent = nil
+          @text_buffer = +""
+        end
+
         # Parse inline markup and append resulting AST nodes to the parent element.
         #
         # @param text [String] the text to parse for inline markup
@@ -19,19 +27,29 @@ 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] == "["
+            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
+            when "["
               flush_text
-              parse_internal_link
-            elsif @input[@pos] == "[" && !(@pos + 1 < @length && @input[@pos + 1] == "[")
-              flush_text
-              parse_external_link
-            elsif @input[@pos] == "<"
+              if next_char == "["
+                parse_internal_link
+              else
+                parse_external_link
+              end
+            when "<"
               flush_text
               parse_html_tag
             else
-              @text_buffer << @input[@pos]
+              @text_buffer << char
               @pos += 1
             end
           end
@@ -46,72 +64,59 @@ module Markbridge
           start = @pos
           count = 0
           count += 1 while @pos + count < @length && @input[@pos + count] == "'"
-          count = 5 if count > 5
+          # Clamp: 5 = bold+italic, 3 = bold, 2 = italic
+          count = [count, 5].min
 
-          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
+          if count < 2
             @text_buffer << @input[@pos]
             @pos += 1
+          else
+            flush_text
+            @pos += count
+            parse_apostrophe_formatting(count, start)
           end
         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
+            bold = AST::Bold.new
+            bold << AST::Italic.new
+            bold
+          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
-          end
+        # Parse inner content and append to a parent element.
+        def parse_inner_content(content, parent:)
+          InlineParser.new.parse(content, parent:)
         end
 
         # Collect text until we find n consecutive apostrophes.
@@ -200,75 +205,71 @@ 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
+
+          # Closing/self-closing tags and unknown tags are treated as literal text
+          if closing || self_closing || !known_html_tag?(tag_name)
+            advance_as_text(full_match)
+            return
+          end
 
           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)
+            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, closing, self_closing, full_match, AST::Strikethrough)
+            handle_paired_tag(tag_name, full_match, AST::Strikethrough)
           when "u", "ins"
-            handle_paired_tag(tag_name, closing, self_closing, full_match, AST::Underline)
+            handle_paired_tag(tag_name, full_match, AST::Underline)
           when "sup"
-            handle_paired_tag(tag_name, closing, self_closing, full_match, AST::Superscript)
+            handle_paired_tag(tag_name, 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
+            handle_paired_tag(tag_name, full_match, AST::Subscript)
           end
         end
 
-        # Handle <nowiki>...</nowiki> - preserves content as literal text.
-        def handle_nowiki_tag(closing, full_match)
-          if closing
-            @text_buffer << full_match
-            @pos += full_match.length
-            return
-          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)
+        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 +279,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/parser.rb

@@ -14,12 +14,19 @@ module Markbridge
       # - Internal links ([[target]] / [[target|display]])
       # - External links ([url text])
       # - Preformatted text (lines starting with a space)
+      # - Tables ({| ... |})
       # - HTML tags: <nowiki>, <code>, <pre>, <br>, <s>, <del>, <u>, <ins>, <sup>, <sub>
       #
       # @example Basic usage
       #   parser = Markbridge::Parsers::MediaWiki::Parser.new
       #   ast = parser.parse("'''bold''' and ''italic''")
       class Parser
+        def initialize
+          @document = nil
+          @inline_parser = nil
+          @list_stack = []
+        end
+
         # Parse MediaWiki wikitext into an AST Document.
         #
         # @param input [String] MediaWiki source
@@ -61,6 +68,9 @@ module Markbridge
             elsif horizontal_rule_line?(line)
               close_open_lists
               @document << AST::HorizontalRule.new
+            elsif table_start_line?(line)
+              close_open_lists
+              i = process_table(lines, i)
             elsif list_line?(line)
               process_list_item(line)
             elsif preformatted_line?(line)
@@ -128,6 +138,124 @@ module Markbridge
           line.strip.empty?
         end
 
+        # Check if a line starts a table ({|).
+        #
+        # @param line [String]
+        # @return [Boolean]
+        def table_start_line?(line)
+          line.match?(/\A\s*\{\|/)
+        end
+
+        # Process a table block from {| to |}.
+        # Consumes lines until the closing |} is found.
+        #
+        # @param lines [Array<String>]
+        # @param start_index [Integer]
+        # @return [Integer] the last index consumed
+        def process_table(lines, start_index)
+          table = AST::Table.new
+          current_row = nil
+          i = start_index + 1 # Skip the {| line
+
+          while i < lines.length
+            stripped = lines[i].strip
+
+            if stripped.start_with?("|}")
+              break
+            elsif stripped.start_with?("|-")
+              # Row separator - next cells will go in a new row
+              current_row = nil
+            elsif stripped.start_with?("!")
+              # Header cells
+              current_row = ensure_table_row(table, current_row)
+              parse_table_cells(stripped[1..], header: true, row: current_row)
+            elsif stripped.start_with?("|")
+              # Data cells
+              current_row = ensure_table_row(table, current_row)
+              parse_table_cells(stripped[1..], header: false, row: current_row)
+            end
+
+            i += 1
+          end
+
+          @document << table
+          i
+        end
+
+        # Ensure a row exists for the table, creating one if needed.
+        #
+        # @param table [AST::Table]
+        # @param current_row [AST::TableRow, nil]
+        # @return [AST::TableRow]
+        def ensure_table_row(table, current_row)
+          return current_row if current_row
+
+          row = AST::TableRow.new
+          table << row
+          row
+        end
+
+        # Parse cell content from a line and add cells to the row.
+        # Cells are separated by !! (headers) or || (data cells).
+        # Separators inside [[...]] internal links are preserved so that
+        # pipes like [[Target|Display]] survive cell splitting.
+        #
+        # @param content [String] the line content after the leading ! or |
+        # @param header [Boolean] whether these are header cells
+        # @param row [AST::TableRow]
+        def parse_table_cells(content, header:, row:)
+          separator = header ? "!!" : "||"
+          cells = split_outside_brackets(content, separator)
+
+          cells.each do |raw_cell|
+            # A single | in a cell separates attributes from content
+            parts = split_outside_brackets(raw_cell, "|", limit: 2)
+            cell_text = parts.last
+
+            cell = AST::TableCell.new(header:)
+            @inline_parser.parse(cell_text.strip, parent: cell)
+            row << cell
+          end
+        end
+
+        # Split content on separator, ignoring occurrences inside [[...]] pairs.
+        # With limit: n, stops after n-1 splits (matching String#split semantics).
+        #
+        # @param content [String]
+        # @param separator [String]
+        # @param limit [Integer, nil]
+        # @return [Array<String>]
+        def split_outside_brackets(content, separator, limit: nil)
+          parts = []
+          buffer = +""
+          depth = 0
+          i = 0
+          sep_len = separator.length
+
+          while i < content.length
+            if content[i, 2] == "[["
+              depth += 1
+              buffer << "[["
+              i += 2
+            elsif content[i, 2] == "]]" && depth.positive?
+              depth -= 1
+              buffer << "]]"
+              i += 2
+            elsif depth.zero? && content[i, sep_len] == separator &&
+                  (limit.nil? || parts.length < limit - 1)
+              parts << buffer
+              buffer = +""
+              i += sep_len
+            else
+              buffer << content[i]
+              i += 1
+            end
+          end
+
+          parts << buffer
+          parts
+        end
+
         # Process a heading line and add it to the document.
         #
         # @param line [String]

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

@@ -122,6 +122,12 @@ module Markbridge
           # Paragraphs
           register("P", Handlers::SimpleHandler.new(AST::Paragraph))
 
+          # Table elements
+          register("TABLE", Handlers::SimpleHandler.new(AST::Table))
+          register("TR", Handlers::SimpleHandler.new(AST::TableRow))
+          register("TD", Handlers::TableCellHandler.new)
+          register("TH", Handlers::TableCellHandler.new)
+
           self
         end
       end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Parsers
+    module TextFormatter
+      module Handlers
+        # Handler for table cell elements (TD, TH)
+        class TableCellHandler < BaseHandler
+          def initialize
+            @element_class = AST::TableCell
+          end
+
+          def process(element:, parent:)
+            node = AST::TableCell.new(header: element.name.upcase == "TH")
+            parent << node
+            node
+          end
+
+          def element_class
+            @element_class
+          end
+        end
+      end
+    end
+  end
+end

data/lib/markbridge/parsers/text_formatter.rb

@@ -18,6 +18,7 @@ require_relative "text_formatter/handlers/image_handler"
 require_relative "text_formatter/handlers/list_handler"
 require_relative "text_formatter/handlers/quote_handler"
 require_relative "text_formatter/handlers/url_handler"
+require_relative "text_formatter/handlers/table_cell_handler"
 
 # Parser components
 require_relative "text_formatter/handler_registry"