markbridge 0.1.0 → 0.1.2

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

@@ -14,26 +14,35 @@ 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
+        # @param inline_tag_registry [InlineTagRegistry, nil] custom registry or use default
+        # @yield [InlineTagRegistry] optional block to customize the default registry
+        def initialize(inline_tag_registry: nil, &block)
+          # InlineParser falls back to InlineTagRegistry.default when this is
+          # nil, so we don't need to materialise it here.
+          @inline_tag_registry =
+            block_given? ? InlineTagRegistry.build_from_default(&block) : inline_tag_registry
+        end
+
         # Parse MediaWiki wikitext into an AST Document.
         #
         # @param input [String] MediaWiki source
         # @return [AST::Document]
         def parse(input)
           normalized = normalize_line_endings(input)
-          lines = normalized.split("\n", -1)
+          lines = normalized.split("\n")
 
           @document = AST::Document.new
-          @inline_parser = InlineParser.new
+          @inline_parser = InlineParser.new(inline_tag_registry: @inline_tag_registry)
           @list_stack = []
 
           process_lines(lines)
-          close_open_lists
           @document
         end
 
@@ -53,7 +62,7 @@ module Markbridge
         def process_lines(lines)
           i = 0
           while i < lines.length
-            line = lines[i]
+            line = lines.fetch(i)
 
             if heading_line?(line)
               close_open_lists
@@ -61,6 +70,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)
@@ -80,12 +92,15 @@ module Markbridge
           end
         end
 
+        HEADING_LINE = /\A={1,6}(?:[^=].*[^=]={1,6}|[^=]+=*)\s*\z/
+        private_constant :HEADING_LINE
+
         # Check if a line is a heading (starts and ends with = signs).
         #
         # @param line [String]
         # @return [Boolean]
         def heading_line?(line)
-          line.match?(/\A={1,6}[^=].*[^=]={1,6}\s*\z/) || line.match?(/\A={1,6}[^=]+=*\s*\z/)
+          line.match?(HEADING_LINE)
         end
 
         # Check if a line is a horizontal rule (4+ dashes).
@@ -125,23 +140,138 @@ module Markbridge
         # @param line [String]
         # @return [Boolean]
         def blank_line?(line)
-          line.strip.empty?
+          !line.match?(/\S/)
+        end
+
+        HEADING_LEVEL_PREFIX = /\A={1,6}/
+        HEADING_LEVEL_SUFFIX = /\s*={1,6}\s*\z/
+        private_constant :HEADING_LEVEL_PREFIX, :HEADING_LEVEL_SUFFIX
+
+        # 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
         end
 
         # Process a heading line and add it to the document.
         #
         # @param line [String]
         def process_heading(line)
-          stripped = line.strip
-          # Count leading = signs for level
-          level = 0
-          level += 1 while level < stripped.length && stripped[level] == "="
-          level = [level, 6].min
-
-          # Remove leading/trailing = signs and whitespace
-          content = stripped[level..].sub(/\s*={1,6}\s*\z/, "").strip
+          leading = line[HEADING_LEVEL_PREFIX]
+          content = line[leading.length..].sub(HEADING_LEVEL_SUFFIX, "").strip
 
-          heading = AST::Heading.new(level:)
+          heading = AST::Heading.new(level: leading.length)
           @inline_parser.parse(content, parent: heading)
           @document << heading
         end
@@ -150,48 +280,28 @@ module Markbridge
         #
         # @param line [String]
         def process_list_item(line)
