markbridge 0.1.0 → 0.1.2

data/lib/markbridge/parsers/bbcode/handlers/list_handler.rb

@@ -11,7 +11,6 @@ module Markbridge
           end
 
           def on_open(token:, context:, registry:, tokens: nil)
-            # Check if ordered: explicit ol/olist tag, or type=1, or option=1
             ordered =
               %w[ol olist].include?(token.tag) || token.attrs[:type] == "1" ||
                 token.attrs[:option] == "1"
@@ -21,10 +20,7 @@ module Markbridge
           end
 
           def on_close(token:, context:, registry:, tokens: nil)
-            # Auto-close open list item before closing list
-            context.pop if context.current.is_a?(AST::ListItem)
-
-            # Then use default closing behavior
+            context.pop if context.current.instance_of?(AST::ListItem)
             super
           end
 

data/lib/markbridge/parsers/bbcode/handlers/list_item_handler.rb

@@ -11,8 +11,7 @@ module Markbridge
           end
 
           def on_open(token:, context:, registry:, tokens: nil)
-            # Auto-close previous list item if opening a new one
-            context.pop if context.current.is_a?(AST::ListItem)
+            context.pop if context.current.instance_of?(AST::ListItem)
 
             element = AST::ListItem.new
             context.push(element, token:)

data/lib/markbridge/parsers/bbcode/handlers/quote_handler.rb

@@ -17,46 +17,41 @@ module Markbridge
           end
 
           def on_open(token:, context:, registry:, tokens: nil)
-            # Extract quote attributes
-            author = nil
-            post = nil
-            topic = nil
-            username = nil
+            attrs = extract_quote_attrs(token)
+            element = AST::Quote.new(**attrs)
+            context.push(element, token:)
+          end
 
-            # Check for author attribute or option
-            if token.attrs[:author]
-              author = token.attrs[:author]
-            elsif token.attrs[:option]
-              # Parse Discourse-style quote: "username, post:123, topic:456"
-              option = token.attrs[:option]
-              if option.match?(/,\s*post:\d+/)
-                # Discourse format with post/topic
-                parts = option.split(",").map(&:strip)
-                username = parts[0]
-                parts[1..].each do |part|
-                  if part =~ /^post:(\d+)$/
-                    post = ::Regexp.last_match(1)
-                  elsif part =~ /^topic:(\d+)$/
-                    topic = ::Regexp.last_match(1)
-                  end
-                end
-                author = username
-              else
-                # Simple author attribution
-                author = option
-              end
-            end
+          attr_reader :element_class
 
-            # Check for explicit username, post, topic attributes (override option if present)
-            username = token.attrs[:username] if token.attrs[:username]
-            post = token.attrs[:post] if token.attrs[:post]
-            topic = token.attrs[:topic] if token.attrs[:topic]
+          private
 
-            element = AST::Quote.new(author:, post:, topic:, username:)
-            context.push(element, token:)
+          def extract_quote_attrs(token)
+            author, post, topic, username = extract_from_option(token)
+            author ||= token.attrs[:author]
+
+            {
+              author:,
+              post: token.attrs[:post] || post,
+              topic: token.attrs[:topic] || topic,
+              username: token.attrs[:username] || username,
+            }
           end
 
-          attr_reader :element_class
+          def extract_from_option(token)
+            option = token.attrs[:option]
+            return nil, nil, nil, nil unless option
+
+            post = option[/,\s*post:(\d+)/, 1]
+            return option, nil, nil, nil unless post
+
+            # Discourse format: "username, post:123, topic:456" (topic optional,
+            # order irrelevant between post: and topic:).
+            username = option.split(",").first.strip
+            topic = option[/,\s*topic:(\d+)/, 1]
+
+            [username, post, topic, username]
+          end
         end
       end
     end

data/lib/markbridge/parsers/bbcode/handlers/raw_handler.rb

@@ -15,19 +15,15 @@ module Markbridge
 
           def on_open(token:, context:, registry:, tokens:)
             result = @collector.collect(token.tag, tokens)
-
-            # Track unclosed raw tags for diagnostics
             context.mark_unclosed_raw!(token.tag) if result.unclosed?
 
             element = create_element(token:, content: result.content)
             context.add_child(element)
           end
 
-          # RawHandler doesn't push to stack, so on_close should do nothing
+          # The collector consumes the closing tag, so this fires only when a
+          # `[/raw]` token leaks past the collector — treat it as literal text.
           def on_close(token:, context:, registry:, tokens: nil)
