@markuplint/rules 3.7.0 → 3.9.0

package/test/create-message.spec.js

@@ -0,0 +1,497 @@
+const { translator } = require('@markuplint/i18n');
+const { i18n } = require('markuplint');
+
+const { __createMessageValueExpected } = require('../lib/create-message');
+
+let t;
+
+beforeAll(async () => {
+	const locale = await i18n('en');
+	t = translator(locale);
+});
+
+// TODO: doesnt-exist-in-enum
+
+describe('duplicated', () => {
+	test('expects: without, partName: without', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', '', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'duplicated',
+			}),
+		).toBe('A is duplicated (REF)');
+	});
+
+	test('expects: without, partName: with', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', '', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'duplicated',
+				partName: 'C',
+			}),
+		).toBe('the C part of A is duplicated (REF)');
+	});
+
+	test('expects: with, partName: without', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', 'B', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'duplicated',
+			}),
+		).toBe('A is duplicated. It expects B (REF)');
+	});
+
+	test('expects: with, partName: with', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', 'B', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'duplicated',
+				partName: 'C',
+			}),
+		).toBe('the C part of A is duplicated. It expects B (REF)');
+	});
+});
+
+describe('empty-token', () => {
+	test('expects: without, partName: without', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', '', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'empty-token',
+			}),
+		).toBe('A must not be empty (REF)');
+	});
+
+	test('expects: without, partName: with', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', '', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'empty-token',
+				partName: 'C',
+			}),
+		).toBe('the C part of A must not be empty (REF)');
+	});
+
+	test('expects: with, partName: without', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', 'B', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'empty-token',
+			}),
+		).toBe('A must not be empty. It expects B (REF)');
+	});
+
+	test('expects: with, partName: with', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', 'B', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'empty-token',
+				partName: 'C',
+			}),
+		).toBe('the C part of A must not be empty. It expects B (REF)');
+	});
+});
+
+describe('extra-token', () => {
+	test('expects: without, partName: without', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', '', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'extra-token',
+			}),
+		).toBe('Found extra token "RAW" (REF)');
+	});
+
+	test('expects: without, partName: with', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', '', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'extra-token',
+				partName: 'C',
+			}),
+		).toBe('Found extra C "RAW" (REF)');
+	});
+
+	test('expects: with, partName: without', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', 'B', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'extra-token',
+			}),
+		).toBe('Found extra token "RAW". A expects B (REF)');
+	});
+
+	test('expects: with, partName: with', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', 'B', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'extra-token',
+				partName: 'C',
+			}),
+		).toBe('Found extra C "RAW". the C part of A expects B (REF)');
+	});
+});
+
+describe('illegal-combination', () => {
+	test('expects: without, partName: without', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', '', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'illegal-combination',
+			}),
+		).toBe('Found an illegal combination (REF)');
+	});
+
+	test('expects: without, partName: with', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', '', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'illegal-combination',
+				partName: 'C',
+			}),
+		).toBe('Found an illegal combination (REF)');
+	});
+
+	test('expects: with, partName: without', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', 'B', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'illegal-combination',
+			}),
+		).toBe('Found an illegal combination. A expects B (REF)');
+	});
+
+	test('expects: with, partName: with', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', 'B', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'illegal-combination',
+				partName: 'C',
+			}),
+		).toBe('Found an illegal combination. the C part of A expects B (REF)');
+	});
+});
+
+describe('missing-comma', () => {
+	test('expects: without, partName: without', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', '', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'missing-comma',
+			}),
+		).toBe('Missing a comma (REF)');
+	});
+
+	test('expects: without, partName: with', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', '', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'missing-comma',
+				partName: 'C',
+			}),
+		).toBe('Missing a comma in the C part (REF)');
+	});
+
+	test('expects: with, partName: without', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', 'B', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'missing-comma',
+			}),
+		).toBe('Missing a comma. A expects B (REF)');
+	});
+
+	test('expects: with, partName: with', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', 'B', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'missing-comma',
+				partName: 'C',
+			}),
+		).toBe('Missing a comma in the C part. It expects B (REF)');
+	});
+});
+
+describe('missing-token', () => {
+	test('expects: without, partName: without', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', '', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'missing-token',
+			}),
+		).toBe('Missing a token (REF)');
+	});
+
+	test('expects: without, partName: with', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', '', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'missing-token',
+				partName: 'C',
+			}),
+		).toBe('Missing the C part. A needs the C part (REF)');
+	});
+
+	test('expects: with, partName: without', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', 'B', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'missing-token',
+			}),
+		).toBe('Missing a token. A needs B (REF)');
+	});
+
+	test('expects: with, partName: with', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', 'B', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'missing-token',
+				partName: 'C',
+			}),
+		).toBe('Missing the C part. the C part of A needs B (REF)');
+	});
+});
+
+describe('unexpected-comma', () => {
+	test('expects: without, partName: without', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', '', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'unexpected-comma',
+			}),
+		).toBe('Found unexpected comma (REF)');
+	});
+
+	test('expects: without, partName: with', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', '', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'unexpected-comma',
+				partName: 'C',
+			}),
+		).toBe('Found unexpected comma (REF)');
+	});
+
+	test('expects: with, partName: without', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', 'B', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'unexpected-comma',
+			}),
+		).toBe('Found unexpected comma. A expects B (REF)');
+	});
+
+	test('expects: with, partName: with', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', 'B', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'unexpected-comma',
+				partName: 'C',
+			}),
+		).toBe('Found unexpected comma. the C part of A expects B (REF)');
+	});
+});
+
+describe('unexpected-newline', () => {
+	test('expects: without, partName: without', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', '', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'unexpected-newline',
+			}),
+		).toBe('Found unexpected newline (REF)');
+	});
+
+	test('expects: without, partName: with', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', '', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'unexpected-newline',
+				partName: 'C',
+			}),
+		).toBe('Found unexpected newline (REF)');
+	});
+
+	test('expects: with, partName: without', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', 'B', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'unexpected-newline',
+			}),
+		).toBe('Found unexpected newline. A expects B (REF)');
+	});
+
+	test('expects: with, partName: with', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', 'B', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'unexpected-newline',
+				partName: 'C',
+			}),
+		).toBe('Found unexpected newline. the C part of A expects B (REF)');
+	});
+});
+
+describe('unexpected-space', () => {
+	test('expects: without, partName: without', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', '', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'unexpected-space',
+			}),
+		).toBe('Found unexpected whitespace (REF)');
+	});
+
+	test('expects: without, partName: with', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', '', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'unexpected-space',
+				partName: 'C',
+			}),
+		).toBe('Found unexpected whitespace (REF)');
+	});
+
+	test('expects: with, partName: without', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', 'B', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'unexpected-space',
+			}),
+		).toBe('Found unexpected whitespace. A expects B (REF)');
+	});
+
+	test('expects: with, partName: with', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', 'B', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'unexpected-space',
+				partName: 'C',
+			}),
+		).toBe('Found unexpected whitespace. the C part of A expects B (REF)');
+	});
+});
+
+describe('unexpected-token', () => {
+	test('expects: without, partName: without', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', '', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'unexpected-token',
+			}),
+		).toBe('It includes unexpected characters (REF)');
+	});
+
+	test('expects: without, partName: with', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', '', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'unexpected-token',
+				partName: 'C',
+			}),
+		).toBe('the C part includes unexpected characters (REF)');
+	});
+
+	test('expects: with, partName: without', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', 'B', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'unexpected-token',
+			}),
+		).toBe('It includes unexpected characters. A expects B (REF)');
+	});
+
+	test('expects: with, partName: with', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', 'B', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: 'unexpected-token',
+				partName: 'C',
+			}),
+		).toBe('the C part includes unexpected characters. It expects B (REF)');
+	});
+});
+
+describe('out-of-range-length-digit', () => {
+	test('expects: without, partName: without', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', '', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: { type: 'out-of-range-length-digit', gte: 4 },
+			}),
+		).toBe('A expects four or more digits (REF)');
+	});
+
+	test('expects: without, partName: with', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', '', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: { type: 'out-of-range-length-digit', gte: 4 },
+				partName: 'C',
+			}),
+		).toBe('the C part of A expects four or more digits (REF)');
+	});
+
+	test('expects: with, partName: without', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', 'B', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: { type: 'out-of-range-length-digit', gte: 4 },
+			}),
+		).toBe('A expects four or more digits and B (REF)');
+	});
+
+	test('expects: with, partName: with', () => {
+		expect(
+			__createMessageValueExpected(t, 'A', 'B', {
+				ref: 'REF',
+				raw: 'RAW',
+				reason: { type: 'out-of-range-length-digit', gte: 4 },
+				partName: 'C',
+			}),
+		).toBe('the C part of A expects four or more digits and B (REF)');
+	});
+});

