{
const txt = `[ ] W\n - > [ ] A\n | [ ] X\n - [ ] Y`;
const {html, warnings} = renderFolded(txt);
expect(html).not.toContain('>X<');
expect(warnings).toEqual([{type: 'mixedGate', line: 3, label: 'A'}]);
});
it('lässt den günstigsten Pfad unberührt — Faltung ist reine Ansicht', () => {
const r = roots(`[ ] W (XS)\n - > [ ] A (S)\n | [ ] A1 (XL)\n | [ ] A2 (S)`);
expect([...computeCheapSet(r)].map(n => n.label).sort())
.toEqual(['A', 'A2', 'W']);
});
});
/* Der eingeklappte Knoten vertritt seinen Teilbaum auch auf dem günstigsten
Pfad (SPEC §9, D38-Nachtrag): Sonst überspränge die Pfad-Linie den ganzen
Zweig, als wäre dort nichts zu tun. */
describe('Günstigster Pfad an eingeklappten Knoten', () => {
/* Nimmt die BEREITS geparsten Wurzeln: `collapsedSet` und `cheapSet` prüfen
auf Objektidentität — ein zweiter Parse-Durchlauf liefert andere Objekte
und die Mengen träfen nie zu (dieselbe Falle wie in D28). */
const cheapRender = (r, collapsedSet) =>
renderTreeHtml(r, {t, showDiscarded: false, cheapPath: true,
cheapSet: computeCheapSet(r), collapsedSet: collapsedSet || new Set()}).html;
/* Labels der Stationen (`cheap-leaf`) in Dokumentreihenfolge — genau die
Menge, durch die drawCheapPath() die Linie fädelt. Gelesen aus dem
`aria-label` (erstes Glied = Label): Im Knoteninneren steht bei
eingeklappten Knoten das Falt-Zeichen vor dem Text. */
const stations = html =>
[...html.matchAll(/class="node[^"]*cheap-leaf[^"]*"[^>]*aria-label="([^",]*)/g)]
.map(m => m[1]);
const TXT = `[ ] W (XS)\n - [ ] A (S)\n - [ ] A1 (S)\n - [ ] A2 (S)\n - [ ] B (S)`;
it('macht den eingeklappten Knoten zur Station statt den Zweig zu überspringen', () => {
const r = roots(TXT);
const a = r[0].children[0];
expect(stations(cheapRender(r))).toEqual(['A1', 'A2', 'B']); /* offen */
expect(stations(cheapRender(r, new Set([a])))).toEqual(['A', 'B']); /* zu */
});
it('gibt die Station beim Aufklappen wieder an die Kinder ab', () => {
const r = roots(TXT);
const a = r[0].children[0];
const zu = stations(cheapRender(r, new Set([a])));
const auf = stations(cheapRender(r, new Set()));
expect(zu).not.toContain('A1');
expect(auf).toContain('A1');
expect(auf).not.toContain('A');
});
it('vertritt auch einen Teilbaum, den der Knoten selbst nicht braucht', () => {
/* `+ O` ist entbehrlich und nicht auf dem Pfad — sein Kind wird aber per
Abhängigkeit gezogen (D42). Eingeklappt ist `O` der einzige sichtbare
Griff darauf und darf deshalb weder fehlen noch ausgeblasst sein. */
const txt = `[ ] W (XS)\n - [ ] N (S) :#t\n + [ ] O (S)\n - [ ] #t: T (S)`;
const r = roots(txt);
const o = r[0].children[1];
const set = computeCheapSet(r);
expect([...set].map(n => n.label).sort()).toEqual(['N', 'T', 'W']); /* O selbst nicht */
const {html} = renderTreeHtml(r, {t, showDiscarded: false, cheapPath: true,
cheapSet: set, collapsedSet: new Set([o])});
expect(stations(html)).toContain('O');
});
it('macht einen eingeklappten Knoten ohne Pfad im Teilbaum NICHT zur Station', () => {
const txt = `[ ] W (XS)\n - [ ] N (S)\n + [ ] O (S)\n - [ ] P (S)`;
const r = roots(txt);
const o = r[0].children[1];
const {html} = renderTreeHtml(r, {t, showDiscarded: false, cheapPath: true,
cheapSet: computeCheapSet(r), collapsedSet: new Set([o])});
expect(stations(html)).toEqual(['N']);
});
});
/* Voreinstellung „unter Größe M zuklappen" im Diagramm-Kopf (SPEC §9, D44).
Das Falten selbst liegt in app.js (kein headless-Testziel); geprüft wird
das Prädikat, das entscheidet, WELCHE Knoten es trifft. */
describe('atMostM — Auswahl für „Größe M und kleiner zuklappen"', () => {
const groessen = txt => roots(txt).map(n => [n.label, atMostM(n)]);
it('trifft XS, S und M — offen bleiben nur L, XL, XXL', () => {
expect(groessen('[ ] a (XS)\n[ ] b (S)\n[ ] c (M)\n[ ] d (L)\n[ ] e (XL)\n[ ] f (XXL)'))
.toEqual([['a', true], ['b', true], ['c', true], ['d', false],
['e', false], ['f', false]]);
});
it('trifft Knoten OHNE Größenangabe nicht', () => {
/* Der günstigste Pfad rechnet fehlende Größen als M (D18) — das ist eine
Kostenannahme, keine Aussage des Autors, und faltet hier nichts zu. */
expect(groessen('[ ] ohne')).toEqual([['ohne', false]]);
});
it('ist von Status und Optionalität unabhängig', () => {
expect(groessen('[x] a (S)\n[-] b (S)\n[ ] c (L)').map(([, b]) => b))
.toEqual([true, true, false]);
});
it('gilt auch für Knoten tief im Baum', () => {
const [w] = roots('[ ] W (XL)\n - [ ] A (M)\n - [ ] A1 (XS)\n - [ ] B (L)');
expect([atMostM(w), ...w.children.map(atMostM)]).toEqual([false, true, false]);
expect(atMostM(w.children[0].children[0])).toBe(true);
});
});
/* Zeile -> sichtbarer Vertreter (SPEC §9, D38-Nachtrag 4): Liegt der Knoten
der Cursor-Zeile in einem eingeklappten Teilbaum, vertritt ihn der nächste
sichtbare Vorfahr — für die Hervorhebung wie für den Alt+Klick. */
import { lineTargets } from '../src/model.js';
describe('lineTargets — der eingeklappte Knoten vertritt seine Zeilen', () => {
const byLabel = (ns, label) => {
for(const n of ns){
if(n.label === label) return n;
const hit = byLabel(n.children, label);
if(hit) return hit;
}
return null;
};
const txt = 'A\n - B\n - C\n - D\n - [-] E\n - F';
it('sichtbare Knoten zeigen auf sich selbst', () => {
const r = roots(txt);
const map = lineTargets(r, new Set(), true);
expect(map.get(1)).toBe(1);
expect(map.get(3)).toBe(3);
});
it('Zeilen unter einem eingeklappten Knoten zeigen auf ihn', () => {
const r = roots(txt);
const map = lineTargets(r, new Set([byLabel(r, 'B')]), true);
expect(map.get(2)).toBe(2); /* der eingeklappte selbst ist sichtbar */
expect(map.get(3)).toBe(2);
expect(map.get(4)).toBe(2);
});
it('bei verschachtelter Faltung gilt der ÄUSSERSTE eingeklappte Vorfahr', () => {
const r = roots(txt);
const map = lineTargets(r, new Set([byLabel(r, 'B'), byLabel(r, 'C')]), true);
expect(map.get(4)).toBe(2);
});
it('Beschreibungs- und Fortsetzungszeilen wandern mit ihrem Knoten', () => {
const t2 = 'A\n - B mit einem \\\n langen Titel\n " Notiz';
const r = roots(t2);
const map = lineTargets(r, new Set([byLabel(r, 'A')]), true);
expect(map.get(3)).toBe(1); /* Fortsetzung */
expect(map.get(4)).toBe(1); /* "-Zeile */
});
it('ausgeblendete verworfene Elemente fehlen — sie heben weiter nichts hervor', () => {
const r = roots(txt);
expect(lineTargets(r, new Set(), false).has(6)).toBe(false);
expect(lineTargets(r, new Set(), true).get(6)).toBe(6);
});
});
/* Falt-Voreinstellungen des Durchschalters (SPEC §9, D75): je Modus ein
VOLLSTÄNDIGER Faltzustand als Menge der zuzuklappenden Knoten. */
describe('presetFoldSet — die vier Voreinstellungen', () => {
const PLAN = `[ ] #w: Wurzel
- [ ] #a: Gross (L)
- [ ] #a1: Mittel (M)
- [ ] #a1a: Blatt (S)
- [ ] #a2: Ohne Groesse
- [ ] Blatt 2
+ [?] #b: Zugabe (M)
- [?] #b1: Blatt 3`;
const collapsed = (mode, cheapSet) => {
const r = roots(PLAN);
return [...presetFoldSet(r, mode, cheapSet ?? computeCheapSet(r))]
.map(n => n.label).sort();
};
it("'small' klappt jeden faltbaren Knoten mit angegebener Groesse <= M zu", () => {
/* `Mittel` (M) und `Zugabe` (M); `Ohne Groesse` bleibt offen — keine
Autoren-Aussage (D44) — und `Gross` (L) sowieso. */
expect(collapsed('small')).toEqual(['Mittel', 'Zugabe']);
});
it("'path' klappt jeden Knoten zu, durch dessen Teilbaum der Pfad nicht laeuft", () => {
/* Die unangetastete Zugabe liegt nie auf dem Pfad (D29/D61) — sie ist der
einzige faltbare Knoten ohne Pfad im Teilbaum. */
expect(collapsed('path')).toEqual(['Zugabe']);
});
it("'path' laesst einen Knoten offen, sobald ein UNTERKNOTEN auf dem Pfad liegt", () => {
const r = roots(`[ ] Wurzel\n + [?] Zweig\n - [ ] #ziel: Gebraucht (S)\n - [ ] Braucht was (S) :#ziel`);
/* `#ziel` wird per Abhaengigkeit gezogen (D42) — der Zweig darueber traegt
Pfad im Teilbaum und bleibt offen, obwohl er selbst nicht gebraucht wird. */
expect([...presetFoldSet(r, 'path', computeCheapSet(r))].map(n => n.label))
.toEqual([]);
});
it("'closed' klappt alle faltbaren Knoten zu, 'open' keinen", () => {
expect(collapsed('closed'))
.toEqual(['Gross', 'Mittel', 'Ohne Groesse', 'Wurzel', 'Zugabe']);
expect(collapsed('open')).toEqual([]);
});
});
/* Der eingeklappte Knoten vertritt seinen Teilbaum auch für die
Querverbindungen (SPEC §9, D75): IDs und Abhaengigkeiten der verborgenen
Knoten haengen als data-sub-ids/data-sub-deps am Vertreter. */
describe('Renderer — data-sub-ids/data-sub-deps am eingeklappten Knoten', () => {
const PLAN = `[ ] Wurzel
- [ ] #box: Zweig
- [ ] #box.a: Drin :#ziel
- [ ] #box.b: Auch drin :#ziel,#box.a
- [ ] #ziel: Draussen`;
it('sammelt IDs (Dokumentreihenfolge) und Abhaengigkeiten (dedupliziert)', () => {
const r = roots(PLAN);
const zweig = r[0].children[0];
const html = renderTreeHtml(r, {t, showDiscarded: false, cheapPath: false,
cheapSet: new Set(), collapsedSet: new Set([zweig])}).html;
expect(html).toContain('data-sub-ids="box.a box.b"');
/* #ziel und #box.a je einmal, obwohl #ziel zweimal gebraucht wird. */
expect(html).toContain('data-sub-deps="ziel box.a"');
});
it('haengt an offene Knoten keine sub-Attribute', () => {
const html = render(PLAN).html;
expect(html).not.toContain('data-sub-ids');
expect(html).not.toContain('data-sub-deps');
});
it('sammelt ausgeblendete verworfene Knoten NICHT mit — deren Kanten entfallen weiter', () => {
const r = roots(`[ ] Wurzel\n - [ ] #box: Zweig\n - [-] #weg: Verworfen :#ziel\n - [ ] #ziel: Draussen`);
const zweig = r[0].children[0];
const html = renderTreeHtml(r, {t, showDiscarded: false, cheapPath: false,
cheapSet: new Set(), collapsedSet: new Set([zweig])}).html;
expect(html).not.toContain('data-sub-ids');
expect(html).not.toContain('data-sub-deps');
});
});