3
0
mirror of https://github.com/larvit/adf-codec.git synced 2026-11-16 13:30:24 +01:00

Give the directive grammar, flavours and reader failures one place each

This commit is contained in:
2026-10-21 23:43:05 +02:00
committed by Lillem4n
parent db10287cae
commit b080410852
37 changed files with 212 additions and 189 deletions
+9 -10
View File
@@ -3,15 +3,14 @@ import test from 'node:test'
import type { Block } from './blocks.ts'
import type { LinkDefinition } from '../commonmark/link-syntax.ts'
import { flavourClaims } from '../portable/conventions.ts'
import { parseBlocks } from './blocks.ts'
function definitions(markdown: string): [string, LinkDefinition][] {
return [...parseBlocks(markdown, flavourClaims.lossless).definitions]
return [...parseBlocks(markdown, 'lossless').definitions]
}
function kinds(markdown: string): string[] {
return parseBlocks(markdown, flavourClaims.lossless).blocks.map((block) => block.kind)
return parseBlocks(markdown, 'lossless').blocks.map((block) => block.kind)
}
function faults(markdown: string): string[] {
@@ -24,7 +23,7 @@ function faults(markdown: string): string[] {
if (block.kind === 'bulletList' || block.kind === 'orderedList') for (const item of block.items) walk(item)
}
}
walk(parseBlocks(markdown, flavourClaims.lossless).blocks)
walk(parseBlocks(markdown, 'lossless').blocks)
return messages
}
@@ -90,7 +89,7 @@ test('opens a container where the content model takes content, and holds it open
assert.deepEqual(faults('!adf:panel info\n> Part.\n!adf:/panel\n'), [])
assert.deepEqual(faults('!adf:panel info\n- !adf:panel warning\n Part.\n !adf:/panel\n!adf:/panel\n'), [])
assert.deepEqual(faults('!adf:panel info\n```\n!adf:/panel\n```\n!adf:/panel\n'), [])
assert.deepEqual(parseBlocks('!adf:panel info {panelColor="#ff0000"}\nPart.\n!adf:/panel\n', flavourClaims.lossless).blocks, [
assert.deepEqual(parseBlocks('!adf:panel info {panelColor="#ff0000"}\nPart.\n!adf:/panel\n', 'lossless').blocks, [
{
argument: 'info',
attributes: new Map([['panelColor', { decoded: '#ff0000', spelling: '"#ff0000"' }]]),
@@ -100,7 +99,7 @@ test('opens a container where the content model takes content, and holds it open
position: { line: 1, offset: 0 },
},
])
assert.deepEqual(parseBlocks('!adf:rule\n', flavourClaims.lossless).blocks, [
assert.deepEqual(parseBlocks('!adf:rule\n', 'lossless').blocks, [
{ argument: undefined, attributes: new Map(), blocks: undefined, kind: 'directive', name: 'rule', position: { line: 1, offset: 0 } },
])
})
@@ -125,7 +124,7 @@ test("releases an indented code block's held blank lines as a walk rather than a
// A level is one list item.
function deepestItem(markdown: string): { depth: number; kinds: string[] } {
let blocks = parseBlocks(markdown, flavourClaims.lossless).blocks
let blocks = parseBlocks(markdown, 'lossless').blocks
let depth = 0
for (let list = blocks[0]; list?.kind === 'bulletList'; list = blocks[0]) {
blocks = list.items.at(-1) ?? []
@@ -148,7 +147,7 @@ test('stops a blank line at the first blockquote', () => {
test('stops a blank line at an empty item, and gives a code block in an item the blank line without its spaces', () => {
assert.deepEqual(deepestItem('- - \n\n a\n'), { depth: 2, kinds: [] })
assert.deepEqual(parseBlocks('- ```\n \n x\n ```\n', flavourClaims.lossless).blocks.map((block) => block.kind === 'bulletList' && block.items[0]?.[0]), [
assert.deepEqual(parseBlocks('- ```\n \n x\n ```\n', 'lossless').blocks.map((block) => block.kind === 'bulletList' && block.items[0]?.[0]), [
{ kind: 'code', language: '', position: { line: 1, offset: 0 }, text: '\nx' },
])
})
@@ -166,7 +165,7 @@ function outline(blocks: readonly Block[]): string {
}
test('reads a marker a tab indents four or more columns into its container as text', () => {
const read = (markdown: string): string => outline(parseBlocks(markdown, flavourClaims.lossless).blocks)
const read = (markdown: string): string => outline(parseBlocks(markdown, 'lossless').blocks)
assert.equal(read('> a\n \t> b\n'), 'quote(paragraph(a|> b))')
assert.equal(read('> > a\n>\t\t> b\n'), 'quote(quote(paragraph(a|> b)))')
assert.equal(read('- > a\n\t\t> b\n'), 'list(quote(paragraph(a|> b)))')
@@ -174,7 +173,7 @@ test('reads a marker a tab indents four or more columns into its container as te
})
test("keeps as spaces the columns a tab holds past an item's indentation", () => {
const read = (markdown: string): string => outline(parseBlocks(markdown, flavourClaims.lossless).blocks)
const read = (markdown: string): string => outline(parseBlocks(markdown, 'lossless').blocks)
assert.equal(read('- ```\n\tx\n ```\n'), 'list(code(" x"))')
assert.equal(read('- a\n \t- b\n'), 'list(paragraph(a) list(paragraph(b)))')
})
+7 -6
View File
@@ -1,6 +1,6 @@
import type { Claims } from '../portable/conventions.ts'
import type { Claims, Flavour } from '../flavour.ts'
import type { ConvertFault, SourcePosition } from '../../result.ts'
import type { DirectiveAttributes, DirectiveLine } from '../directive-syntax.ts'
import type { DirectiveAttributes, DirectiveLine } from '../directive/syntax.ts'
import type { LinkDefinition } from '../commonmark/link-syntax.ts'
import {
atxHeading,
@@ -20,8 +20,9 @@ import {
type ThematicBreakTail,
} from '../commonmark/grammar.ts'
import { barePipeCells, isDelimiterRow, isPipeAlignment, malformedPipeTable, pipeCells } from '../pipe-table-syntax.ts'
import { blockDirectiveForm } from '../block-directive.ts'
import { directiveEscape, malformedDirective, readDirectiveLine, spellDirectiveCloser } from '../directive-syntax.ts'
import { blockDirectiveForm } from '../directive/block.ts'
import { directiveEscape, malformedDirective, readDirectiveLine, spellDirectiveCloser } from '../directive/syntax.ts'
import { flavourClaims } from '../flavour.ts'
import { readLinkDefinitions } from '../commonmark/link-reference-definitions.ts'
export type Block = { position: SourcePosition } & (
@@ -90,10 +91,10 @@ const indentedCodeColumns = 4
const largestOpenerIndentation = 3
const tabStop = 4
export function parseBlocks(markdown: string, claims: Claims): ParsedBlocks {
export function parseBlocks(markdown: string, flavour: Flavour): ParsedBlocks {
const walk: Walk = {
blocks: [],
claims,
claims: flavourClaims[flavour],
definitions: new Map(),
endedLists: new Set(),
leaf: undefined,
+10 -9
View File
@@ -1,6 +1,6 @@
import type { AdfMark, AdfNode } from '../../adf/document.ts'
import type { ClaimedPrefix, DirectiveSpan, NestedSpans } from '../directive-syntax.ts'
import type { Claims } from '../portable/conventions.ts'
import type { ClaimedPrefix, DirectiveSpan, NestedSpans } from '../directive/syntax.ts'
import type { Claims, Flavour } from '../flavour.ts'
import type { EmphasisPairing } from '../commonmark/emphasis-matching.ts'
import type { InlineSource, InlineToken } from '../inline-tokens.ts'
import type { LineContainer } from '../line-container.ts'
@@ -9,19 +9,20 @@ import { centeredImage, externalMedia } from '../external-image.ts'
import { commonMarkLink, linkHref, linkMark } from '../mark-spellings.ts'
import { decodeTextEscapes, trimTrailingSpace } from '../commonmark/grammar.ts'
import { failure, faulted, success, type ConvertErrorPath, type Result } from '../../result.ts'
import { flavourClaims } from '../flavour.ts'
import { highlightDelimiter } from '../portable/conventions.ts'
import { identicalMarks, mergeAdjacentText, nodeAttrs, nodeMarks } from '../../adf/document.ts'
import { inlineNodeModel, takesMark } from '../../adf/inline-nodes.ts'
import { joinsWhenRead, textBreakName, textBreakSpelling } from '../adjacent-text.ts'
import { matchEmphasis } from '../commonmark/emphasis-matching.ts'
import { normalizeLabel, readInlineTarget, readLabel } from '../commonmark/link-syntax.ts'
import { noSpans, readInlineDirective } from '../directive-syntax.ts'
import { openingLinkTakesDirective } from '../emit/inline-line.ts'
import { noSpans, readInlineDirective } from '../directive/syntax.ts'
import { openingLinkTakesDirective } from '../emit/spelling-questions.ts'
import { readCarriedInline } from '../opaque-carry.ts'
import { readDirectiveMark } from './directive-marks.ts'
import { readInlineDirectiveNode } from './directive-nodes.ts'
import { readDirectiveMark } from '../directive/marks.ts'
import { readInlineDirectiveNode } from '../directive/nodes.ts'
import { inlineSource, readInlineToken } from '../inline-tokens.ts'
import { readTextDirective } from '../text-directive.ts'
import { readTextDirective } from '../directive/text.ts'
// Only a `paragraph` block takes `image`, the `mediaSingle` a lone image builds; every other container takes `nodes`, where the image is its linked alt text.
export type InlineContent = { image?: AdfNode; nodes: AdfNode[] }
@@ -89,8 +90,8 @@ const spellableLink = 'link takes the directive form only where CommonMark canno
const textBreak: TextBreak = { kind: 'textBreak' }
// The outermost content: only here does a text break see both its neighbours.
export function parseInlineContent(source: string, definitions: LinkDefinitions, path: ConvertErrorPath, container: LineContainer, claims: Claims): Result<InlineContent> {
const scan = freshScan(source, { definitions, path }, { claims, container, inLink: false, spans: noSpans })
export function parseInlineContent(source: string, definitions: LinkDefinitions, path: ConvertErrorPath, container: LineContainer, flavour: Flavour): Result<InlineContent> {
const scan = freshScan(source, { definitions, path }, { claims: flavourClaims[flavour], container, inLink: false, spans: noSpans })
const scanned = scanInline(scan)
if (!scanned.ok) return scanned
const nodes = partText(scanned.value.nodes, scan)
+24 -23
View File
@@ -1,23 +1,24 @@
import type { AdfDocument, AdfNode } from '../../adf/document.ts'
import type { Block, DirectiveBlock } from './blocks.ts'
import type { BlockDirectiveNode } from './directive-nodes.ts'
import type { Claims } from '../portable/conventions.ts'
import type { BlockDirectiveNode } from '../directive/nodes.ts'
import type { ConvertFault } from '../../result.ts'
import type { Flavour } from '../flavour.ts'
import type { LineContainer } from '../line-container.ts'
import type { LinkDefinitions } from './inline-content.ts'
import { carryFenceType, readCarriedBlock } from '../opaque-carry.ts'
import { commonMarkSpelling, type SpellingMemo } from '../emit/adf-to-markdown.ts'
import { documentAttribute, documentName, documentSpelling } from '../block-directive.ts'
import { commonMarkSpelling, type SpellingMemo } from '../emit/spelling-questions.ts'
import { documentAttribute, documentName, documentSpelling } from '../directive/block.ts'
import { emptyKeys, nodeAttrs, nodeContent } from '../../adf/document.ts'
import { failure, faulted, positioned, success, type ConvertErrorPath, type ParseError, type Result, type SourcePosition } from '../../result.ts'
import { flavourClaims, leadingMarker, readAlertMarker, readTaskMarker } from '../portable/conventions.ts'
import { flavourClaims } from '../flavour.ts'
import { languageSlot } from '../code-language.ts'
import { largestNesting } from '../../nesting.ts'
import { leadingMarker, readAlertMarker, readTaskMarker } from '../portable/conventions.ts'
import { mintTaskIds } from '../portable/task-ids.ts'
import { parseBlocks } from './blocks.ts'
import { parseInlineContent } from './inline-content.ts'
import { readBlockDirectiveNode } from './directive-nodes.ts'
import { spellStringAttribute, unsupportedNodeShape } from '../directive-syntax.ts'
import { readBlockDirectiveNode } from '../directive/nodes.ts'
import { spellStringAttribute, unsupportedNodeShape } from '../directive/syntax.ts'
import { spellsEmpty } from '../empty-keys.ts'
import { splitPlace, splitTaskList } from '../portable/task-list.ts'
import { withinEngineLimits } from '../length-bound.ts'
@@ -30,40 +31,40 @@ type TaskParagraph = { kind: 'taskParagraph'; position: SourcePosition; text: st
type ReadBlock = Block | TaskParagraph
// `inExpand` is whether an expand holds the blocks, which makes a folded callout a nestedExpand.
type Reading = { claims: Claims; definitions: LinkDefinitions; inExpand: boolean; memo: SpellingMemo }
type Reading = { definitions: LinkDefinitions; flavour: Flavour; inExpand: boolean; memo: SpellingMemo }
export function commonMarkToAdf(markdown: string): Result<AdfDocument, ParseError> {
return readDocument(markdown, flavourClaims.commonmark)
return readDocument(markdown, 'commonmark')
}
export function losslessMarkdownToAdf(markdown: string): Result<AdfDocument, ParseError> {
return readDocument(markdown, flavourClaims.lossless)
return readDocument(markdown, 'lossless')
}
export function portableMarkdownToAdf(markdown: string): Result<AdfDocument, ParseError> {
return readDocument(markdown, flavourClaims.portable)
return readDocument(markdown, 'portable')
}
function readDocument(markdown: string, claims: Claims): Result<AdfDocument, ParseError> {
function readDocument(markdown: string, flavour: Flavour): Result<AdfDocument, ParseError> {
return positioned(
withinEngineLimits(() => readMarkdown(markdown, claims)),
withinEngineLimits(() => readMarkdown(markdown, flavour)),
{ line: 1, offset: 0 },
)
}
function readMarkdown(markdown: string, claims: Claims): Result<AdfDocument> {
function readMarkdown(markdown: string, flavour: Flavour): Result<AdfDocument> {
if (typeof markdown !== 'string') return failure('not-a-string', `markdown is a string: found ${typeName(markdown)}`, [])
const parsed = parseBlocks(markdown, claims)
const parsed = parseBlocks(markdown, flavour)
const [only] = parsed.blocks
if (parsed.blocks.length === 1 && only?.kind === 'directive' && only.name === documentName) {
const fault = documentFault(only)
return fault === undefined ? success({ type: 'doc', version: 1 }) : positioned(faulted(fault, []), only.position)
}
const reading: Reading = { claims, definitions: parsed.definitions, inExpand: false, memo: new Map() }
const reading: Reading = { definitions: parsed.definitions, flavour, inExpand: false, memo: new Map() }
const content = readBlocks(parsed.blocks, reading, [], 0)
if (!content.ok) return content
const document: AdfDocument = { content: content.value, type: 'doc', version: 1 }
if (claims.taskMarkers) mintTaskIds(document, markdown)
if (flavourClaims[flavour].taskMarkers) mintTaskIds(document, markdown)
return success(document)
}
@@ -84,7 +85,7 @@ function readBlocks(blocks: readonly ReadBlock[], reading: Reading, path: Conver
const fault = documentFault(block) ?? unsupportedNodeShape(`delete the ${documentSpelling} line to give the document content: it stands only as the whole document`)
return positioned(faulted(fault, nodePath), block.position)
}
if (block.kind === 'bulletList' && reading.claims.taskMarkers) {
if (block.kind === 'bulletList' && flavourClaims[reading.flavour].taskMarkers) {
const listed = positioned(bulletBlocks(block.items, reading, nodePath, depth), block.position)
if (!listed.ok) return listed
for (const node of listed.value) content.push(node)
@@ -113,7 +114,7 @@ function documentFault(block: DirectiveBlock): ConvertFault | undefined {
function readBlock(block: ReadBlock, reading: Reading, path: ConvertErrorPath, depth: number): Result<AdfNode> {
switch (block.kind) {
case 'blockquote':
return reading.claims.alerts ? quoteNode(block.blocks, reading, path, depth) : containerNode({ type: 'blockquote' }, block.blocks, reading, path, depth)
return flavourClaims[reading.flavour].alerts ? quoteNode(block.blocks, reading, path, depth) : containerNode({ type: 'blockquote' }, block.blocks, reading, path, depth)
case 'bulletList':
// readBlocks reads a portable task list before it reaches here.
return listNode({ type: 'bulletList' }, block.items, reading, path, depth)
@@ -165,7 +166,7 @@ function quoteNode(blocks: readonly Block[], reading: Reading, path: ConvertErro
const { folded, panelType } = led.marker
const { line, rest } = markerLine(led.text)
if (!folded) return filledNode({ attrs: { panelType }, type: 'panel' }, readBlocks([...paragraphsOf(led.position, line, rest), ...body], reading, path, depth + 1))
const title = parseInlineContent(line, reading.definitions, path, 'paragraph', reading.claims)
const title = parseInlineContent(line, reading.definitions, path, 'paragraph', reading.flavour)
if (!title.ok) return title
const text = titleText(title.value.nodes)
const type = reading.inExpand ? 'nestedExpand' : 'expand'
@@ -369,7 +370,7 @@ function listNode(node: AdfNode, items: readonly Block[][], reading: Reading, pa
}
function codeBlockNode(language: string, text: string, reading: Reading, path: ConvertErrorPath, depth: number): Result<AdfNode> {
const carriedType = reading.claims.carryFence ? carryFenceType(language) : undefined
const carriedType = flavourClaims[reading.flavour].carryFence ? carryFenceType(language) : undefined
if (carriedType !== undefined) {
const carried = readCarriedBlock(carriedType, text, depth)
return carried.fault === undefined ? success(carried.value) : faulted(carried.fault, path)
@@ -380,14 +381,14 @@ function codeBlockNode(language: string, text: string, reading: Reading, path: C
// spec/flavour.md, The CommonMark image: only a `paragraph` block gives a lone image the block it needs.
function paragraphNode(text: string, reading: Reading, path: ConvertErrorPath): Result<AdfNode> {
const content = parseInlineContent(text, reading.definitions, path, 'paragraph', reading.claims)
const content = parseInlineContent(text, reading.definitions, path, 'paragraph', reading.flavour)
if (!content.ok) return content
const image = content.value.image
return success(image === undefined ? withContent({ type: 'paragraph' }, content.value.nodes) : image)
}
function contentNode(node: AdfNode, text: string, reading: Reading, path: ConvertErrorPath, container: LineContainer): Result<AdfNode> {
const content = parseInlineContent(text, reading.definitions, path, container, reading.claims)
const content = parseInlineContent(text, reading.definitions, path, container, reading.flavour)
if (!content.ok) return content
return success(withContent(node, content.value.nodes))
}