wikilint 0.10.0

package/src/tagPair/include.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const hidden = require('../../mixin/hidden'),
+	Parser = require('../..'),
+	TagPairToken = require('.');
+
+/**
+ * `<includeonly>`或`<noinclude>`
+ * @classdesc `{childNodes: [AstText, AstText]}`
+ */
+class IncludeToken extends hidden(TagPairToken) {
+	type = 'include';
+
+	/**
+	 * @param {string} name 标签名
+	 * @param {string} attr 标签属性
+	 * @param {string|undefined} inner 内部wikitext
+	 * @param {string|undefined} closed 是否封闭
+	 * @param {accum} accum
+	 */
+	constructor(name, attr = '', inner = undefined, closed = undefined, config = Parser.getConfig(), accum = []) {
+		super(name, attr, inner ?? '', inner === undefined ? closed : closed ?? '', config, accum);
+	}
+}
+
+module.exports = IncludeToken;

package/src/tagPair/index.js

@@ -0,0 +1,77 @@
+'use strict';
+
+const Parser = require('../..'),
+	Token = require('..');
+
+/**
+ * 成对标签
+ * @classdesc `{childNodes: [AstText|AttributesToken, AstText|Token]}`
+ */
+class TagPairToken extends Token {
+	#selfClosing;
+	#closed;
+	#tags;
+
+	/** getter */
+	get closed() {
+		return this.#closed;
+	}
+
+	/**
+	 * @param {string} name 标签名
+	 * @param {string|Token} attr 标签属性
+	 * @param {string|Token} inner 内部wikitext
+	 * @param {string|undefined} closed 是否封闭；约定`undefined`表示自闭合，`''`表示未闭合
+	 * @param {accum} accum
+	 */
+	constructor(name, attr, inner, closed, config = Parser.getConfig(), accum = []) {
+		super(undefined, config, true);
+		this.setAttribute('name', name.toLowerCase());
+		this.#tags = [name, closed || name];
+		this.#selfClosing = closed === undefined;
+		this.#closed = closed !== '';
+		this.append(attr, inner);
+		let index = accum.indexOf(attr);
+		if (index === -1) {
+			index = accum.indexOf(inner);
+		}
+		if (index === -1) {
+			index = Infinity;
+		}
+		accum.splice(index, 0, this);
+	}
+
+	/**
+	 * @override
+	 */
+	toString(selector) {
+		const {firstChild, lastChild} = this,
+			[opening, closing] = this.#tags;
+		return this.#selfClosing
+			? `<${opening}${String(firstChild)}/>`
+			: `<${opening}${String(firstChild)}>${String(lastChild)}${this.#closed ? `</${closing}>` : ''}`;
+	}
+
+	/**
+	 * @override
+	 * @returns {string}
+	 */
+	text() {
+		const [opening, closing] = this.#tags;
+		return this.#selfClosing
+			? `<${opening}${this.firstChild.text()}/>`
+			: `<${opening}${super.text('>')}${this.#closed ? `</${closing}>` : ''}`;
+	}
+
+	/** @override */
+	getPadding() {
+		return this.#tags[0].length + 1;
+	}
+
+	/** @override */
+	getGaps() {
+		return 1;
+	}
+}
+
+module.exports = TagPairToken;

package/src/transclude.js

