mirror of
https://github.com/larvit/adf-codec.git
synced 2026-11-18 22:25:44 +01:00
Refuse an inline card a link marks in every writer, before it writes
This commit is contained in:
@@ -4,6 +4,7 @@ import vm from 'node:vm'
|
||||
|
||||
import type { AdfDocument } from './document.ts'
|
||||
import type { JsonValue } from '../json-value.ts'
|
||||
import { adfToHtml, adfToLosslessMarkdown, adfToPortableMarkdown } from '../index.ts'
|
||||
import { adfDocumentFault, isAdfDocument, writableContent } from './document.ts'
|
||||
import { largestNesting } from '../nesting.ts'
|
||||
|
||||
@@ -129,3 +130,31 @@ test('opens every writer with the same checks: a document, version 1, and no mor
|
||||
const text = { content: [{ text: long, type: 'text' }, { text: long, type: 'text' }, { text: long, type: 'text' }], type: 'paragraph' }
|
||||
assert.equal(checked({ content: [text], type: 'doc', version: 1 }), 'unsupported-node-shape')
|
||||
})
|
||||
|
||||
test('refuses an inline card a link marks, wherever the document holds it and whichever call writes it', () => {
|
||||
const card = { attrs: { url: 'https://example.com/roadmap' }, marks: [{ attrs: { href: 'https://example.com/' }, type: 'link' }], type: 'inlineCard' }
|
||||
const paragraph = { content: [{ text: 'See ', type: 'text' }, card], type: 'paragraph' }
|
||||
const holders = [
|
||||
{ holder: paragraph, path: ['content', 0, 'content', 1] },
|
||||
{ holder: { content: [{ content: [paragraph], type: 'listItem' }], type: 'bulletList' }, path: ['content', 0, 'content', 0, 'content', 0, 'content', 1] },
|
||||
{ holder: { content: [paragraph], type: 'panel' }, path: ['content', 0, 'content', 0, 'content', 1] },
|
||||
{ holder: { content: [card, { text: 'x', type: 'text' }], marks: [{ attrs: { align: 'center' }, type: 'alignment' }], type: 'paragraph' }, path: ['content', 0, 'content', 0] },
|
||||
{ holder: { content: [{ content: [card], type: 'futureNode' }], type: 'futureBlock' }, path: ['content', 0, 'content', 0, 'content', 0] },
|
||||
]
|
||||
const writers = [adfToHtml, adfToLosslessMarkdown, adfToPortableMarkdown]
|
||||
for (const { holder, path } of holders) {
|
||||
for (const write of writers) {
|
||||
const refused = write({ content: [holder], type: 'doc', version: 1 })
|
||||
assert.equal(!refused.ok && refused.error.code, 'unsupported-node-shape')
|
||||
assert.deepEqual(!refused.ok && refused.error.path, path)
|
||||
assert.match(!refused.ok ? refused.error.message : '', /inlineCard.*link/)
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
test('writes a card holding no link mark, and a node type it does not know holding one', () => {
|
||||
const comment = { attrs: { annotationType: 'inlineComment', id: 'c1' }, type: 'annotation' }
|
||||
const link = { attrs: { href: 'https://example.com/' }, type: 'link' }
|
||||
const marked = { content: [{ attrs: { url: 'https://example.com/roadmap' }, marks: [comment], type: 'inlineCard' }, { marks: [link], type: 'futureInline' }], type: 'paragraph' }
|
||||
for (const write of [adfToHtml, adfToLosslessMarkdown, adfToPortableMarkdown]) assert.equal(write({ content: [marked], type: 'doc', version: 1 }).ok, true)
|
||||
})
|
||||
|
||||
@@ -55,6 +55,8 @@ export function writableContent(document: AdfDocument): Result<readonly AdfNode[
|
||||
if (fault !== undefined) return faulted(fault, [])
|
||||
if (document.version !== 1) return failure('unsupported-document-version', `no format this library writes carries ADF version ${document.version}`, [])
|
||||
if (document.content === undefined) return success(undefined)
|
||||
const refused = refusedShape(document.content)
|
||||
if (refused !== undefined) return refused
|
||||
// Text alone past the bound is refused before anything is written (docs/decisions.md §Output past V8's longest string is refused on every engine).
|
||||
return withinLongest(heldTextLength(document.content), document.content)
|
||||
}
|
||||
@@ -145,6 +147,25 @@ export function nodeMarks(node: { marks?: AdfMark[] }): readonly AdfMark[] {
|
||||
return node.marks ?? []
|
||||
}
|
||||
|
||||
// The writers' refusals of what Atlassian's schema forbids, in document order, at any depth and inside nodes no writer reads. Each rule stands on the schema alone.
|
||||
function refusedShape(content: readonly AdfNode[]): Result<never> | undefined {
|
||||
type Step = { index: number; node: AdfNode; parent: Step | undefined }
|
||||
const pending: Step[] = content.map((node, index) => ({ index, node, parent: undefined })).reverse()
|
||||
for (let step = pending.pop(); step !== undefined; step = pending.pop()) {
|
||||
if (step.node.type === 'inlineCard' && nodeMarks(step.node).some(({ type }) => type === 'link')) {
|
||||
const path: (number | string)[] = []
|
||||
for (let up: Step | undefined = step; up !== undefined; up = up.parent) path.unshift('content', up.index)
|
||||
return failure('unsupported-node-shape', 'an inlineCard takes no link mark: this one holds one', path)
|
||||
}
|
||||
const children = nodeContent(step.node)
|
||||
for (let index = children.length - 1; index >= 0; index -= 1) {
|
||||
const node = children[index]
|
||||
if (node !== undefined) pending.push({ index, node, parent: step })
|
||||
}
|
||||
}
|
||||
return undefined
|
||||
}
|
||||
|
||||
// Tracks ancestors alone: a tree may share an object, but an object holding itself walks the guards forever.
|
||||
function holdsItself(root: object): boolean {
|
||||
const pending = [{ depth: 0, item: root }]
|
||||
|
||||
@@ -277,12 +277,7 @@ test('shows a carried image marked by a link to another target as that link, the
|
||||
assert.equal(inline({ attrs: { href: 'https://example.com/', title: 5 }, type: 'link' }), '<a href="https://example.com/">The moon</a> (<a href="https://example.com/moon.jpg">image</a>)')
|
||||
})
|
||||
|
||||
test('links a card a link marks, inside a carried node, to that link\'s target alone', () => {
|
||||
const card: AdfNode = { attrs: { url: 'https://example.com/roadmap' }, marks: [{ attrs: { href: 'https://example.com/' }, type: 'link' }], type: 'inlineCard' }
|
||||
assert.equal(shown(html(adfToHtml(document({ content: [paragraph(card)], type: 'panel' })))), '<p><a href="https://example.com/">https://example.com/roadmap</a></p>')
|
||||
})
|
||||
|
||||
test('refuses an inline card a link marks, which Atlassian\'s schema does not allow', () => {
|
||||
test('refuses an inline card a link marks, which Atlassian\'s schema does not allow, inside a carried node too', () => {
|
||||
const marks: AdfMark[] = [{ attrs: { href: 'https://example.com/' }, type: 'link' }]
|
||||
const cards: AdfNode[] = [{ attrs: { url: 'https://example.com/roadmap' }, marks, type: 'inlineCard' }, { attrs: { data: { name: 'Roadmap', url: 'https://example.com/roadmap' } }, marks, type: 'inlineCard' }]
|
||||
for (const card of cards) {
|
||||
@@ -291,6 +286,8 @@ test('refuses an inline card a link marks, which Atlassian\'s schema does not al
|
||||
assert.deepEqual(!refused.ok && refused.error.path, ['content', 0, 'content', 1])
|
||||
assert.match(!refused.ok ? refused.error.message : '', /inlineCard.*link/)
|
||||
}
|
||||
const carried = adfToHtml(document({ content: [paragraph(cards[0] ?? text('x'))], type: 'panel' }))
|
||||
assert.deepEqual(!carried.ok && carried.error.path, ['content', 0, 'content', 0, 'content', 0])
|
||||
const nested = adfToHtml(document({ content: [{ content: [paragraph(cards[0] ?? text('x'))], type: 'listItem' }], type: 'bulletList' }))
|
||||
assert.deepEqual(!nested.ok && nested.error.path, ['content', 0, 'content', 0, 'content', 0, 'content', 0])
|
||||
})
|
||||
|
||||
@@ -5,17 +5,13 @@ import { elementOfMark } from '../mark-elements.ts'
|
||||
import { holdsOnlyAttributes, isSpellableText, isUnmarkedSpellableText, nodeAttrs, nodeContent, nodeMarks } from '../../adf/document.ts'
|
||||
import { linkAttrs } from '../../adf/mark-attributes.ts'
|
||||
import { nodeElement } from './node-element.ts'
|
||||
import { failure, success, type ConvertErrorPath, type Result } from '../../result.ts'
|
||||
import { success, type ConvertErrorPath, type Result } from '../../result.ts'
|
||||
import { writableValue } from '../escaping.ts'
|
||||
|
||||
export function inlineHtml(nodes: readonly AdfNode[], path: ConvertErrorPath): Result<string> {
|
||||
let html = ''
|
||||
let afterPlainText = false
|
||||
for (const [index, node] of nodes.entries()) {
|
||||
// Refused, not carried: Atlassian's schema gives a card no link mark. A carried block never reaches here.
|
||||
if (node.type === 'inlineCard' && nodeMarks(node).some(({ type }) => type === 'link')) {
|
||||
return failure('unsupported-node-shape', 'an inlineCard takes no link mark: this one holds one', [...path, 'content', index])
|
||||
}
|
||||
// Two unmarked text nodes side by side read back as one, so the second rides the carry.
|
||||
const written: string | undefined = afterPlainText && isUnmarkedSpellableText(node) ? undefined : tryInlineNode(node)
|
||||
if (written === undefined) {
|
||||
|
||||
@@ -230,7 +230,6 @@ test('spells an inline node as its text', () => {
|
||||
|
||||
test('spells a card as a link to its url, or to its data url named by its data name, else a note', () => {
|
||||
assert.equal(portable(paragraph(node('inlineCard', { url: 'https://example.com' }))), '<https://example.com>\n')
|
||||
assert.equal(portable(paragraph({ ...node('inlineCard', { url: 'https://example.com' }), marks: [strong, link('https://other.com')] })), '**<https://example.com>**\n')
|
||||
assert.equal(portable(paragraph(text('see '), node('inlineCard', { data: {} }))), 'see _(link card not included)_\n')
|
||||
assert.equal(portable(paragraph(node('inlineCard', { data: { name: 'Spec', url: 'https://e.com/s' } }), text(' '), node('inlineCard', { data: { url: 'https://e.com/u' } }))), '[Spec](https://e.com/s) <https://e.com/u>\n')
|
||||
assert.equal(portable(paragraph(node('inlineCard', { data: { name: 'Spec' } }), text(' '), node('inlineCard', { data: ['x'] }))), 'Spec _(link card not included)_\n')
|
||||
|
||||
Reference in New Issue
Block a user