-            # Raw content was already consumed by collector
-            # Closing tag was consumed by collector, so this shouldn't be called
-            # If it is called, treat as text
             context.add_child(AST::Text.new(token.source))
           end
 

data/lib/markbridge/parsers/bbcode/handlers/self_closing_handler.rb

@@ -15,10 +15,10 @@ module Markbridge
             context.add_child(element)
           end
 
-          def on_close(token:, context:, registry:, tokens: nil)
-            # Treat unexpected closing tag as text
-            context.add_child(AST::Text.new(token.source))
-          end
+          # on_close is inherited from BaseHandler. SelfClosing elements are
+          # never pushed onto the stack, so the registry's closing strategy
+          # always falls through to adding the closing-tag source as text -
+          # the same result as a dedicated override.
 
           attr_reader :element_class
         end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Parsers
+    module BBCode
+      module Handlers
+        # Handler for table cell tags (td, th)
+        class TableCellHandler < BaseHandler
+          def initialize
+            @element_class = AST::TableCell
+          end
+
+          def on_open(token:, context:, registry:, tokens: nil)
+            # Auto-close previous cell if still open
+            context.pop if context.current.instance_of?(AST::TableCell)
+
+            element = AST::TableCell.new(header: token.tag == "th")
+            context.push(element, token:)
+          end
+
+          attr_reader :element_class
+        end
+      end
+    end
+  end
+end

data/lib/markbridge/parsers/bbcode/handlers/table_handler.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Parsers
+    module BBCode
+      module Handlers
+        # Handler for table tags
+        class TableHandler < BaseHandler
+          def initialize
+            @element_class = AST::Table
+          end
+
+          def on_open(token:, context:, registry:, tokens: nil)
+            element = AST::Table.new
+            context.push(element, token:)
+          end
+
+          def on_close(token:, context:, registry:, tokens: nil)
+            # Auto-close open cell before closing row
+            context.pop if context.current.instance_of?(AST::TableCell)
+            # Auto-close open row before closing table
+            context.pop if context.current.instance_of?(AST::TableRow)
+
+            super
+          end
+
+          attr_reader :element_class
+        end
+      end
+    end
+  end
+end

data/lib/markbridge/parsers/bbcode/handlers/table_row_handler.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Parsers
+    module BBCode
+      module Handlers
+        # Handler for table row tags (tr)
+        class TableRowHandler < BaseHandler
+          def initialize
+            @element_class = AST::TableRow
+          end
+
+          def on_open(token:, context:, registry:, tokens: nil)
+            # Auto-close open cell before starting new row
+            context.pop if context.current.instance_of?(AST::TableCell)
+            # Auto-close previous row if still open
+            context.pop if context.current.instance_of?(AST::TableRow)
+
+            element = AST::TableRow.new
+            context.push(element, token:)
+          end
+
+          def on_close(token:, context:, registry:, tokens: nil)
+            # Auto-close open cell before closing row
+            context.pop if context.current.instance_of?(AST::TableCell)
+
+            super
+          end
+
+          attr_reader :element_class
+        end
+      end
+    end
+  end
+end

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

@@ -66,8 +66,7 @@ module Markbridge
         def parse_tokens(scanner, context)
           tokens = PeekableEnumerator.new(scanner)
 
-          while tokens.has_next?
-            token = tokens.next
+          while (token = tokens.next)
             case token
             when TextToken
               process_text(token, context)
@@ -94,7 +93,7 @@ module Markbridge
           if (handler = @handlers[token.tag])
             handler.on_open(token:, context:, registry: @handlers, tokens:)
           else
-            handle_unknown_tag(token, context)
+            track_unknown_tag(token)
           end
         end
 
@@ -106,15 +105,13 @@ module Markbridge
           if (handler = @handlers[token.tag])
             handler.on_close(token:, context:, registry: @handlers, tokens:)
           else
-            handle_unknown_tag(token, context)
+            track_unknown_tag(token)
           end
         end
 
-        # Handle unknown tag by tracking it and ignoring the wrapper
-        # while still processing its children
+        # Track unknown tag by name; the wrapper is ignored, children pass through.
         # @param token [Token]
-        # @param context [ParserState]
-        def handle_unknown_tag(token, context)
+        def track_unknown_tag(token)
           @unknown_tags[token.tag] += 1
         end
       end