@@ -0,0 +1,336 @@
+'use strict';
+
+const {removeComment, text, decodeHtml} = require('../util/string'),
+	{generateForChild} = require('../util/lint'),
+	Parser = require('..'),
+	Token = require('.'),
+	ParameterToken = require('./parameter'),
+	AtomToken = require('./atom'),
+	SyntaxToken = require('./syntax');
+
+/**
+ * 模板或魔术字
+ * @classdesc `{childNodes: [AtomToken|SyntaxToken, ...ParameterToken]}`
+ */
+class TranscludeToken extends Token {
+	type = 'template';
+	modifier = '';
+	/** @type {Record<string, Set<ParameterToken>>} */ #args = {};
+	#fragment;
+	#valid = true;
+	#raw = false;
+
+	/**
+	 * 设置引用修饰符
+	 * @param {string} modifier 引用修饰符
+	 * @complexity `n`
+	 */
+	setModifier(modifier = '') {
+		const {parserFunction: [,, raw, subst]} = this.getAttribute('config'),
+			lcModifier = removeComment(modifier).trim();
+		if (modifier && !lcModifier.endsWith(':')) {
+			return false;
+		}
+		const magicWord = lcModifier.slice(0, -1).toLowerCase(),
+			isRaw = raw.includes(magicWord),
+			isSubst = subst.includes(magicWord);
+		if (isRaw || isSubst || modifier === '') {
+			this.setAttribute('modifier', modifier);
+			this.#raw = isRaw;
+			return Boolean(modifier);
+		}
+		return false;
+	}
+
+	/**
+	 * @param {string} title 模板标题或魔术字
+	 * @param {[string, string|undefined][]} parts 参数各部分
+	 * @param {accum} accum
+	 * @complexity `n`
+	 * @throws `SyntaxError` 非法的模板名称
+	 */
+	constructor(title, parts, config = Parser.getConfig(), accum = []) {
+		super(undefined, config, true, accum, {
+		});
+		const {parserFunction: [insensitive, sensitive]} = config,
+			argSubst = /^(?:\s|\0\d+c\x7F)*\0\d+s\x7F/u.exec(title)?.[0];
+		if (argSubst) {
+			this.setAttribute('modifier', argSubst);
+			title = title.slice(argSubst.length);
+		} else if (title.includes(':')) {
+			const [modifier, ...arg] = title.split(':'),
+				[mt] = /^(?:\s|\0\d+c\x7F)*/u.exec(arg[0] ?? '');
+			if (this.setModifier(`${modifier}:${mt}`)) {
+				title = arg.join(':').slice(mt.length);
+			}
+		}
+		if (title.includes(':') || parts.length === 0 && !this.#raw) {
+			const [magicWord, ...arg] = title.split(':'),
+				cleaned = removeComment(magicWord),
+				name = cleaned[arg.length > 0 ? 'trimStart' : 'trim'](),
+				isSensitive = sensitive.includes(name),
+				canonicalCame = insensitive[name.toLowerCase()];
+			if (isSensitive || canonicalCame) {
+				this.setAttribute('name', canonicalCame || name.toLowerCase()).type = 'magic-word';
+				const pattern = new RegExp(`^\\s*${name}\\s*$`, isSensitive ? 'u' : 'iu'),
+					token = new SyntaxToken(magicWord, pattern, 'magic-word-name', config, accum, {
+					});
+				this.insertAt(token);
+				if (arg.length > 0) {
+					parts.unshift([arg.join(':')]);
+				}
+				if (this.name === 'invoke') {
+					for (let i = 0; i < 2; i++) {
+						const part = parts.shift();
+						if (!part) {
+							break;
+						}
+						const invoke = new AtomToken(part.join('='), `invoke-${
+							i ? 'function' : 'module'
+						}`, config, accum, {
+						});
+						this.insertAt(invoke);
+					}
+				}
+			}
+		}
+		if (this.type === 'template') {
+			const name = removeComment(decodeHtml(title)).split('#')[0].trim();
+			if (!name || /\0\d+[eh!+-]\x7F|[<>[\]{}\n]|%[\da-f]{2}/u.test(name)) {
+				accum.pop();
+				throw new SyntaxError(`非法的模板名称：${name}`);
+			}
+			const token = new AtomToken(title, 'template-name', config, accum, {
+			});
+			this.insertAt(token);
+		}
+		const templateLike = this.isTemplate();
+		let i = 1;
+		for (let j = 0; j < parts.length; j++) {
+			const part = parts[j];
+			if (!templateLike && !(this.name === 'switch' && j > 0)) {
+				part[0] = part.join('=');
+				part.length = 1;
+			}
+			if (part.length === 1) {
+				part.unshift(i);
+				i++;
+			}
+			this.insertAt(new ParameterToken(...part, config, accum));
+		}
+	}
+
+	/** @override */
+	afterBuild() {
+		if (this.modifier.includes('\0')) {
+			this.setAttribute('modifier', this.getAttribute('buildFromStr')(this.modifier, 'string'));
+		}
+		if (this.isTemplate()) {
+			const isTemplate = this.type === 'template',
+				titleObj = this.normalizeTitle(this.childNodes[isTemplate ? 0 : 1].text(), isTemplate ? 10 : 828);
+			this.#fragment = titleObj.fragment;
+			this.#valid = titleObj.valid;
+		}
+	}
+
+	/**
+	 * @override
+	 */
+	toString(selector) {
+		const {childNodes, firstChild, modifier} = this;
+		return `{{${modifier}${
+			this.type === 'magic-word'
+				? `${String(firstChild)}${childNodes.length > 1 ? ':' : ''}${childNodes.slice(1).map(String).join('|')}`
+				: super.toString(selector, '|')
+		}}}`;
+	}
+
+	/**
+	 * @override
+	 * @returns {string}
+	 * @complexity `n`
+	 */
+	text() {
+		const {childNodes, firstChild, modifier, type, name} = this;
+		return type === 'magic-word' && name === 'vardefine'
+			? ''
+			: `{{${modifier}${
+				this.type === 'magic-word'
+					? `${firstChild.text()}${childNodes.length > 1 ? ':' : ''}${text(childNodes.slice(1), '|')}`
+					: super.text('|')
+			}}}`;
+	}
+
+	/** @override */
+	getPadding() {
+		return this.modifier.length + 2;
+	}
+
+	/** @override */
+	getGaps() {
+		return 1;
+	}
+
+	/**
+	 * @override
+	 * @param {number} start 起始位置
+	 */
+	lint(start) {
+		const errors = super.lint(start),
+			{type, childNodes} = this;
+		let rect;
+		if (!this.isTemplate()) {
+			return errors;
+		} else if (this.#fragment !== undefined) {
+			rect = {start, ...this.getRootNode().posFromIndex(start)};
+			errors.push(generateForChild(childNodes[type === 'template' ? 0 : 1], rect, 'useless fragment'));
+		}
+		if (!this.#valid) {
+			rect = {start, ...this.getRootNode().posFromIndex(start)};
+			errors.push(generateForChild(childNodes[1], rect, 'illegal module name'));
+		}
+		const duplicatedArgs = this.getDuplicatedArgs();
+		if (duplicatedArgs.length > 0) {
+			rect ||= {start, ...this.getRootNode().posFromIndex(start)};
+			errors.push(...duplicatedArgs.flatMap(([, args]) => args).map(
+				arg => generateForChild(arg, rect, 'duplicated parameter'),
+			));
+		}
+		return errors;
+	}
+
+	/** 是否是模板 */
+	isTemplate() {
+		return this.type === 'template' || this.type === 'magic-word' && this.name === 'invoke';
+	}
+
+	/**
+	 * 处理匿名参数更改
+	 * @param {number|ParameterToken} addedToken 新增的参数
+	 * @complexity `n`
+	 */
+	#handleAnonArgChange(addedToken) {
+		const args = this.getAnonArgs(),
+			j = args.indexOf(addedToken);
+		for (let i = j; i < args.length; i++) {
+			const token = args[i],
+				{name} = token,
+				newName = String(i + 1);
+			if (name !== newName) {
+				this.getArgs(newName, false, false).add(token.setAttribute('name', newName));
+			}
+		}
+	}
+
+	/**
+	 * @override
+	 * @param {ParameterToken} token 待插入的子节点
+	 * @param {number} i 插入位置
+	 * @complexity `n`
+	 */
+	insertAt(token, i = this.length) {
+		super.insertAt(token, i);
+		if (token.anon) {
+			this.#handleAnonArgChange(token);
+		} else if (token.name) {
+			this.getArgs(token.name, false, false).add(token);
+		}
+		return token;
+	}
+
+	/**
+	 * 获取所有参数
+	 * @returns {ParameterToken[]}
+	 * @complexity `n`
+	 */
+	getAllArgs() {
+		return this.childNodes.filter(child => child instanceof ParameterToken);
+	}
+
+	/**
+	 * 获取匿名参数
+	 * @complexity `n`
+	 */
+	getAnonArgs() {
+		return this.getAllArgs().filter(({anon}) => anon);
+	}
+
+	/**
+	 * 获取指定参数
+	 * @param {string|number} key 参数名
+	 * @param {boolean} exact 是否匹配匿名性
+	 * @param {boolean} copy 是否返回一个备份
+	 * @complexity `n`
+	 */
+	getArgs(key, exact, copy = true) {
+		const keyStr = String(key).replace(/^[ \t\n\0\v]+|(?<=[^ \t\n\0\v])[ \t\n\0\v]+$/gu, '');
+		let args;
+		if (Object.hasOwn(this.#args, keyStr)) {
+			args = this.#args[keyStr];
+		} else {
+			args = new Set(this.getAllArgs().filter(({name}) => keyStr === name));
+			this.#args[keyStr] = args;
+		}
+		return args;
+	}
+
+	/**
+	 * 获取重名参数
+	 * @complexity `n`
+	 * @returns {[string, ParameterToken[]][]}
+	 */
+	getDuplicatedArgs() {
+		if (this.isTemplate()) {
+			return Object.entries(this.#args).filter(([, {size}]) => size > 1)
+				.map(([key, args]) => [key, [...args]]);
+		}
+		return [];
+	}
+
+	/**
+	 * 对特定魔术字获取可能的取值
+	 * @this {ParameterToken}}
+	 * @throws `Error` 不是可接受的魔术字
+	 */
+	getPossibleValues() {
+		const {type, name, childNodes, constructor: {name: cName}} = this;
+		if (type === 'template') {
+			throw new Error(`${cName}.getPossibleValues 方法仅供特定魔术字使用！`);
+		}
+		let start;
+		switch (name) {
+			case 'if':
+			case 'ifexist':
+			case 'ifexpr':
+			case 'iferror':
+				start = 2;
+				break;
+			case 'ifeq':
+				start = 3;
+				break;
+			default:
+				throw new Error(`${cName}.getPossibleValues 方法仅供特定魔术字使用！`);
+		}
+		const /** @type {Token[]} */ queue = childNodes.slice(start, start + 2).map(({childNodes: [, value]}) => value);
+		for (let i = 0; i < queue.length;) {
+			/** @type {Token[] & {0: TranscludeToken}} */
+			const {length, 0: first} = queue[i].childNodes.filter(child => child.text().trim());
+			if (length === 0) {
+				queue.splice(i, 1);
+			} else if (length > 1 || first.type !== 'magic-word') {
+				i++;
+			} else {
+				try {
+					const possibleValues = first.getPossibleValues();
+					queue.splice(i, 1, ...possibleValues);
+					i += possibleValues.length;
+				} catch {
+					i++;
+				}
+			}
+		}
+		return queue;
+	}
+}
+
+module.exports = TranscludeToken;

package/util/base.js

@@ -0,0 +1,17 @@
+'use strict';
+
+/**
+ * 是否是普通对象
+ * @param {*} obj 对象
+ */
+const isPlainObject = obj => Boolean(obj) && Object.getPrototypeOf(obj).constructor === Object;
+
+/**
+ * 延时
+ * @param {number} t 秒数
+ */
+const sleep = t => new Promise(resolve => {
+	setTimeout(resolve, t * 1000);
+});
+
+module.exports = {isPlainObject, sleep};

package/util/diff.js

@@ -0,0 +1,76 @@
+'use strict';
+
+const {spawn} = require('child_process'),
+	fs = require('fs/promises');
+
+process.on('unhandledRejection', e => {
+	console.error(e);
+});
+
+/**
+ * 将shell命令转化为Promise对象
+ * @param {string} command shell指令
+ * @param {string[]} args shell输入参数
+ * @returns {Promise<?string>}
+ */
+const cmd = (command, args) => new Promise(resolve => {
+	let timer, shell;
+
+	/**
+	 * 清除进程并返回
+	 * @param {*} val 返回值
+	 */
+	const r = val => {
+		clearTimeout(timer);
+		shell.kill('SIGINT');
+		resolve(val);
+	};
+	try {
+		shell = spawn(command, args);
+		timer = setTimeout(() => {
+			shell.kill('SIGINT');
+		}, 60 * 1000);
+		let buf = '';
+		shell.stdout.on('data', data => {
+			buf += data.toString();
+		});
+		shell.stdout.on('end', () => {
+			r(buf);
+		});
+		shell.on('exit', () => {
+			r(shell.killed ? undefined : '');
+		});
+		shell.on('error', () => {
+			r(undefined);
+		});
+	} catch {
+		r(undefined);
+	}
+});
+
+/**
+ * 比较两个文件
+ * @param {string} oldStr 旧文本
+ * @param {string} newStr 新文本
+ * @param {string} uid 唯一标识
+ */
+const diff = async (oldStr, newStr, uid = '') => {
+	if (oldStr === newStr) {
+		return;
+	}
+	const oldFile = `diffOld${uid}`,
+		newFile = `diffNew${uid}`;
+	await Promise.all([fs.writeFile(oldFile, oldStr), fs.writeFile(newFile, newStr)]);
+	const stdout = await cmd('git', [
+		'diff',
+		'--color-words=[\xC0-\xFF][\x80-\xBF]+|<?/?\\w+/?>?|[^[:space:]]',
+		'-U0',
+		'--no-index',
+		oldFile,
+		newFile,
+	]);
+	await Promise.all([fs.unlink(oldFile), fs.unlink(newFile)]);
+	console.log(stdout?.split('\n')?.slice(4)?.join('\n'));
+};
+
+module.exports = diff;

package/util/lint.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const Parser = require('..'),
+	Token = require('../src');
+
+/**
+ * 生成对于子节点的LintError对象
+ * @param {Token} child 子节点
+ * @param {{top: number, left: number, start: number}} boundingRect 父节点的绝对定位
+ * @param {string} msg 错误信息
+ * @param {'error'|'warning'} severity 严重程度
+ * @returns {LintError}
+ */
+const generateForChild = (child, boundingRect, msg, severity = 'error') => {
+	const index = child.getRelativeIndex(),
+		{offsetHeight, offsetWidth, parentNode, length} = child,
+		{top: offsetTop, left: offsetLeft} = parentNode.posFromIndex(index),
+		{start} = boundingRect,
+		{top, left} = 'top' in boundingRect ? boundingRect : child.getRootNode().posFromIndex(start),
+		startIndex = start + index,
+		endIndex = startIndex + length,
+		startLine = top + offsetTop,
+		endLine = startLine + offsetHeight - 1,
+		startCol = offsetTop ? offsetLeft : left + offsetLeft,
+		endCol = offsetHeight > 1 ? offsetWidth : startCol + offsetWidth;
+	return {message: Parser.msg(msg), severity, startIndex, endIndex, startLine, endLine, startCol, endCol};
+};
+
+/**
+ * 生成对于自己的LintError对象
+ * @param {Token} token 节点
+ * @param {{top: number, left: number, start: number}} boundingRect 绝对定位
+ * @param {string} msg 错误信息
+ * @param {'error'|'warning'} severity 严重程度
+ * @returns {LintError}
+ */
+const generateForSelf = (token, boundingRect, msg, severity = 'error') => {
+	const {start} = boundingRect,
+		{offsetHeight, offsetWidth, length} = token,
+		{top, left} = 'top' in boundingRect ? boundingRect : token.getRootNode().posFromIndex(start);
+	return {
+		message: Parser.msg(msg),
+		severity,
+		startIndex: start,
+		endIndex: start + length,
+		startLine: top,
+		endLine: top + offsetHeight - 1,
+		startCol: left,
+		endCol: offsetHeight > 1 ? offsetWidth : left + offsetWidth,
+	};
+};
+
+module.exports = {generateForChild, generateForSelf};

package/util/string.js

@@ -0,0 +1,75 @@
+'use strict';
+
+const extUrlCharFirst = '(?:\\[[\\da-f:.]+\\]|[^[\\]<>"\\0-\\x1F\\x7F\\p{Zs}\\uFFFD])',
+	extUrlChar = '(?:[^[\\]<>"\\0-\\x1F\\x7F\\p{Zs}\\uFFFD]|\\0\\d+c\\x7F)*';
+
+/**
+ * remove half-parsed comment-like tokens
+ * @param {string} str 原字符串
+ */
+const removeComment = str => str.replace(/\0\d+c\x7F/gu, '');
+
+/**
+ * escape special chars for RegExp constructor
+ * @param {string} str RegExp source
+ */
+const escapeRegExp = str => str.replace(/[\\{}()|.?*+^$[\]]/gu, '\\$&');
+
+/**
+ * a more sophisticated string-explode function
+ * @param {string} start start syntax of a nested AST node
+ * @param {string} end end syntax of a nested AST node
+ * @param {string} separator syntax for explosion
+ * @param {string} str string to be exploded
+ */
+const explode = (start, end, separator, str) => {
+	if (str === undefined) {
+		return [];
+	}
+	const regex = new RegExp(`${[start, end, separator].map(escapeRegExp).join('|')}`, 'gu'),
+		/** @type {string[]} */ exploded = [];
+	let mt = regex.exec(str),
+		depth = 0,
+		lastIndex = 0;
+	while (mt) {
+		const {0: match, index} = mt;
+		if (match !== separator) {
+			depth += match === start ? 1 : -1;
+		} else if (depth === 0) {
+			exploded.push(str.slice(lastIndex, index));
+			({lastIndex} = regex);
+		}
+		mt = regex.exec(str);
+	}
+	exploded.push(str.slice(lastIndex));
+	return exploded;
+};
+
+/**
+ * extract effective wikitext
+ * @param {(string|AstNode)[]} childNodes a Token's contents
+ * @param {string} separator delimiter between nodes
+ */
+const text = (childNodes, separator = '') => {
+	const AstNode = require('../lib/node');
+	return childNodes.map(child => typeof child === 'string' ? child : child.text()).join(separator);
+};
+
+/**
+ * decode HTML entities
+ * @param {string} str 原字符串
+ */
+const decodeHtml = str => str?.replace(
+	/&#(\d+|x[\da-f]+);/giu,
+	/** @param {string} code */ (_, code) => String.fromCodePoint(`${code[0].toLowerCase() === 'x' ? '0' : ''}${code}`),
+);
+
+module.exports = {
+	extUrlCharFirst,
+	extUrlChar,
+	removeComment,
+	escapeRegExp,
+	explode,
+	text,
+	decodeHtml,
+};