markbridge 0.1.1 → 0.1.3

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

@@ -21,10 +21,13 @@ module Markbridge
       #   parser = Markbridge::Parsers::MediaWiki::Parser.new
       #   ast = parser.parse("'''bold''' and ''italic''")
       class Parser
-        def initialize
-          @document = nil
-          @inline_parser = nil
-          @list_stack = []
+        # @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.
@@ -33,14 +36,13 @@ module Markbridge
         # @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
 
@@ -60,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
@@ -90,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).
@@ -135,9 +140,13 @@ 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]
@@ -253,23 +262,16 @@ module Markbridge
           end
 
           parts << buffer
-          parts
         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
+          leading = line[HEADING_LEVEL_PREFIX]
+          content = line[leading.length..].sub(HEADING_LEVEL_SUFFIX, "").strip
 
-          # Remove leading/trailing = signs and whitespace
-          content = stripped[level..].sub(/\s*={1,6}\s*\z/, "").strip
-
-          heading = AST::Heading.new(level:)
+          heading = AST::Heading.new(level: leading.length)
           @inline_parser.parse(content, parent: heading)
           @document << heading
         end
@@ -278,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.
@@ -332,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.
@@ -352,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)
 
@@ -127,8 +97,6 @@ module Markbridge
           register("TR", Handlers::SimpleHandler.new(AST::TableRow))
           register("TD", Handlers::TableCellHandler.new)
           register("TH", Handlers::TableCellHandler.new)
-
-          self
         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/processors/discourse_markdown/code_block_tracker.rb

@@ -31,11 +31,12 @@ module Markbridge
 
         def initialize
           @in_fenced_block = false
-          @fence_char = nil
-          @fence_length = 0
           @in_indented_block = false
           @in_inline_code = false
-          @inline_delimiter = nil
+          # @fence_char / @fence_length / @inline_delimiter are set by
+          # open_fence / open_inline before any helper reads them;
+          # they're only consulted when the corresponding in_X flag is
+          # true, which requires a prior open_* call.
         end
 
         # Check if currently inside any code context
@@ -53,9 +54,10 @@ module Markbridge
           return nil unless line_start
 
           input_length = input.length
-          scan_pos = skip_leading_spaces(input, pos, input_length)
-          return nil if scan_pos >= input_length
-
+          scan_pos = skip_leading_spaces(input, pos)
+          # No `scan_pos >= input_length` guard: `input[input_length]` is
+          # nil, and `nil == "`"` / `nil == "~"` are both false so the
+          # next check returns nil anyway.
           fence_char = input[scan_pos]
           return nil unless fence_char == "`" || fence_char == "~"
 
@@ -106,10 +108,11 @@ module Markbridge
         # @return [Integer, nil] end position after inline code, or nil if not at boundary
         def check_inline_boundary(input, pos)
           return nil if @in_fenced_block || @in_indented_block
+          # No `pos >= input_length` guard: `input[input_length]` is nil,
+          # and `nil != "`"` is true so the next check returns nil anyway.
+          return nil if input[pos] != "`"
 
           input_length = input.length
-          return nil if pos >= input_length || input[pos] != "`"
-
           if @in_inline_code
             try_close_inline(input, pos, input_length)
           else
@@ -120,10 +123,10 @@ module Markbridge
         private
 
         # Skip up to 3 leading spaces of indentation.
-        def skip_leading_spaces(input, pos, input_length)
+        def skip_leading_spaces(input, pos)
           scan_pos = pos
           spaces = 0
-          while spaces < 3 && scan_pos < input_length && input[scan_pos] == " "
+          while spaces < 3 && input[scan_pos] == " "
             spaces += 1
             scan_pos += 1
           end
@@ -148,9 +151,10 @@ module Markbridge
           scan_pos += 1 while scan_pos < input_length && input[scan_pos] == " "
           return nil unless scan_pos >= input_length || input[scan_pos] == "\n"
 