data/lib/markbridge/parsers/bbcode/parser_state.rb

@@ -28,16 +28,13 @@ module Markbridge
         # @return [Boolean] true if pushed successfully, false if depth exceeded
         # @raise [MaxDepthExceededError] when pushing would exceed MAX_DEPTH and no token provided
         def push(element, token: nil)
-          if @depth >= MAX_DEPTH
-            if token
-              # Graceful degradation: treat as text
-              @current << AST::Text.new(token.source)
-              @depth_exceeded_count += 1
-              return false
-            else
-              # Legacy behavior: raise error
-              raise MaxDepthExceededError, MAX_DEPTH
-            end
+          if @depth == MAX_DEPTH
+            raise MaxDepthExceededError, MAX_DEPTH unless token
+
+            # Graceful degradation: treat as text
+            @current << AST::Text.new(token.source)
+            @depth_exceeded_count += 1
+            return false
           end
 
           @current << element
@@ -50,10 +47,10 @@ module Markbridge
         # Pop current element and return to parent
         # @return [AST::Element] the parent node
         def pop
-          return @root if @node_stack.size <= 1
+          return @root if @node_stack.size == 1
 
           @node_stack.pop
-          @current = @node_stack.last
+          @current = @node_stack.fetch(-1)
           @depth -= 1
           @current
         end
@@ -80,12 +77,9 @@ module Markbridge
         # @param limit [Integer, nil] number of elements to include from the top
         # @return [Array<AST::Node>]
         def elements_from_current(limit = nil)
-          return [] if @node_stack.empty?
-
-          limit = (@node_stack.size - 1) if limit.nil?
-          limit = [limit, @node_stack.size - 1].min
-
-          (0..limit).map { |offset| @node_stack[@node_stack.size - 1 - offset] }
+          max_offset = @node_stack.size - 1
+          limit = [limit || max_offset, max_offset].min
+          (0..limit).map { |offset| @node_stack.fetch(max_offset - offset) }
         end
       end
     end

data/lib/markbridge/parsers/bbcode/peekable_enumerator.rb

@@ -10,7 +10,7 @@ module Markbridge
       # `next_token`) so callers can:
       # - inspect the next token with {#peek} without advancing the scanner
       # - inspect several upcoming tokens with {#peek_ahead}
-      # - consume tokens with {#next}
+      # - consume tokens with {#next} (returns `nil` when exhausted)
       #
       # The enumerator is lazy: tokens are only requested from the scanner
       # when needed. Once the underlying scanner returns `nil`, the enumerator
@@ -32,71 +32,29 @@ module Markbridge
         def initialize(scanner)
           @scanner = scanner
           @peeked = []
-          @finished = false
         end
 
         # Consume and return the next token.
-        #
-        # If there are tokens in the internal buffer (from prior peeks) the
-        # buffered token is returned. Otherwise, the next token is requested
-        # from the underlying scanner via `next_token`.
-        #
         # @return [Object, nil] next token or `nil` when exhausted
         def next
-          return @peeked.shift if @peeked.any?
-          return nil if @finished
-
-          value = @scanner.next_token
-          @finished = true if value.nil?
-          value
-        end
-
-        # Return whether more tokens are available.
-        #
-        # This will attempt to fetch one token from the scanner if necessary
-        # to determine whether more tokens remain.
-        #
-        # @return [Boolean] `true` if at least one token is available
-        def has_next?
-          return true if @peeked.any?
-          return false if @finished
-
-          value = @scanner.next_token
-          if value.nil?
-            @finished = true
-            false
-          else
-            @peeked << value
-            true
-          end
+          ensure_peeked(1)
+          @peeked.shift
         end
 
         # Peek at the next single token without consuming it.
-        #
-        # If the enumerator has been exhausted this returns `nil`.
-        #
         # @return [Object, nil] the next token or `nil` when exhausted
         def peek
-          return @peeked.first if @peeked.any?
-          return nil if @finished
-
           ensure_peeked(1)
           @peeked.first
         end
 
         # Peek ahead at up to `count` upcoming tokens without consuming them.
-        #
-        # The method will return an array with at most `count` elements.
-        # If fewer tokens remain, a shorter array is returned. When the
-        # enumerator is exhausted an empty array is returned.
-        #
-        # @param count [Integer] number of tokens to peek ahead (non\-negative)
+        # @param count [Integer] number of tokens to peek ahead (clamped to 0..)
         # @return [Array<Object>] array of upcoming tokens (possibly empty)
         def peek_ahead(count)
