debug - bhsd-harry/wikiparser-node GitHub Wiki

// Shadow.run (Node.js)
var {Shadow} = require("../util/debug"),
	{Token} = require("../src/index");
var token = Shadow.run(() => new Token());
assert.ok(token.getAttribute("built"));
assert.ok(!Shadow.running);

// isToken (Node.js)
var {isToken} = require("../util/debug"),
	{Token} = require("../src/index");
var isPlain = isToken("plain"),
	isRoot = isToken("root"),
	token = new Token();
assert.ok(isPlain(token));
assert.ok(!isRoot(token));

// isRowEnd (Node.js)
var {isRowEnd} = require("../util/debug");
var {childNodes} = Parser.parse("{|\n|\n|-\n|}").firstChild;
for (const child of childNodes) {
	assert.strictEqual(
		isRowEnd(child),
		child.type !== "table-attrs" && child.type !== "td",
	);
}

// isLink (Node.js)
var {isLink} = require("../util/debug");
assert.ok(isLink("redirect-target"));
assert.ok(isLink("link"));
assert.ok(!isLink("category"));
assert.ok(!isLink("file"));

// setChildNodes (Node.js)
var {setChildNodes} = require("../util/debug"),
	{Token} = require("../src/index"),
	{AstText} = require("../lib/text");
var a = new AstText("a"),
	b = new AstText("b"),
	c = new AstText("c"),
	d = new AstText("d"),
	e = new AstText("e"),
	token = new Token(),
	removed;
token.append(a, b, c);
assert.equal(token, "abc");
removed = setChildNodes(token, 1, 1, [d, e]);
assert.equal(token, "adec");
assert.deepStrictEqual(removed, [b]);
assert.deepStrictEqual(token.childNodes, [a, d, e, c]);
assert.strictEqual(a.parentNode, token);
assert.strictEqual(c.parentNode, token);
assert.strictEqual(d.parentNode, token);
assert.strictEqual(e.parentNode, token);
assert.strictEqual(a.previousSibling, undefined);
assert.strictEqual(c.previousSibling, e);
assert.strictEqual(d.previousSibling, a);
assert.strictEqual(e.previousSibling, d);
assert.strictEqual(a.nextSibling, d);
assert.strictEqual(c.nextSibling, undefined);
assert.strictEqual(d.nextSibling, e);
assert.strictEqual(e.nextSibling, c);

removed = setChildNodes(token, 0, 4, [b]);
assert.equal(token, "b");
assert.deepStrictEqual(removed, [a, d, e, c]);
assert.deepStrictEqual(token.childNodes, [b]);
assert.strictEqual(b.parentNode, token);
assert.strictEqual(b.previousSibling, undefined);
assert.strictEqual(b.nextSibling, undefined);

// setChildNodes (main)
var {setChildNodes} = require("../util/debug"),
	{Token} = require("../src/index"),
	{AstText} = require("../lib/text");
var a = new AstText("a"),
	b = new AstText("b"),
	c = new AstText("c"),
	token = new Token();
token.append(a, b, c);
setChildNodes(token, 1, 1);
assert.strictEqual(b.parentNode, undefined);
assert.strictEqual(b.previousSibling, undefined);
assert.strictEqual(b.nextSibling, undefined);

setChildNodes(token, 0, 2);
assert.strictEqual(a.parentNode, undefined);
assert.strictEqual(c.parentNode, undefined);
assert.strictEqual(a.previousSibling, undefined);
assert.strictEqual(c.previousSibling, undefined);
assert.strictEqual(a.nextSibling, undefined);
assert.strictEqual(c.nextSibling, undefined);

// getMagicWordInfo (Node.js)
var {getMagicWordInfo} = require("../util/debug");
var parserFunction = [
	{"#if": "if"},
	{PAGENAME: "pagename"},
];
assert.deepStrictEqual(
	getMagicWordInfo("PAGENAME", parserFunction),
	["pagename", true, "pagename"],
);
assert.deepStrictEqual(
	getMagicWordInfo("IF", parserFunction),
	["if", false, false],
);
assert.deepStrictEqual(
	getMagicWordInfo("#IF", parserFunction),
	["#if", false, "if"],
);

// emptyArray (Node.js)
var {emptyArray} = require("../util/debug");
assert.deepStrictEqual(
	emptyArray(3, i => i + 1),
	[1, 2, 3],
);

// mixin (Node.js)
var {attributesParent} = require("../mixin/attributesParent"),
	{elementLike} = require("../mixin/elementLike"),
	{gapped} = require("../mixin/gapped"),
	{hiddenToken} = require("../mixin/hidden"),
	{nodeLike} = require("../mixin/nodeLike"),
	{padded} = require("../mixin/padded"),
	{Token} = require("../src/index");
assert.strictEqual(attributesParent()(Token).name, "Token");
assert.strictEqual(elementLike(Token).name, "Token");
assert.strictEqual(gapped()(Token).name, "Token");
assert.strictEqual(hiddenToken()(Token).name, "Token");
assert.strictEqual(nodeLike(Token).name, "Token");
assert.strictEqual(padded("")(Token).name, "Token");

// mixin (main)
var {fixedToken} = require("../mixin/fixed"),
	{noEscape} = require("../mixin/noEscape"),
	{singleLine} = require("../mixin/singleLine"),
	{sol} = require("../mixin/sol"),
	{syntax} = require("../mixin/syntax"),
	{Token} = require("../src/index");
assert.strictEqual(fixedToken(Token).name, "Token");
assert.strictEqual(noEscape(Token).name, "Token");
assert.strictEqual(singleLine(Token).name, "Token");
assert.strictEqual(sol()(Token).name, "Token");
assert.strictEqual(syntax()(Token).name, "Token");

// undo (main)
var {firstChild: {firstChild}} = Parser.parse("[[file:a]]"),
	token, cloned;
assert.equal(firstChild.type, "link-target");
try {
	firstChild.setText("a");
} catch {}
assert.equal(firstChild, "file:a");

({firstChild: {firstChild}} = Parser.parse("[[category:a]]"));
assert.equal(firstChild.type, "link-target");
try {
	firstChild.setText("a");
} catch {}
assert.equal(firstChild, "category:a");

token = Parser.parse("{{{!}}").firstChild;
({firstChild} = token);
assert.equal(firstChild.type, "table-syntax");
try {
	firstChild.length = 1;
} catch {}
assert.equal(firstChild, "{{{!}}");
firstChild.replaceChildren("{|");
assert.equal(firstChild, "{|");

token = Parser.parse("<gallery>a</gallery>").querySelector("link-target");
try {
	token.append("<");
} catch {}
assert.equal(token, "a");

token = Parser.parse("-{zh-cn:a}-")
	.querySelector("converter-rule");
({firstChild} = token);
assert.equal(firstChild.type, "converter-rule-variant");
cloned = firstChild.cloneNode();
cloned.setText("!");
try {
	firstChild.safeReplaceWith(cloned);
} catch {}
assert.equal(token, "zh-cn:a");

// getCanonicalName (main)
var {getCanonicalName} = require("../util/debug");
var parserFunction = [
	{"#if": "if"},
	{PAGENAME: "pagename"},
];
assert.deepStrictEqual(
	getCanonicalName("PAGENAME", parserFunction),
	["pagename", "pagename"],
);
assert.deepStrictEqual(
	getCanonicalName("IF", parserFunction),
	["if", false],
);
assert.deepStrictEqual(
	getCanonicalName("#IF", parserFunction),
	["if", "if"],
);