+          # @fence_char / @fence_length are not reset here: they are only
+          # consulted while @in_fenced_block is true, and open_fence
+          # overwrites them on the next opening.
           @in_fenced_block = false
-          @fence_char = nil
-          @fence_length = 0
           pos_after_line(scan_pos, input_length)
         end
 
@@ -174,8 +178,10 @@ module Markbridge
           next_pos = pos + delimiter_length
           return nil if next_pos < input_length && input[next_pos] == "`"
 
+          # @inline_delimiter is not reset here: it is only consulted
+          # while @in_inline_code is true, and open_inline overwrites it
+          # on the next opening.
           @in_inline_code = false
-          @inline_delimiter = nil
           next_pos
         end
 
@@ -196,14 +202,15 @@ module Markbridge
 
         public
 
-        # Reset the tracker state
+        # Reset the tracker state. The @fence_char / @fence_length /
+        # @inline_delimiter companions are not cleared: they're only
+        # consulted while the corresponding in_* flag is true, and
+        # open_fence / open_inline overwrites them on the next
+        # opening (same pattern as try_close_fence / try_close_inline).
         def reset!
           @in_fenced_block = false
-          @fence_char = nil
-          @fence_length = 0
           @in_indented_block = false
           @in_inline_code = false
-          @inline_delimiter = nil
         end
       end
     end

data/lib/markbridge/processors/discourse_markdown/detectors/base.rb

@@ -38,29 +38,23 @@ module Markbridge
             !prev_char.match?(/\w/)
           end
 
-          # Helper to extract a word starting at position
+          WORD_PATTERN = /\A[\w\-]*/
+          private_constant :WORD_PATTERN
+
+          # Helper to extract a word starting at position. Caller must ensure
+          # pos is within input bounds (`pos <= input.length`).
           # @param input [String] the input string
           # @param pos [Integer] starting position
           # @return [String] the word (may be empty)
           def extract_word(input, pos)
-            word = +""
-            while pos < input.length && input[pos].match?(/[\w\-]/)
-              word << input[pos]
-              pos += 1
-            end
-            word
+            input[pos..].match(WORD_PATTERN)[0]
           end
 
-          # Parse key="value" or key='value' attribute pairs from a string
-          # @param attr_string [String, nil] the attribute string to parse
+          # Parse key="value" or key='value' attribute pairs from a string.
+          # @param attr_string [String] the attribute string to parse
           # @return [Hash<String, String>] parsed attributes with downcased keys
           def parse_attributes(attr_string)
-            attrs = {}
-            return attrs if attr_string.nil? || attr_string.empty?
-
-            attr_string.scan(/(\w+)=["']([^"']*)["']/) { |key, value| attrs[key.downcase] = value }
-
-            attrs
+            attr_string.scan(/(\w+)=["']([^"']*)["']/).to_h.transform_keys(&:downcase)
           end
         end
       end

data/lib/markbridge/processors/discourse_markdown/detectors/event.rb

@@ -12,7 +12,7 @@ module Markbridge
         #   match = detector.detect(input, 0)
         #   match.node.name # => "Meeting"
         class Event < Base
-          OPEN_TAG_PATTERN = /\[event([^\]]*)\]/i
+          OPEN_TAG_PATTERN = /\[event(?<attrs>[^\]]*)\]/i
           CLOSE_TAG_PATTERN = %r{\[/event\]}i
 
           # Attempt to detect an event at the given position.
@@ -21,15 +21,14 @@ module Markbridge
           # @param pos [Integer] current position to check
           # @return [Match, nil] match result or nil if no match
           def detect(input, pos)
-            return nil unless input[pos] == "["
-
-            # Check for opening tag
             remaining = input[pos..]
             open_match = OPEN_TAG_PATTERN.match(remaining)
             return nil unless open_match&.begin(0)&.zero?
 