-          return [] if count <= 0
-
+          count = [count, 0].max
           ensure_peeked(count)
-          @peeked.take(count)
+          @peeked.first(count)
         end
 
         alias next_token next
@@ -104,19 +62,11 @@ module Markbridge
         private
 
         # Ensure at least `count` items are present in the peek buffer.
-        #
-        # This will repeatedly call `next_token` on the scanner until the
-        # buffer contains `count` items or the scanner returns `nil`.
-        #
-        # @param count [Integer] desired buffer size
-        # @return [void]
         def ensure_peeked(count)
-          while !@finished && @peeked.size < count
+          while @peeked.size < count
             value = @scanner.next_token
-            if value.nil?
-              @finished = true
-              break
-            end
+            break if value.nil?
+
             @peeked << value
           end
         end

data/lib/markbridge/parsers/bbcode/raw_content_collector.rb

@@ -15,9 +15,9 @@ module Markbridge
           closed = false
 
           while (token = scanner.next_token)
-            if token.is_a?(TagStartToken) && token.tag == tag_name
+            if token.instance_of?(TagStartToken) && token.tag == tag_name
               depth += 1
-            elsif token.is_a?(TagEndToken) && token.tag == tag_name
+            elsif token.instance_of?(TagEndToken) && token.tag == tag_name
               if (depth -= 1) == 0
                 closed = true
                 break

data/lib/markbridge/parsers/bbcode/scanner.rb

@@ -20,16 +20,12 @@ module Markbridge
           if bracket_index.nil?
             text = @input[@current_pos..]
             @current_pos = @length
-            return TextToken.new(text:, pos: start_pos)
-          end
-
-          if bracket_index > @current_pos
+            TextToken.new(text:, pos: start_pos)
+          elsif bracket_index > @current_pos
             text = @input[@current_pos...bracket_index]
             @current_pos = bracket_index
-            return TextToken.new(text:, pos: start_pos)
-          end
-
-          if (tag_token = parse_tag_at_cursor)
+            TextToken.new(text:, pos: start_pos)
+          elsif (tag_token = parse_tag_at_cursor)
             tag_token
           else
             @current_pos += 1
@@ -53,35 +49,25 @@ module Markbridge
                          :WHITESPACE_CHAR,
                          :UNQUOTED_VALUE_STOP
 
+        # @return [Token, nil] tag token or nil if not a valid tag (caller rolls back)
+        # Precondition: caller has verified current_char == "[".
         def parse_tag_at_cursor
-          return nil if current_char != "["
-
           tag_start_pos = @current_pos
           @current_pos += 1 # skip '['
-
-          # Check for closing tag
-          closing = current_char == "/"
-          @current_pos += 1 if closing
-
-          # Parse tag name
+          closing = consume("/")
           tag_name = scan_tag_name
-          return rollback(tag_start_pos) unless tag_name
-
-          # Parse attributes (only for opening tags)
-          attrs = closing ? {} : scan_attributes
-          return rollback(tag_start_pos) if current_char != "]"
+          attrs = (closing || tag_name.nil?) ? {} : scan_attributes
+          return rollback(tag_start_pos) unless tag_name && consume("]")
 
-          @current_pos += 1 # skip ']'
-
-          # Capture original source text
           source = @input[tag_start_pos...@current_pos]
+          build_token(closing:, tag: tag_name.downcase, attrs:, pos: tag_start_pos, source:)
+        end
 
-          normalized_tag_name = tag_name.downcase
-
+        def build_token(closing:, tag:, attrs:, pos:, source:)
           if closing
-            TagEndToken.new(tag: normalized_tag_name, pos: tag_start_pos, source:)
+            TagEndToken.new(tag:, pos:, source:)
           else
-            TagStartToken.new(tag: normalized_tag_name, attrs:, pos: tag_start_pos, source:)
+            TagStartToken.new(tag:, attrs:, pos:, source:)
           end
         end
 
@@ -90,19 +76,21 @@ module Markbridge
           nil
         end
 
