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.strictEqual(Shadow.running, false);

// Shadow.rev (main)
var {Shadow} = require('../util/debug');
var {rev} = Shadow;
assert.ok(!Parser.viewOnly);
Parser.viewOnly = true;
assert.strictEqual(Shadow.rev, rev);
Parser.viewOnly = false;
assert.strictEqual(Shadow.rev, rev + 1);

// 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);

// 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);

// mixin (Node.js)
var {attributesParent} = require('../mixin/attributesParent'),
	{hiddenToken} = require('../mixin/hidden'),
	{Token} = require('../src/index');
assert.strictEqual(attributesParent()(Token).name, 'Token');
assert.strictEqual(hiddenToken()(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');