lint - bhsd-harry/wikiparser-node GitHub Wiki

// isFostered (Node.js)
var {isFostered} = require('../util/lint');
var check = text => isFostered(Parser.parse(text));
assert.strictEqual(check(' <!-- --> '), false);
assert.strictEqual(check('<!-- --> !'), false);
assert.strictEqual(check('<!-- --> {{!}}'), false);
assert.strictEqual(check('<!-- --> <td>'), false);
assert.strictEqual(check('<!-- --> {{{|!}}}'), false);
assert.strictEqual(check('<!-- --> {{{|x}}}'), 2);
assert.strictEqual(check('<!-- --> {{{|{{x}}}}}'), 1);
assert.strictEqual(check('{{#if:||!}}'), false);
assert.strictEqual(check('{{#if:|{{x}}|x}}'), 2);
assert.strictEqual(check('{{#if:|{{x}}|!}}'), 1);
assert.strictEqual(check('{{x}}'), 1);
assert.strictEqual(check('{{#invoke:x|y}}'), 1);
assert.strictEqual(check('x'), 2);

// getEndPos (Node.js)
var {getEndPos} = require('../util/lint');
assert.deepStrictEqual(
	getEndPos(1, 1, 1, 1),
	{line: 1, character: 2},
);
assert.deepStrictEqual(
	getEndPos(1, 1, 2, 1),
	{line: 2, character: 1},
);

// generateForChild (Node.js)
var {generateForChild} = require('../util/lint'),
	{Token} = require('../src/index');
var root = new Token(),
	child = new Token('a\nb');
root.append(child);
assert.deepStrictEqual(
	generateForChild(child, {start: 0}, 'rule', 'msg'),
	{
		rule: 'rule',
		message: 'msg',
		severity: 'error',
		startIndex: 0,
		endIndex: 3,
		startLine: 0,
		startCol: 0,
		endLine: 1,
		endCol: 1,
	},
);

// generateForSelf (Node.js)
var {generateForSelf} = require('../util/lint'),
	{Token} = require('../src/index');
var root = new Token('a\nb');
assert.deepStrictEqual(
	generateForSelf(root, {start: 0}, 'rule', 'msg'),
	{
		rule: 'rule',
		message: 'msg',
		severity: 'error',
		startIndex: 0,
		endIndex: 3,
		startLine: 0,
		startCol: 0,
		endLine: 1,
		endCol: 1,
	},
);

// cache (main)
var {cache} = require('../util/lint');
var store1,
	store2,
	counter = 0,
	compute = () => counter++,
	f = () => cache(store1, compute, value => {
		store1 = value;
	}),
	g = () => cache(store2, compute, value => {
		store2 = value;
	}, true);
Parser.viewOnly = true;
assert.strictEqual(f(), 0);
assert.strictEqual(f(), 0);
Parser.viewOnly = false;
assert.strictEqual(f(), 1);
assert.strictEqual(g(), 2);
assert.strictEqual(g(), 2);

// provideValues (Node.js)
var {provideValues} = require('../util/lint');
assert.deepStrictEqual(
	provideValues('ol', 'type'),
	['1', 'a', 'A', 'i', 'I'],
);
assert.deepStrictEqual(
	provideValues('th', 'scope'),
	['row', 'col', 'rowgroup', 'colgroup'],
);
assert.deepStrictEqual(
	provideValues('p', 'dir'),
	['ltr', 'rtl', 'auto'],
);
assert.deepStrictEqual(
	provideValues('p', 'aria-hidden'),
	['true', 'false'],
);
assert.deepStrictEqual(
	provideValues('p', 'id'),
	[],
);

// fixBy (Node.js)
var {fixBy} = require('../util/lint');
var e = {
	startIndex: 0,
	endIndex: 1,
};
assert.deepStrictEqual(
	fixBy(e, 'left-bracket', '[', 1),
	{
		desc: 'opening bracket',
		range: [1, 1],
		text: '[',
	},
);

// fixByInsert (Node.js)
var {fixByInsert} = require('../util/lint');
assert.deepStrictEqual(
	fixByInsert(1, 'left-bracket', '['),
	{
		desc: 'opening bracket',
		range: [1, 1],
		text: '[',
	},
);

// fixByRemove (Node.js)
var {fixByRemove} = require('../util/lint');
var e = {
	startIndex: 0,
	endIndex: 1,
};
assert.deepStrictEqual(
	fixByRemove(e, 1, '['),
	{
		desc: 'remove',
		range: [1, 1],
		text: '[',
	},
);
assert.deepStrictEqual(
	fixByRemove(1, 1, '['),
	{
		desc: 'remove',
		range: [1, 2],
		text: '[',
	},
);

// fixByDecode (Node.js)
var {fixByDecode} = require('../util/lint');
var e = {
		startIndex: 0,
		endIndex: 3,
	},
	link = Parser.parse('%25');
assert.deepStrictEqual(
	fixByDecode(e, link),
	{
		desc: 'decode',
		range: [0, 3],
		text: '%',
	},
);

// fixByClose (Node.js)
var {fixByClose} = require('../util/lint');
assert.deepStrictEqual(
	fixByClose(1, '[', -1),
	{
		desc: 'close',
		range: [0, 1],
		text: '[',
	},
);

// fixByOpen (Node.js)
var {fixByOpen} = require('../util/lint');
assert.deepStrictEqual(
	fixByOpen(1),
	{
		desc: 'open',
		range: [2, 3],
		text: '',
	},
);

// fixByComment (Node.js)
var {fixByComment} = require('../util/lint');
var e = {
	startIndex: 0,
	endIndex: 1,
};
assert.deepStrictEqual(
	fixByComment(e, '['),
	{
		desc: 'comment',
		range: [0, 1],
		text: '<!--[-->',
	},
);

// fixByUpper (Node.js)
var {fixByUpper} = require('../util/lint');
var e = {
	startIndex: 0,
	endIndex: 1,
};
assert.deepStrictEqual(
	fixByUpper(e, 'a'),
	{
		desc: 'uppercase',
		range: [0, 1],
		text: 'A',
	},
);

// fixBySpace (Node.js)
var {fixBySpace} = require('../util/lint');
assert.deepStrictEqual(
	fixBySpace(1, 1),
	{
		desc: 'whitespace',
		range: [1, 2],
		text: ' ',
	},
);

// fixByEscape (Node.js)
var {fixByEscape} = require('../util/lint');
assert.deepStrictEqual(
	fixByEscape(1, '[', 2),
	{
		desc: 'escape',
		range: [1, 3],
		text: '[[',
	},
);

// fixByPipe (Node.js)
var {fixByPipe} = require('../util/lint');
assert.deepStrictEqual(
	fixByPipe(1, '|'),
	{
		desc: 'escape',
		range: [1, 2],
		text: '|',
	},
);