-            # Find closing tag
-            close_match = CLOSE_TAG_PATTERN.match(remaining, open_match.end(0))
+            # Find closing tag. The opening tag pattern forbids `]` between
+            # `[event` and its closing `]`, so `[/event]` cannot appear inside
+            # the opening tag - no need to skip past it.
+            close_match = CLOSE_TAG_PATTERN.match(remaining)
             return nil unless close_match
 
             # Extract raw content
@@ -37,15 +36,17 @@ module Markbridge
             raw = input[pos...end_pos]
 
             # Parse attributes from opening tag
-            attrs = parse_attributes(open_match[1])
+            attrs = parse_attributes(open_match[:attrs])
 
             # Validate required attributes
-            return nil unless attrs["name"] && attrs["start"]
+            name = attrs["name"]
+            starts_at = attrs["start"]
+            return nil if name.nil? || starts_at.nil?
 
             node =
               AST::Event.new(
-                name: attrs["name"],
-                starts_at: attrs["start"],
+                name:,
+                starts_at:,
                 ends_at: attrs["end"],
                 status: attrs["status"],
                 timezone: attrs["timezone"],

data/lib/markbridge/processors/discourse_markdown/detectors/poll.rb

@@ -12,8 +12,7 @@ module Markbridge
         #   match = detector.detect(input, 0)
         #   match.node.type # => "regular"
         class Poll < Base
-          OPEN_TAG_PATTERN = /\[poll([^\]]*)\]/i
-          CLOSE_TAG_PATTERN = %r{\[/poll\]}i
+          TAG_PATTERN = %r{\A\[poll(?<attrs>[^\]]*)\](?<content>.*?)\[/poll\]}im
 
           # Attempt to detect a poll at the given position.
           #
@@ -21,57 +20,30 @@ module Markbridge
           # @param pos [Integer] current position to check
           # @return [Match, nil] match result or nil if no match
           def detect(input, pos)
-            return nil unless input[pos] == "["
-
-            # Check for opening tag
-            remaining = input[pos..]
-            open_match = OPEN_TAG_PATTERN.match(remaining)
-            return nil unless open_match&.begin(0)&.zero?
-
-            # Find closing tag
-            close_match = CLOSE_TAG_PATTERN.match(remaining, open_match.end(0))
-            return nil unless close_match
-
-            # Extract raw content
-            end_pos = pos + close_match.end(0)
-            raw = input[pos...end_pos]
-
-            # Parse attributes from opening tag
-            attrs = parse_attributes(open_match[1])
-
-            # Extract options from content between tags
-            content = remaining[open_match.end(0)...close_match.begin(0)]
-            options = extract_options(content)
+            match = TAG_PATTERN.match(input[pos..])
+            return nil unless match
 
+            attrs = parse_attributes(match[:attrs])
             node =
               AST::Poll.new(
                 name: attrs["name"] || "poll",
                 type: attrs["type"],
                 results: attrs["results"],
                 public: attrs["public"] == "true",
-                chart_type: attrs["charttype"] || attrs["chartType"],
-                options:,
-                raw:,
+                chart_type: attrs["charttype"],
+                options: extract_options(match[:content]),
+                raw: match[0],
               )
 
-            Match.new(start_pos: pos, end_pos:, node:)
+            Match.new(start_pos: pos, end_pos: pos + match.end(0), node:)
           end
 
           private
 
+          OPTION_PATTERN = /\A\s*(?:\*\s|-\s|\d+\.\s+)(?<value>.+?)\s*\z/
+
           def extract_options(content)
-            options = []
-            content.each_line do |line|
-              line = line.strip
-              if line.start_with?("* ")
-                options << line[2..].strip
-              elsif line.start_with?("- ")
-                options << line[2..].strip
-              elsif line.match?(/^\d+\.\s/)
-                options << line.sub(/^\d+\.\s*/, "").strip
-              end
-            end
-            options
+            content.each_line.filter_map { |line| OPTION_PATTERN.match(line)&.[](:value) }
           end
         end
       end