-        # Scan a tag name: [a-z*.][a-z0-9]*(:uid)?
+        # Scan a tag name: [a-z*][a-z0-9]*(:hex*)?
+        #
+        # Char-by-char rather than a single regex over `@input[pos..]`
+        # because the regex form allocates a substring for every tag,
+        # which is a dominant cost on tag-heavy input. The char-based
+        # loop is ~3x faster under YJIT.
         # @return [String, nil]
         def scan_tag_name
           start = @current_pos
 
-          # First character: letter, *, or .
           return nil unless current_char&.match?(TAG_INITIAL_CHAR)
           @current_pos += 1
 
-          # Remaining characters: letters or digits
           @current_pos += 1 while current_char&.match?(TAG_NAME_CHAR)
 
-          # Optional :uid suffix (e.g., [quote:abc123])
           if current_char == ":"
             @current_pos += 1
             @current_pos += 1 while current_char&.match?(UID_HEX_CHAR)
@@ -119,7 +107,6 @@ module Markbridge
           attrs = {}
           skip_whitespace
 
-          # First attribute might be option: [tag=value]
           if current_char == "="
             @current_pos += 1
             skip_whitespace
@@ -129,17 +116,11 @@ module Markbridge
             skip_whitespace
           end
 
-          # Named attributes: [tag key=value key=value ...]
-          while (char = current_char) && char != "]"
-            name = scan_while(ATTR_NAME_CHAR)
-            break if name.nil?
-
+          while (name = scan_while(ATTR_NAME_CHAR))
             skip_whitespace
-            break if current_char != "="
+            break unless consume("=")
 
-            @current_pos += 1
             skip_whitespace
-
             value = scan_attribute_value
             attrs[name.downcase.to_sym] = value if value
             skip_whitespace
@@ -148,6 +129,13 @@ module Markbridge
           attrs
         end
 
+        def consume(char)
+          return false if current_char != char
+
+          @current_pos += 1
+          true
+        end
+
         def scan_attribute_value
           char = current_char
           if char == '"' || char == "'"
@@ -171,22 +159,15 @@ module Markbridge
         # Workaround: Use single quotes if you need double quotes in the value:
         #   [url='has "quotes" inside']    → option: "has \"quotes\" inside" ✓
         #
-        # @return [String] the unescaped attribute value
+        # @return [String, nil] the unescaped attribute value, or nil if unterminated
         def scan_quoted_string
           quote_char = current_char
           start = (@current_pos += 1) # skip opening quote
-
           closing_index = @input.index(quote_char, start)
+          return nil unless closing_index
 
-          if closing_index
-            value = @input[start...closing_index]
-            @current_pos = closing_index + 1 # position after closing quote
-          else
-            value = @input[start..] || ""
-            @current_pos = @length
-          end
-
-          value
+          @current_pos = closing_index + 1
+          @input[start...closing_index]
         end
 
         def scan_unquoted_value
@@ -195,18 +176,18 @@ module Markbridge
 
         # Consumes characters matching +pattern+; returns substring or nil if empty
         def scan_while(pattern)
-          start = @current_pos
-          while (char = current_char) && char.match?(pattern)
-            @current_pos += 1
-          end
-
-          return nil if @current_pos == start
-          @input[start...@current_pos]
+          stop_index = @current_pos
+          stop_index += 1 while stop_index < @length && @input[stop_index].match?(pattern)
+          consume_range(stop_index)
         end
 
-        # Consumes characters until +pattern+ matches; returns substring or nil if empty
+        # Consumes characters until +pattern+ matches (or end of input); returns substring or nil if empty
         def scan_until(pattern)
-          stop_index = @input.index(pattern, @current_pos) || @length
+          consume_range(@input.index(pattern, @current_pos) || @length)
+        end
+
+        # Slice [@current_pos, stop_index), advance the cursor, or return nil for empty.
+        def consume_range(stop_index)
           return nil if stop_index == @current_pos
 
           value = @input[@current_pos...stop_index]
@@ -219,11 +200,16 @@ module Markbridge
         end
 
         def skip_whitespace
-          @current_pos += 1 while current_char&.match?(WHITESPACE_CHAR)
+          @current_pos += 1 while @current_pos < @length &&
+            @input[@current_pos].match?(WHITESPACE_CHAR)
         end
 
         def end_of_input?
-          @current_pos >= @length
+          # All callers maintain @current_pos <= @length (scan_while
+          # bounds on @length; scan_until uses `index || @length`;
+          # consume is a no-op at EOF); `==` and `>=` are observably
+          # identical here.
+          @current_pos == @length
         end
       end
     end