Text Content Rendering

/**
 * Renders a tree of nodes to plain text.
 * Thread-safe renderer that can be reused across multiple rendering operations.
 */
public class TextContentRenderer implements Renderer {
    /**
     * Create a new builder for configuring a TextContentRenderer
     * @return a builder instance
     */
    public static Builder builder();
    
    /**
     * Render the node to text and return as string
     * @param node the node to render - must not be null
     * @return the rendered text as a string
     */
    public String render(Node node);
    
    /**
     * Render the node to text and append to the given output
     * @param node the node to render - must not be null
     * @param output the appendable to write text to
     */
    public void render(Node node, Appendable output);
}

import org.commonmark.parser.Parser;
import org.commonmark.renderer.text.TextContentRenderer;
import org.commonmark.node.Node;

// Basic text rendering
Parser parser = Parser.builder().build();
TextContentRenderer renderer = TextContentRenderer.builder().build();

Node document = parser.parse("# Hello\n\nThis is **bold** text with a [link](url).");
String text = renderer.render(document);
// Result: "Hello\n\nThis is bold text with a link."

// Render to StringBuilder
StringBuilder sb = new StringBuilder();
renderer.render(document, sb);

// Render to file
try (FileWriter writer = new FileWriter("output.txt")) {
    renderer.render(document, writer);
}

/**
 * Builder for configuring a TextContentRenderer
 */
public static class TextContentRenderer.Builder {
    /**
     * Build the configured TextContentRenderer instance
     * @return the configured TextContentRenderer
     */
    public TextContentRenderer build();
    
    /**
     * Whether to strip newlines and render everything on one line, defaults to false
     * @param stripNewlines true to strip newlines, false to preserve line structure
     * @return this builder
     */
    public Builder stripNewlines(boolean stripNewlines);
    
    /**
     * Add a factory for instantiating a node renderer (done when rendering)
     * @param nodeRendererFactory the factory for creating a node renderer
     * @return this builder
     */
    public Builder nodeRendererFactory(TextContentNodeRendererFactory nodeRendererFactory);
    
    /**
     * Add extensions to use on this text renderer
     * @param extensions extensions to use on this text renderer
     * @return this builder
     */
    public Builder extensions(Iterable<? extends Extension> extensions);
}

import org.commonmark.renderer.text.TextContentRenderer;

// Strip newlines for single-line output
TextContentRenderer singleLineRenderer = TextContentRenderer.builder()
    .stripNewlines(true)
    .build();

Node document = parser.parse("# Title\n\nParagraph one.\n\nParagraph two.");
String singleLine = singleLineRenderer.render(document);
// Result: "Title Paragraph one. Paragraph two."

// Preserve line structure (default)
TextContentRenderer structuredRenderer = TextContentRenderer.builder()
    .stripNewlines(false)
    .build();

String structured = structuredRenderer.render(document);
// Result: "Title\n\nParagraph one.\n\nParagraph two."

/**
 * Extension interface for text content renderer
 */
public interface TextContentRenderer.TextContentRendererExtension extends Extension {
    /**
     * Extend the text content renderer builder with custom functionality
     * @param rendererBuilder the builder to extend
     */
    void extend(TextContentRenderer.Builder rendererBuilder);
}

/**
 * Factory for text content node renderers
 */
public interface TextContentNodeRendererFactory {
    /**
     * Create a node renderer with the given context
     * @param context the rendering context
     * @return a node renderer instance
     */
    NodeRenderer create(TextContentNodeRendererContext context);
}

/**
 * Context for text content node rendering
 */
public interface TextContentNodeRendererContext {
    /**
     * Whether newlines should be stripped
     * @return true if newlines should be stripped
     */
    boolean stripNewlines();
    
    /**
     * Get the text content writer
     * @return the text content writer
     */
    TextContentWriter getWriter();
    
    /**
     * Render a child node
     * @param node the node to render
     */
    void render(Node node);
}

/**
 * Helper for writing text content
 */
public class TextContentWriter {
    /**
     * Create a text content writer that writes to the given appendable
     * @param out the appendable to write to
     */
    public TextContentWriter(Appendable out);
    