package/test/deprecated-attr/index.spec.js

@@ -0,0 +1,48 @@
+const { mlRuleTest } = require('markuplint');
+
+const rule = require('../../lib/deprecated-attr').default;
+
+test('deprecated attribute', async () => {
+	const { violations } = await mlRuleTest(rule, '<img align="top">');
+	expect(violations).toStrictEqual([
+		{
+			severity: 'error',
+			line: 1,
+			col: 6,
+			raw: 'align',
+			message: 'The "align" attribute is deprecated',
+		},
+	]);
+});
+
+test('deprecated global attribute', async () => {
+	const { violations } = await mlRuleTest(rule, '<img xml:lang="en-US">');
+	expect(violations).toStrictEqual([
+		{
+			severity: 'error',
+			line: 1,
+			col: 6,
+			raw: 'xml:lang',
+			message: 'The "xml:lang" attribute is deprecated',
+		},
+	]);
+});
+
+test('svg', async () => {
+	const { violations } = await mlRuleTest(
+		rule,
+		`<svg viewBox="0 0 160 40" xmlns="http://www.w3.org/2000/svg">
+          <a xlink:href="https://developer.mozilla.org/">
+          <text x="10" y="25">MDN Web Docs</text></a>
+        </svg>`,
+	);
+	expect(violations).toStrictEqual([
+		{
+			severity: 'error',
+			line: 2,
+			col: 14,
+			message: 'The "xlink:href" attribute is deprecated',
+			raw: 'xlink:href',
+		},
+	]);
+});