-          # Count prefix characters to determine depth and type
-          prefix = +""
-          i = 0
-          while i < line.length && (line[i] == "*" || line[i] == "#")
-            prefix << line[i]
-            i += 1
-          end
-
-          content = line[i..].strip
-          desired_depth = prefix.length
+          prefix = line[/\A[*#]+/]
+          content = line[prefix.length..].strip
 
-          # Adjust list stack to match desired depth
-          reconcile_list_stack(prefix, desired_depth)
+          reconcile_list_stack(prefix)
 
-          # Create list item and add content
           item = AST::ListItem.new
           @inline_parser.parse(content, parent: item)
-          @list_stack.last[:list] << item
+          @list_stack.last.fetch(:list) << item
         end
 
         # Reconcile the list stack with the desired prefix.
         # Opens new lists or closes existing ones as needed.
         #
         # @param prefix [String] the list prefix characters (e.g., "**#")
-        # @param desired_depth [Integer]
-        def reconcile_list_stack(prefix, desired_depth)
-          # Close lists that no longer match
-          @list_stack.pop while @list_stack.length > desired_depth
-
-          # Check if existing stack entries match the type at each level
-          prefix.chars.each_with_index do |char, idx|
-            ordered = char == "#"
-            if idx < @list_stack.length
-              # If type changed at this level, close from here and reopen
-              if @list_stack[idx][:ordered] != ordered
-                @list_stack.pop while @list_stack.length > idx
-                open_new_list(ordered, idx)
-              end
-            else
-              open_new_list(ordered, idx)
-            end
-          end
+        def reconcile_list_stack(prefix)
+          keep = matching_prefix_depth(prefix)
+          @list_stack.pop while @list_stack.length > keep
+          prefix[keep..].each_char { |char| open_new_list(char == "#", @list_stack.length) }
+        end
+
+        def matching_prefix_depth(prefix)
+          @list_stack.take_while.with_index { |entry, i| entry.fetch(:char) == prefix[i] }.length
         end
 
         # Open a new list at the given depth.
@@ -204,13 +314,12 @@ module Markbridge
           if depth.zero?
             @document << list
           else
-            # Nest inside the last item of the parent list
-            parent_list = @list_stack.last[:list]
+            parent_list = @list_stack.last.fetch(:list)
             parent_list << AST::ListItem.new if parent_list.children.empty?
             parent_list.children.last << list
           end
 
-          @list_stack << { list:, ordered: }
+          @list_stack << { list:, char: ordered ? "#" : "*" }
         end
 
         # Close all open lists.
@@ -224,45 +333,39 @@ module Markbridge
         # @param start_index [Integer]
         # @return [Integer] the last index consumed (will be incremented by caller)
         def process_preformatted_block(lines, start_index)
-          content_lines = []
-          i = start_index
-
-          while i < lines.length && lines[i].start_with?(" ")
-            content_lines << lines[i][1..] # Remove leading space
-            i += 1
-          end
+          consumed = lines[start_index..].take_while { |line| line.start_with?(" ") }
+          content = consumed.map { |line| line[1..] }.join("\n")
 
           code = AST::Code.new
-          code << AST::Text.new(content_lines.join("\n"))
+          code << AST::Text.new(content)
           @document << code
 
-          i - 1 # Return last consumed index
+          start_index + consumed.length - 1
         end
 
+        PRE_TAG_OPEN = /\A\s*<pre\b[^>]*>/i
+        PRE_TAG_CLOSE = %r{</pre\s*>}i
+        PRE_TAG_CLOSE_TRAILING = %r{</pre\s*>\s*\z}i
+        private_constant :PRE_TAG_OPEN, :PRE_TAG_CLOSE, :PRE_TAG_CLOSE_TRAILING
+
         # Process a <pre>...</pre> block that may span multiple lines.
         #
         # @param lines [Array<String>]
         # @param start_index [Integer]
         # @return [Integer] the last index consumed
         def process_pre_tag_block(lines, start_index)
-          combined = +""
-          i = start_index
+          consumed = lines[start_index..].take_while { |line| !line.match?(PRE_TAG_CLOSE) }
+          terminated = consumed.length < lines.length - start_index
+          consumed << lines.fetch(start_index + consumed.length) if terminated
 
-          while i < lines.length
-            combined << lines[i]
-            break if lines[i].match?(%r{</pre\s*>}i)
-            combined << "\n"
-            i += 1
-          end
-
-          # Extract content between <pre> and </pre>
-          content = combined.sub(/\A\s*<pre\b[^>]*>/i, "").sub(%r{</pre\s*>\s*\z}i, "")
+          combined = consumed.join("\n")
+          content = combined.sub(PRE_TAG_OPEN, "").sub(PRE_TAG_CLOSE_TRAILING, "")
 
           code = AST::Code.new
           code << AST::Text.new(content)
           @document << code
 
-          i
+          start_index + consumed.length - 1
         end
 
         # Process a line as inline content wrapped in a paragraph.

data/lib/markbridge/parsers/media_wiki.rb

@@ -4,6 +4,7 @@
 require_relative "../ast"
 
 # Parser components
+require_relative "media_wiki/inline_tag_registry"
 require_relative "media_wiki/inline_parser"
 require_relative "media_wiki/parser"
 

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

@@ -18,14 +18,6 @@ module Markbridge
       #     r.register("CUSTOM", MyCustomHandler.new)
       #     r.register("B", SimpleHandler.new(AST::Bold))  # Override default
       #   end
-      #
-      # @example Using lambdas for simple mappings
-      #   registry = HandlerRegistry.new
-      #   registry.register("CUSTOM", ->(element:, parent:) {
-      #     node = AST::Custom.new
-      #     parent << node
-      #     node  # Return node to process children
-      #   })
       class HandlerRegistry
         # Create a new registry with default mappings
         # @return [HandlerRegistry]
@@ -46,11 +38,7 @@ module Markbridge
 
         # Register a handler for an element
         # @param element_name [String] XML element name (case-insensitive)
-        # @param handler [#process, #call] Handler object or lambda
-        # @example With handler object
-        #   registry.register("CUSTOM", MyCustomHandler.new)
-        # @example With lambda
-        #   registry.register("CUSTOM", ->(element:, parent:) { ... })
+        # @param handler [#process] Handler object responding to `process(element:, parent:)`
         def register(element_name, handler)
           @mappings[element_name.upcase] = handler
         end
@@ -69,16 +57,7 @@ module Markbridge
         def process_element(element, parent)
           tag_name = element.name.upcase
           handler = @mappings[tag_name]
-          return nil unless handler
-
-          # Call handler and return its result (element or nil)
-          if handler.respond_to?(:process)
-            handler.process(element:, parent:)
-          elsif handler.respond_to?(:call)
-            handler.call(element:, parent:)
-          else
-            raise ArgumentError, "Handler must respond to :process or :call"
-          end
+          handler&.process(element:, parent:)
         end
 
         # Register all default s9e/TextFormatter element mappings
@@ -96,22 +75,13 @@ module Markbridge
           register("QUOTE", Handlers::QuoteHandler.new)
           register("IMG", Handlers::ImageHandler.new)
           register("LIST", Handlers::ListHandler.new)
-          register(
-            "COLOR",
-            Handlers::AttributeHandler.new(AST::Color, attribute: :color, param: :color),
-          )
-          register(
-            "SIZE",
-            Handlers::AttributeHandler.new(AST::Size, attribute: :size, param: :size),
-          )
+          register("COLOR", Handlers::AttributeHandler.new(AST::Color, attribute: :color))
+          register("SIZE", Handlers::AttributeHandler.new(AST::Size, attribute: :size))
           register(
             "ALIGN",
             Handlers::AttributeHandler.new(AST::Align, attribute: :align, param: :alignment),
           )
-          register(
-            "SPOILER",
-            Handlers::AttributeHandler.new(AST::Spoiler, attribute: :title, param: :title),
-          )
+          register("SPOILER", Handlers::AttributeHandler.new(AST::Spoiler, attribute: :title))
           register("ATTACHMENT", Handlers::AttachmentHandler.new)
           register("ATTACH", Handlers::AttachmentHandler.new)
 
@@ -122,7 +92,11 @@ module Markbridge
           # Paragraphs
           register("P", Handlers::SimpleHandler.new(AST::Paragraph))
 
-          self
+          # 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)
         end
       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/parser.rb

@@ -57,11 +57,8 @@ module Markbridge
           document = AST::Document.new
           process_node(root, document)
           document
-        rescue Nokogiri::XML::SyntaxError => e
-          # Invalid XML - treat as plain text
-          document = AST::Document.new
-          document << AST::Text.new(input)
-          document
+        rescue Nokogiri::XML::SyntaxError
+          AST::Document.new << AST::Text.new(input)
         end
 
         # Process children of an XML element (public for handler access)
@@ -122,9 +119,7 @@ module Markbridge
         # @param ast_parent [AST::Element]
         def process_text(text_node, ast_parent)
           text = text_node.content
-          return if text.strip.empty?
-
-          ast_parent << AST::Text.new(text)
+          ast_parent << AST::Text.new(text) if text.match?(/\S/)
         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"