Refactor blockquote builder to eliminate coupling anti-pattern: consume markers and yield back to main builder

Co-authored-by: DongyuZhao <8455725+DongyuZhao@users.noreply.github.com>

Author: Copilot

Sources/CodeParserCollection/Markdown/MarkdownConstructState.swift

@@ -12,6 +12,14 @@ public class MarkdownConstructState: CodeConstructState {
   /// Note: This cannot be derived from AST since reference definitions may appear
   /// anywhere in the document and need to be available for link resolution
   public var referenceDefinitions: [String: (url: String, title: String)] = [:]
+  
+  /// Current line tokens being processed - builders can modify these
+  /// This allows builders to consume their part and leave remaining tokens for further processing
+  public var tokens: [any CodeToken<MarkdownTokenElement>] = []
+  
+  /// Flag indicating if current line has been fully processed by a builder
+  /// When false, MarkdownBlockBuilder should continue processing the remaining tokens
+  public var currentLineProcessed: Bool = true
 
   public init() {}
 

Sources/CodeParserCollection/Markdown/Nodes/MarkdownATXHeadingBuilder.swift

@@ -189,7 +189,7 @@ public class MarkdownATXHeadingBuilder: MarkdownBlockBuilderProtocol {
     return result
   }
 
-  public func processLine(block: any MarkdownBlockNode, line: MarkdownLine) -> Bool {
+  public func processLine(block: any MarkdownBlockNode, line: MarkdownLine, state: inout MarkdownConstructState) -> Bool {
     // ATX headings are single-line blocks, no processing needed
     return false
   }

Sources/CodeParserCollection/Markdown/Nodes/MarkdownBlockBuilder.swift

@@ -85,27 +85,56 @@ public class MarkdownBlockBuilder: CodeNodeBuilder {
       return
     }
 
-    // Check if any existing block can continue with this line
-    if let continuingBlock = findBlockThatCanContinue(line, in: context.current) {
-      // Let the appropriate builder process this line into the existing block
-      processContinuationLine(line, for: continuingBlock)
-      return
-    }
-    
-    // Check if this line should interrupt any existing blocks
-    if canLineInterruptExistingBlocks(line) {
-      closeInterruptibleBlocks(context: &context)
-    }
-    
-    // Try to start a new block with this line
-    if let newBlock = tryCreateNewBlock(for: line) {
-      // Add the new block to the AST
-      context.current.append(newBlock as! MarkdownNodeBase)
-      // Process the opening line
-      processOpeningLine(line, for: newBlock)
-    } else {
-      // Fallback to paragraph
-      createAndProcessParagraph(for: line, context: &context)
+    // Store the current line in state for builders to process
+    if var state = context.state as? MarkdownConstructState {
+      state.tokens = line.tokens
+      state.currentLineProcessed = false
+      
+      // Keep processing until the line is fully processed
+      while !state.currentLineProcessed && !state.tokens.isEmpty {
+        state.currentLineProcessed = true // Will be set to false if a builder yields back
+        
+        // Check if any existing block can continue with current tokens
+        let currentLine = MarkdownLine(tokens: state.tokens, lineNumber: line.lineNumber)
+        if let continuingBlock = findBlockThatCanContinue(currentLine, in: context.current) {
+          // Let the appropriate builder process tokens and potentially modify state
+          processContinuationLine(currentLine, for: continuingBlock, state: &state)
+        } else {
+          // Check if this line should interrupt any existing blocks
+          if canLineInterruptExistingBlocks(MarkdownLine(tokens: state.tokens, lineNumber: line.lineNumber)) {
+            closeInterruptibleBlocks(context: &context)
+          }
+          
+          // Try to start a new block with current tokens
+          let currentLine = MarkdownLine(tokens: state.tokens, lineNumber: line.lineNumber)
+          if let newBlock = tryCreateNewBlock(for: currentLine) {
+            // Add the new block to the AST
+            context.current.append(newBlock as! MarkdownNodeBase)
+            
+            // If this is a container block (like blockquote), update context to point to it
+            let wasContainer = isContainerBlock(newBlock)
+            if wasContainer {
+              context.current = newBlock as! MarkdownNodeBase
+            }
+            
+            // Process the opening line and potentially modify state
+            processOpeningLine(currentLine, for: newBlock, state: &state)
+            
+            // If we made current point to a container and processing isn't complete,
+            // continue processing within that container
+            if wasContainer && !state.currentLineProcessed {
+              continue
+            }
+          } else {
+            // Fallback to paragraph
+            createAndProcessParagraph(for: currentLine, context: &context, state: &state)
+            break // Paragraph consumes everything
+          }
+        }
+      }
+      
+      // Update context state
+      context.state = state
     }
   }
 
@@ -191,37 +220,37 @@ public class MarkdownBlockBuilder: CodeNodeBuilder {
   }
 
   /// Process a line that continues an existing block
-  private func processContinuationLine(_ line: MarkdownLine, for block: any MarkdownBlockNode) {
+  private func processContinuationLine(_ line: MarkdownLine, for block: any MarkdownBlockNode, state: inout MarkdownConstructState) {
     // Find the builder for this block and let it process the line
     for builder in blockBuilders {
       if builder.canContinue(block: block, line: line) {
-        _ = builder.processLine(block: block, line: line)
+        _ = builder.processLine(block: block, line: line, state: &state)
         return
       }
     }
   }
 
   /// Process a line that opens a new block
-  private func processOpeningLine(_ line: MarkdownLine, for block: any MarkdownBlockNode) {
+  private func processOpeningLine(_ line: MarkdownLine, for block: any MarkdownBlockNode, state: inout MarkdownConstructState) {
     // Find the builder for this block and let it process the opening line
     for builder in blockBuilders {
       if canBuilderHandle(builder, blockType: block.blockType) {
-        _ = builder.processLine(block: block, line: line)
+        _ = builder.processLine(block: block, line: line, state: &state)
         return
       }
     }
   }
 
   /// Create and process a paragraph for this line
-  private func createAndProcessParagraph(for line: MarkdownLine, context: inout CodeConstructContext<Node, Token>) {
+  private func createAndProcessParagraph(for line: MarkdownLine, context: inout CodeConstructContext<Node, Token>, state: inout MarkdownConstructState) {
     // Create a new paragraph
     let paragraph = createParagraphBlock()
     context.current.append(paragraph as! MarkdownNodeBase)
 
     // Process the line into the paragraph
     for builder in blockBuilders {
       if builder is MarkdownParagraphBuilder {
-        _ = builder.processLine(block: paragraph, line: line)
+        _ = builder.processLine(block: paragraph, line: line, state: &state)
         return
       }
     }
@@ -235,6 +264,15 @@ public class MarkdownBlockBuilder: CodeNodeBuilder {
     return ParagraphNode(range: range)
   }
 
+  /// Check if a block is a container block that can contain other blocks
+  private func isContainerBlock(_ block: any MarkdownBlockNode) -> Bool {
+    switch block.blockType {
+    case "blockquote": return true
+    case "list_item": return true
+    default: return false
+    }
+  }
+  
   /// Check if a builder can handle a specific block type
   private func canBuilderHandle(_ builder: MarkdownBlockBuilderProtocol, blockType: String) -> Bool {
     switch blockType {

Sources/CodeParserCollection/Markdown/Nodes/MarkdownBlockBuilderProtocol.swift

@@ -26,8 +26,9 @@ public protocol MarkdownBlockBuilderProtocol {
   /// - Parameters:
   ///   - block: The existing block to add content to
   ///   - line: The line tokens to process
+  ///   - state: The construction state that can be modified by the builder
   /// - Returns: True if the line was successfully processed
-  func processLine(block: any MarkdownBlockNode, line: MarkdownLine) -> Bool
+  func processLine(block: any MarkdownBlockNode, line: MarkdownLine, state: inout MarkdownConstructState) -> Bool
 
   /// Close and finalize a block (post-processing)
   /// - Parameter block: The block to finalize

Sources/CodeParserCollection/Markdown/Nodes/MarkdownBlockquoteBuilder.swift

@@ -59,80 +59,33 @@ public class MarkdownBlockquoteBuilder: MarkdownBlockBuilderProtocol {
       blockquote.contentColumn = MarkdownIndentation.findContentColumn(tokens: line.tokens, afterMarkerAt: markerColumn)
     }
 
-    // Process the initial line
-    _ = processLine(block: blockquote, line: line)
-    
     return blockquote
   }
 
-  public func processLine(block: any MarkdownBlockNode, line: MarkdownLine) -> Bool {
+  public func processLine(block: any MarkdownBlockNode, line: MarkdownLine, state: inout MarkdownConstructState) -> Bool {
     guard let blockquote = block as? MarkdownBlockquote else { return false }
 
     // Find content tokens after the '>' marker using package-level properties
     var contentTokens: [any CodeToken<MarkdownTokenElement>] = []
 
-    let (found, _, _) = MarkdownIndentation.findMarkerPosition(tokens: line.tokens, marker: ">", afterWhitespace: true)
+    let (found, _, _) = MarkdownIndentation.findMarkerPosition(tokens: state.tokens, marker: ">", afterWhitespace: true)
     if found {
       // Remove content up to the content column (after '> ')
-      contentTokens = MarkdownIndentation.removeIndentation(from: line.tokens, upToColumn: blockquote.contentColumn)
+      contentTokens = MarkdownIndentation.removeIndentation(from: state.tokens, upToColumn: blockquote.contentColumn)
     } else {
       // Lazy continuation - use tokens after the blockquote's indent
-      contentTokens = MarkdownIndentation.removeIndentation(from: line.tokens, upToColumn: blockquote.indent)
+      contentTokens = MarkdownIndentation.removeIndentation(from: state.tokens, upToColumn: blockquote.indent)
     }
 
-    // Add content tokens to a temporary buffer for recursive parsing
-    // We'll accumulate all blockquote content and then parse it recursively
-    if !blockquote.children.isEmpty && blockquote.children.last?.element == .content {
-      // Continue accumulating content
-      if let contentNode = blockquote.children.last as? ContentNode {
-        // Add a newline between lines for proper parsing
-        if !contentNode.tokens.isEmpty {
-          let syntheticNewline = MarkdownToken(element: .newline, text: "\n", range: "".startIndex..<"".endIndex)
-          contentNode.tokens.append(syntheticNewline)
-        }
-        contentNode.tokens.append(contentsOf: contentTokens)
-      }
-    } else {
-      // Create new content accumulator
-      let contentNode = ContentNode(tokens: contentTokens)
-      blockquote.children.append(contentNode)
-    }
+    // Update state with remaining content tokens for MarkdownBlockBuilder to process
+    state.tokens = contentTokens
+    state.currentLineProcessed = false // Signal that remaining tokens need processing
 
     return true
   }
 
-  /// Close the block and parse accumulated content recursively
+  /// Close the block - no special processing needed as content is parsed recursively by MarkdownBlockBuilder
   public func closeBlock(block: any MarkdownBlockNode) {
-    guard let blockquote = block as? MarkdownBlockquote else { return }
-    
-    // Find all accumulated content
-    var allContentTokens: [any CodeToken<MarkdownTokenElement>] = []
-    for child in blockquote.children {
-      if let contentNode = child as? ContentNode {
-        allContentTokens.append(contentsOf: contentNode.tokens)
-      }
-    }
-    
-    // Clear the temporary content nodes
-    blockquote.children.removeAll()
-    
-    // Create a new parsing context for the blockquote content
-    if !allContentTokens.isEmpty {
-      let language = MarkdownLanguage()
-      let subBuilder = MarkdownBlockBuilder()
-      
-      // Create parsing context for the content
-      var state = MarkdownConstructState()
-      var contentContext = CodeConstructContext<MarkdownNodeElement, MarkdownTokenElement>(
-        root: blockquote,
-        current: blockquote,
-        tokens: allContentTokens,
-        consuming: 0,
-        state: state
-      )
-      
-      // Parse the content recursively
-      _ = subBuilder.build(from: &contentContext)
-    }
+    // No special closing logic needed - the recursive parsing is handled by MarkdownBlockBuilder
   }
 }

Sources/CodeParserCollection/Markdown/Nodes/MarkdownFencedCodeBlockBuilder.swift

@@ -156,7 +156,7 @@ public class MarkdownFencedCodeBlockBuilder: MarkdownBlockBuilderProtocol {
     return codeBlock
   }
 
-  public func processLine(block: any MarkdownBlockNode, line: MarkdownLine) -> Bool {
+  public func processLine(block: any MarkdownBlockNode, line: MarkdownLine, state: inout MarkdownConstructState) -> Bool {
     guard let codeBlock = block as? MarkdownFencedCodeBlock else { return false }
 
     // Check if this is a closing fence

Sources/CodeParserCollection/Markdown/Nodes/MarkdownIndentedCodeBlockBuilder.swift

@@ -29,7 +29,7 @@ public class MarkdownIndentedCodeBlockBuilder: MarkdownBlockBuilderProtocol {
     return codeBlock
   }
 
-  public func processLine(block: any MarkdownBlockNode, line: MarkdownLine) -> Bool {
+  public func processLine(block: any MarkdownBlockNode, line: MarkdownLine, state: inout MarkdownConstructState) -> Bool {
     guard let codeBlock = block as? CodeBlockNode else { return false }
 
     if line.isBlank {

Sources/CodeParserCollection/Markdown/Nodes/MarkdownListItemBuilder.swift

@@ -154,13 +154,10 @@ public class MarkdownListItemBuilder: MarkdownBlockBuilderProtocol {
     // Set the old properties for backward compatibility
     listItem.contentIndent = contentColumn
 
-    // Process the content after marker
-    _ = processLine(block: listItem, line: line)
-    
     return listItem
   }
 
-  public func processLine(block: any MarkdownBlockNode, line: MarkdownLine) -> Bool {
+  public func processLine(block: any MarkdownBlockNode, line: MarkdownLine, state: inout MarkdownConstructState) -> Bool {
     guard let listItem = block as? MarkdownListItem else { return false }
 
     var contentTokens: [any CodeToken<MarkdownTokenElement>] = []

Sources/CodeParserCollection/Markdown/Nodes/MarkdownParagraphBuilder.swift

@@ -49,11 +49,11 @@ public class MarkdownParagraphBuilder: MarkdownBlockBuilderProtocol {
     return paragraph
   }
 
-  public func processLine(block: any MarkdownBlockNode, line: MarkdownLine) -> Bool {
+  public func processLine(block: any MarkdownBlockNode, line: MarkdownLine, state: inout MarkdownConstructState) -> Bool {
     guard let paragraph = block as? ParagraphNode else { return false }
 
-    // Get content tokens (exclude EOF and newline)
-    var contentTokens = line.tokens.filter { token in
+    // Get content tokens from state (these may have been processed by other builders)
+    var contentTokens = state.tokens.filter { token in
       token.element != .eof && token.element != .newline
     }
 
@@ -102,6 +102,9 @@ public class MarkdownParagraphBuilder: MarkdownBlockBuilderProtocol {
       }
     }
 
+    // Mark current line as fully processed since paragraph consumes everything
+    state.currentLineProcessed = true
+    
     return true
   }
 

Sources/CodeParserCollection/Markdown/Nodes/MarkdownSetextHeadingBuilder.swift

@@ -54,7 +54,7 @@ public class MarkdownSetextHeadingBuilder: MarkdownBlockBuilderProtocol {
     return nil
   }
 
-  public func processLine(block: any MarkdownBlockNode, line: MarkdownLine) -> Bool {
+  public func processLine(block: any MarkdownBlockNode, line: MarkdownLine, state: inout MarkdownConstructState) -> Bool {
     // Setext headings don't process additional lines
     return false
   }