package/test/deprecated-element/index.spec.js

@@ -0,0 +1,48 @@
+const { mlRuleTest } = require('markuplint');
+
+const rule = require('../../lib/deprecated-element').default;
+
+test('normal', async () => {
+	const { violations } = await mlRuleTest(rule, '<div></div><p><span></span></p>');
+	expect(violations).toStrictEqual([]);
+});
+
+test('deprecated', async () => {
+	const { violations } = await mlRuleTest(rule, '<font></font><big><blink></blink></big>');
+	expect(violations).toStrictEqual([
+		{
+			severity: 'error',
+			message: 'The "font" element is obsolete',
+			line: 1,
+			col: 1,
+			raw: '<font>',
+		},
+		{
+			severity: 'error',
+			message: 'The "big" element is obsolete',
+			line: 1,
+			col: 14,
+			raw: '<big>',
+		},
+		{
+			severity: 'error',
+			message: 'The "blink" element is obsolete',
+			line: 1,
+			col: 19,
+			raw: '<blink>',
+		},
+	]);
+});
+
+test('svg', async () => {
+	const { violations } = await mlRuleTest(rule, '<svg><altGlyph>text</altGlyph></svg>');
+	expect(violations).toStrictEqual([
+		{
+			severity: 'error',
+			message: 'The "altGlyph" element is obsolete',
+			line: 1,
+			col: 6,
+			raw: '<altGlyph>',
+		},
+	]);
+});

package/test/disallowed-element/index.spec.js

@@ -0,0 +1,90 @@
+const { mlRuleTest } = require('markuplint');
+
+const rule = require('../../lib/disallowed-element').default;
+
+it('specifies to global rule', async () => {
+	const { violations } = await mlRuleTest(rule, '<div><hgroup><h1>Heading</h1></hgroup></div>', {
+		rule: ['hgroup'],
+	});
+	expect(violations).toStrictEqual([
+		{
+			severity: 'error',
+			line: 1,
+			col: 6,
+			raw: '<hgroup>',
+			message: 'The "hgroup" element is disallowed',
+		},
+	]);
+});
+
+it('specifies to node rule', async () => {
+	const { violations } = await mlRuleTest(rule, '<h1><span>Title</span><small>Sub-title</small></h1>', {
+		nodeRule: [
+			{
+				selector: 'h1, h2, h3, h4, h5, h6',
+				rule: ['small'],
+			},
+		],
+	});
+	expect(violations).toStrictEqual([
+		{
+			severity: 'error',
+			line: 1,
+			col: 23,
+			raw: '<small>',
+			message: 'The "small" element is disallowed',
+		},
+	]);
+});
+
+it('Recommend', async () => {
+	expect(
+		(
+			await mlRuleTest(
+				rule,
+				'<details><summary><label id="foo">foo</label></summary><input id="foo"/></details>',
+				{
+					nodeRule: [
+						{
+							selector: 'summary',
+							rule: ['label'],
+						},
+					],
+				},
+			)
+		).violations,
+	).toStrictEqual([
+		{
+			severity: 'error',
+			line: 1,
+			col: 19,
+			raw: '<label id="foo">',
+			message: 'The "label" element is disallowed',
+		},
+	]);
+
+	expect(
+		(
+			await mlRuleTest(
+				rule,
+				'<details><summary><label id="foo">foo</label></summary><input id="foo"/></details>',
+				{
+					nodeRule: [
+						{
+							selector: 'summary',
+							rule: [':model(interactive)'],
+						},
+					],
+				},
+			)
+		).violations,
+	).toStrictEqual([
+		{
+			severity: 'error',
+			line: 1,
+			col: 19,
+			raw: '<label id="foo">',
+			message: 'The ":model(interactive)" element is disallowed',
+		},
+	]);
+});