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'],
);