# Processing Markdown

version 6.0.0-RC-1

Groovy has an optional `groovy-markdown` module which provides support for parsing CommonMark Markdown. The classes are found in the `groovy.markdown` package.

## 1. MarkdownSlurper

`MarkdownSlurper` parses Markdown text into a `MarkdownDocument` backed by nested lists and maps. Each node is a `Map` with a `type` key plus type-specific fields:

    def doc = new MarkdownSlurper().parseText('# Hello World')
    def h = doc.headings[0]
    assert h.level == 1
    assert h.text == 'Hello World'

The raw structure supports all standard Groovy list/map operations. The document also exposes convenience properties — `headings`, `codeBlocks`, `links`, `tables` — that recursively walk the tree.

### 1.1. Extracting code blocks

A common pattern when consuming LLM output is to pull fenced code blocks by language:

    def md = '''
        Some intro text.

        ```groovy
        println 'hi'
        ```

        ```sql
        SELECT 1
        ```
        '''.stripIndent()
    def doc = new MarkdownSlurper().parseText(md)
    def groovySnippets = doc.codeBlocks.findAll { it.lang == 'groovy' }*.text
    assert groovySnippets == ["println 'hi'\n"]

`codeBlocks` walks the entire tree, so blocks nested inside block quotes or list items are included.

### 1.2. Links

    def doc = new MarkdownSlurper().parseText('See [docs](https://example.com/docs).')
    def link = doc.links[0]
    assert link.href == 'https://example.com/docs'
    assert link.text == 'docs'

### 1.3. Sections

`section(headingText)` returns the nodes between the given heading and the next heading of equal or higher level — useful for parsing structured agent replies:

    def md = '''
        # Title

        ## Summary

        The work is on track.

        ## Next Steps

        - Item one
        - Item two
        '''.stripIndent()
    def doc = new MarkdownSlurper().parseText(md)
    def summary = doc.section('Summary')
    assert summary[0].type == 'paragraph'
    assert summary[0].children[0].value == 'The work is on track.'

    def next = doc.section('Next Steps')
    assert next[0].type == 'list'
    assert next[0].items*.text == ['Item one', 'Item two']

### 1.4. Tables (optional)

GFM-style tables are supported when the `org.commonmark:commonmark-ext-gfm-tables` jar is on the classpath. Call `enableTables(true)` on the slurper:

    def md = '''
        | name  | age |
        |-------|-----|
        | Alice | 30  |
        | Bob   | 25  |
        '''.stripIndent()
    def doc = new MarkdownSlurper().enableTables(true).parseText(md)
    def rows = doc.tables[0].rows
    assert rows[0].name == 'Alice'
    assert rows[0].age == '30'
    assert rows[1].name == 'Bob'

Each row is returned as a `Map` keyed by header.

### 1.5. Node types

type | fields
--- | ---
`heading` | `level`, `text`, `children`
`paragraph` | `children`
`code_block` | `lang`, `text`
`list` | `ordered`, `items` (`start` for ordered lists)
`list_item` | `text`, `children`
`block_quote` | `children`
`link` | `href`, `title`, `text`, `children`
`image` | `src`, `title`, `alt`
`text` | `value`
`inline_code` | `text`
`emphasis`, `strong` | `children`
`html_block`, `html_inline` | `text`
`thematic_break` | (no fields)
`hard_line_break`, `soft_line_break` | (no fields)
`table` | `headers`, `alignments`, `rows`

### 1.6. Untrusted input

Prefer parsing Markdown from trusted sources. Like the sibling `JsonSlurper` and `XmlSlurper`, `MarkdownSlurper` is a convenience parser, not a security boundary, so the safest choice is not to hand it attacker-controlled input. If you must, bound the input by size yourself before parsing and treat the parsed result defensively.

As a backstop, `MarkdownSlurper` caps how deeply a document may nest (both block containers and inline emphasis), so that a small but pathologically nested input — thousands of nested block quotes, or a long run of emphasis markers — is reported as a `MarkdownRuntimeException` rather than being allowed to exhaust the stack with a `StackOverflowError`. The limit defaults to `1000` and can be set per instance or globally via the `groovy.markdown.maxNestingDepth` system property; a value of `0` or less disables the check.

    def slurper = new MarkdownSlurper()
    slurper.maxNestingDepth = 100   // cap block nesting (default 1000; 0 disables the check)

    // a hostile, deeply nested document is rejected, not allowed to crash the parser
    def rejected = false
    try {
        slurper.parseText(('>' * 5000) + ' text')
    } catch (MarkdownRuntimeException ignored) {
        rejected = true
    }
    assert rejected

This cap is a robustness backstop, not a licence to treat the parser as hardened.