    /**
     * Write whitespace (space character)
     */
    public void whitespace();
    
    /**
     * Write a colon character
     */
    public void colon();
    
    /**
     * Write a line break
     */
    public void line();
    
    /**
     * Write text content, stripping newlines if configured
     * @param s the text to write
     */
    public void writeStripped(String s);
    
    /**
     * Write text content as-is
     * @param s the text to write
     */
    public void write(String s);
    
    /**
     * Write a single character
     * @param c the character to write
     */
    public void write(char c);
}

import org.commonmark.renderer.text.TextContentWriter;

// Custom text writer usage
StringBuilder output = new StringBuilder();
TextContentWriter writer = new TextContentWriter(output);

writer.write("Hello");
writer.whitespace();
writer.write("world");
writer.line();
writer.writeStripped("Text with\nnewlines"); // May strip newlines based on configuration

/**
 * Core text content renderer for built-in nodes
 */
public class CoreTextContentNodeRenderer extends AbstractVisitor implements NodeRenderer {
    /**
     * Create a core text content node renderer with the given context
     * @param context the rendering context
     */
    public CoreTextContentNodeRenderer(TextContentNodeRendererContext context);
    
    /**
     * Get the node types this renderer handles
     * @return set of node types
     */
    public Set<Class<? extends Node>> getNodeTypes();
    
    /**
     * Render the specified node
     * @param node the node to render
     */
    public void render(Node node);
    
    // Visit methods for all core node types (inherited from AbstractVisitor)
}

import org.commonmark.renderer.text.TextContentRenderer;
import org.commonmark.renderer.text.TextContentNodeRendererFactory;
import org.commonmark.renderer.text.TextContentNodeRendererContext;
import org.commonmark.renderer.NodeRenderer;
import org.commonmark.node.CustomNode;

// Custom text node renderer
public class CustomTextRenderer implements NodeRenderer {
    private final TextContentNodeRendererContext context;
    private final TextContentWriter writer;
    
    public CustomTextRenderer(TextContentNodeRendererContext context) {
        this.context = context;
        this.writer = context.getWriter();
    }
    
    @Override
    public Set<Class<? extends Node>> getNodeTypes() {
        return Collections.singleton(CustomNode.class);
    }
    
    @Override
    public void render(Node node) {
        CustomNode customNode = (CustomNode) node;
        
        writer.write("[CUSTOM: ");
        renderChildren(customNode);
        writer.write("]");
    }
    
    private void renderChildren(Node parent) {
        Node child = parent.getFirstChild();
        while (child != null) {
            context.render(child);
            child = child.getNext();
        }
    }
}

// Register custom text renderer
TextContentRenderer renderer = TextContentRenderer.builder()
    .nodeRendererFactory(context -> new CustomTextRenderer(context))
    .build();

// Demonstrate different rendering modes
Parser parser = Parser.builder().build();
Node document = parser.parse(
    "# Title\n\n" +
    "This is a paragraph with **bold** text and a [link](url).\n\n" +
    "- List item 1\n" +
    "- List item 2\n\n" +
    "```java\n" +
    "System.out.println(\"code\");\n" +
    "```"
);

// Default text rendering (preserves structure)
TextContentRenderer defaultRenderer = TextContentRenderer.builder().build();
String structured = defaultRenderer.render(document);
System.out.println("Structured:\n" + structured);

// Single-line text rendering
TextContentRenderer singleLineRenderer = TextContentRenderer.builder()
    .stripNewlines(true)
    .build();
String singleLine = singleLineRenderer.render(document);
System.out.println("Single line: " + singleLine);

// Convert Markdown to plain text for search indexing
String markdown = "# Article Title\n\nThis **article** discusses [CommonMark](url).";
Node document = parser.parse(markdown);
String plainText = textRenderer.render(document);
// Use plainText for full-text search, previews, etc.

// Generate single-line summary
TextContentRenderer summaryRenderer = TextContentRenderer.builder()
    .stripNewlines(true)
    .build();
String summary = summaryRenderer.render(document);
// Use summary for meta descriptions, previews, etc.

// Custom renderer to extract only headings
public class HeadingExtractor implements NodeRenderer {
    // Implementation that only renders heading text
}