@markuplint/rules 3.7.0 → 3.9.0

package/test/no-refer-to-non-existent-id/index.spec.js

@@ -0,0 +1,254 @@
+const { mlRuleTest } = require('markuplint');
+
+const rule = require('../../lib/no-refer-to-non-existent-id').default;
+
+test('label[for]', async () => {
+	const { violations } = await mlRuleTest(rule, '<label for="foo"></label>');
+	expect(violations).toStrictEqual([
+		{
+			severity: 'error',
+			line: 1,
+			col: 13,
+			raw: 'foo',
+			message: 'Missing "foo" ID',
+		},
+	]);
+});
+
+test('td[headers]', async () => {
+	const { violations } = await mlRuleTest(
+		rule,
+		`<table>
+  <tr>
+    <th id="a"></th>
+    <th id="b"></th>
+    <td headers="a c"></td>
+  </tr>
+</table>`,
+		{
+			parser: {
+				'.*': '@markuplint/jsx-parser',
+			},
+		},
+	);
+	expect(violations).toStrictEqual([
+		{
+			severity: 'error',
+			line: 5,
+			col: 18,
+			raw: 'a c',
+			message: 'Missing "c" ID',
+		},
+	]);
+});
+
+test('td[headers] (Dynamic)', async () => {
+	const { violations } = await mlRuleTest(
+		rule,
+		`<table>
+  <tr>
+    <th id={a}></th>
+    <th id={b}></th>
+    <td headers="a c"></td>
+  </tr>
+</table>`,
+		{
+			parser: {
+				'.*': '@markuplint/jsx-parser',
+			},
+		},
+	);
+	expect(violations.length).toBe(0);
+});
+
+test('td[headers] (Dynamic)', async () => {
+	const { violations } = await mlRuleTest(
+		rule,
+		// cspell: disable
+		`<table>
+  <tr>
+    <th id="a"></th>
+    <th id="b"></th>
+    <td headers={aandb}></td>
+  </tr>
+</table>`,
+		// cspell: enable
+		{
+			parser: {
+				'.*': '@markuplint/jsx-parser',
+			},
+		},
+	);
+	expect(violations.length).toBe(0);
+});
+
+test('aria-describedby', async () => {
+	const { violations } = await mlRuleTest(rule, '<section aria-describedby="foo"></section>');
+	expect(violations).toStrictEqual([
+		{
+			severity: 'error',
+			line: 1,
+			col: 28,
+			raw: 'foo',
+			message: 'Missing "foo" ID',
+		},
+	]);
+});
+
+test('fragment', async () => {
+	expect((await mlRuleTest(rule, '<a href="#foo"></a>')).violations).toStrictEqual([
+		{
+			severity: 'error',
+			line: 1,
+			col: 10,
+			raw: '#foo',
+			message: 'Missing "foo" ID',
+		},
+	]);
+
+	expect((await mlRuleTest(rule, '<a href="#"></a>')).violations).toStrictEqual([]);
+
+	expect((await mlRuleTest(rule, '<a href="#top"></a>')).violations).toStrictEqual([]);
+
+	expect((await mlRuleTest(rule, '<a href="#TOP"></a>')).violations).toStrictEqual([]);
+
+	expect(
+		(await mlRuleTest(rule, `<a href="#${encodeURI('あいうえお')}"></a><div id="あいうえお"></div>`)).violations,
+	).toStrictEqual([]);
+
+	expect(
+		(
+			await mlRuleTest(rule, '<><a href="#foo" /><div id="foo" /></>', {
+				parser: {
+					'.*': '@markuplint/jsx-parser',
+				},
+			})
+		).violations,
+	).toStrictEqual([]);
+
+	expect(
+		(
+			await mlRuleTest(rule, '<><a href="#foo" /><div id={foo} /></>', {
+				parser: {
+					'.*': '@markuplint/jsx-parser',
+				},
+			})
+		).violations,
+	).toStrictEqual([]);
+
+	expect(
+		(
+			await mlRuleTest(rule, '<><a href="#foo" /><div name="foo" /></>', {
+				parser: {
+					'.*': '@markuplint/jsx-parser',
+				},
+			})
+		).violations,
+	).toStrictEqual([
+		{
+			severity: 'error',
+			line: 1,
+			col: 12,
+			raw: '#foo',
+			message: 'Missing "foo" ID',
+		},
+	]);
+
+	expect(
+		(
+			await mlRuleTest(rule, '<><a href="#foo" /><div name={foo} /></>', {
+				parser: {
+					'.*': '@markuplint/jsx-parser',
+				},
+			})
+		).violations,
+	).toStrictEqual([
+		{
+			severity: 'error',
+			line: 1,
+			col: 12,
+			raw: '#foo',
+			message: 'Missing "foo" ID',
+		},
+	]);
+
+	expect(
+		(
+			await mlRuleTest(rule, '<><a href="#foo" /><div name="foo" /></>', {
+				parser: {
+					'.*': '@markuplint/jsx-parser',
+				},
+				rule: {
+					options: {
+						fragmentRefersNameAttr: true,
+					},
+				},
+			})
+		).violations,
+	).toStrictEqual([]);
+
+	expect(
+		(
+			await mlRuleTest(rule, '<><a href="#foo" /><div name={foo} /></>', {
+				parser: {
+					'.*': '@markuplint/jsx-parser',
+				},
+				rule: {
+					options: {
+						fragmentRefersNameAttr: true,
+					},
+				},
+			})
+		).violations,
+	).toStrictEqual([]);
+});
+
+describe('Issues', () => {
+	test('#748', async () => {
+		expect(
+			(
+				await mlRuleTest(
+					rule,
+					`
+	<main>
+		<?php foo() ?>
+		<a href="#foo">link</a>
+		<div id="foo"></div>
+	</main>`,
+					{
+						parser: {
+							'.*': '@markuplint/php-parser',
+						},
+					},
+				)
+			).violations,
+		).toStrictEqual([]);
+	});
+
+	test('#776', async () => {
+		expect(
+			(
+				await mlRuleTest(
+					rule,
+					/* cSpell:disable */
+					`
+						<a href="#apple%3Aorange">apple:orange</a>
+						<p id="apple:orange">apple:orange</p>
+
+						<a href="#apple%26orange">apple&amp;orange</a>
+						<p id="apple&amp;orange">apple&amp;orange</p>
+
+						<a href="#apple%26lemon">apple&amp;lemon</a>
+						<p id="apple&lemon">apple&amp;lemon</p>
+					`,
+					/* cSpell:enable */
+					{
+						parser: {
+							'.*': '@markuplint/php-parser',
+						},
+					},
+				)
+			).violations,
+		).toStrictEqual([]);
+	});
+});

package/test/no-use-event-handler-attr/index.spec.js

@@ -0,0 +1,57 @@
+const { mlRuleTest } = require('markuplint');
+
+const rule = require('../../lib/no-use-event-handler-attr').default;
+
+it('disallows onclick', async () => {
+	const { violations } = await mlRuleTest(rule, '<div onclick="e => e"></div>');
+	expect(violations).toStrictEqual([
+		{
+			severity: 'warning',
+			line: 1,
+			col: 6,
+			raw: 'onclick="e => e"',
+			message: 'The "onclick" attribute is disallowed',
+		},
+	]);
+});
+
+it('allows onclick because ignores it', async () => {
+	const { violations } = await mlRuleTest(rule, '<div onclick="e => e"></div>', {
+		rule: {
+			options: {
+				ignore: 'onclick',
+			},
+		},
+	});
+	expect(violations).toStrictEqual([]);
+});
+
+it('✔ onclick, ✘ onmouseleave', async () => {
+	const { violations } = await mlRuleTest(rule, '<div onclick="e => e" onmouseleave="e => e"></div>', {
+		rule: {
+			options: {
+				ignore: 'onclick',
+			},
+		},
+	});
+	expect(violations).toStrictEqual([
+		{
+			severity: 'warning',
+			line: 1,
+			col: 23,
+			raw: 'onmouseleave="e => e"',
+			message: 'The "onmouseleave" attribute is disallowed',
+		},
+	]);
+});
+
+it('ignore by regex', async () => {
+	const { violations } = await mlRuleTest(rule, '<div onclick="e => e"></div>', {
+		rule: {
+			options: {
+				ignore: '/^onc/',
+			},
+		},
+	});
+	expect(violations).toStrictEqual([]);
+});

package/test/permitted-contents/choice.spec.js

@@ -0,0 +1,174 @@
+const specs = require('@markuplint/html-spec');
+const { createTestElement } = require('@markuplint/ml-core');
+
+const { choice } = require('../../lib/permitted-contents/choice');
+
+function c(models, innerHtml) {
+	const el = createTestElement(`<div>${innerHtml}</div>`);
+	return choice(models, Array.from(el.childNodes), specs, { ignoreHasMutableChildren: true }, 0);
+}
+
+it('ordered requires', () => {
+	const models = {
+		choice: [
+			//
+			[{ require: 'a' }],
+			[{ require: 'b' }],
+			[{ require: 'c' }],
+		],
+	};
+
+	expect(c(models, '').type).toBe('MISSING_NODE_REQUIRED');
+	expect(c(models, '<a></a>').type).toBe('MATCHED');
+	expect(c(models, '<a></a><a></a>').type).toBe('UNEXPECTED_EXTRA_NODE');
+	expect(c(models, '<b></b>').type).toBe('MATCHED');
+	expect(c(models, '<b></b><c></c>').type).toBe('UNEXPECTED_EXTRA_NODE');
+	expect(c(models, '<c></c>').type).toBe('MATCHED');
+	expect(c(models, '<d></d>').type).toBe('MISSING_NODE_REQUIRED');
+});
+
+test('optional', () => {
+	const models = {
+		choice: [
+			[
+				{
+					require: 'a',
+				},
+			],
+			[
+				{
+					require: 'b',
+				},
+			],
+			[
+				{
+					optional: 'c',
+				},
+			],
+		],
+	};
+
+	expect(c(models, '').type).toBe('MATCHED_ZERO');
+	expect(c(models, '<a></a>').type).toBe('MATCHED');
+	expect(c(models, '<b></b>').type).toBe('MATCHED');
+	expect(c(models, '<c></c>').type).toBe('MATCHED');
+	expect(c(models, '<d></d>').type).toBe('UNEXPECTED_EXTRA_NODE');
+});
+
+test('interleave', () => {
+	const models = {
+		choice: [
+			[
+				{
+					require: 'a',
+				},
+				{
+					require: 'b',
+				},
+			],
+			[
+				{
+					require: 'b',
+				},
+				{
+					require: 'a',
+				},
+			],
+		],
+	};
+
+	expect(c(models, '<a></a>').type).toBe('MISSING_NODE_REQUIRED');
+	expect(c(models, '<b></b>').type).toBe('MISSING_NODE_REQUIRED');
+	expect(c(models, '<a></a><b></b>').type).toBe('MATCHED');
+	expect(c(models, '<b></b><a></a>').type).toBe('MATCHED');
+	expect(c(models, '<b></b><a></a><c></c>').type).toBe('UNEXPECTED_EXTRA_NODE');
+	expect(c(models, '<b></b><a></a><a></a>').type).toBe('UNEXPECTED_EXTRA_NODE');
+});
+
+test('the dl element', () => {
+	const models = {
+		choice: [
+			[
+				{
+					oneOrMore: [
+						{
+							zeroOrMore: ':model(script-supporting)',
+						},
+						{
+							oneOrMore: 'dt',
+						},
+						{
+							zeroOrMore: ':model(script-supporting)',
+						},
+						{
+							oneOrMore: 'dd',
+						},
+						{
+							zeroOrMore: ':model(script-supporting)',
+						},
+					],
+				},
+			],
+			[
+				{
+					zeroOrMore: ':model(script-supporting)',
+				},
+				{
+					oneOrMore: 'div',
+				},
+				{
+					zeroOrMore: ':model(script-supporting)',
+				},
+			],
+		],
+	};
+
+	expect(c(models, '<dt></dt><dd></dd>').type).toBe('MATCHED');
+	expect(c(models, '').type).toBe('MISSING_NODE_ONE_OR_MORE');
+	expect(c(models, '').query).toBe('dt');
+	expect(c(models, '<dt></dt>').type).toBe('MISSING_NODE_ONE_OR_MORE');
+	expect(c(models, '<div></div>').type).toBe('MATCHED');
+	expect(c(models, '<div></div><div></div>').type).toBe('MATCHED');
+	expect(c(models, '<dt></dt><dd></dd><dt></dt>').type).toBe('MISSING_NODE_ONE_OR_MORE');
+});
+
+it('part of the ruby element', () => {
+	const models = {
+		// 2. One or the other of the following:
+		choice: [
+			[
+				{
+					// - One or more rt elements
+					oneOrMore: 'rt',
+				},
+			],
+			[
+				{
+					// - An rp element
+					require: 'rp',
+				},
+				{
+					// followed by one or more rt elements, each of which is itself followed by an rp element
+					oneOrMore: [
+						{
+							require: 'rt',
+						},
+						{
+							require: 'rp',
+						},
+					],
+				},
+			],
+		],
+	};
+
+	expect(c(models, '<rt></rt>').type).toBe('MATCHED');
+	expect(c(models, '<rp></rp>').type).toBe('MISSING_NODE_REQUIRED');
+	expect(c(models, '<rp></rp>').query).toBe('rt');
+	expect(c(models, '<rt></rt><rt></rt>').type).toBe('MATCHED');
+	expect(c(models, '<rp></rp><rt></rt><rp></rp>').type).toBe('MATCHED');
+	expect(c(models, '<rp></rp><rt></rt>').type).toBe('MISSING_NODE_REQUIRED');
+	expect(c(models, '<rp></rp><rt></rt>').query).toBe('rp');
+	expect(c(models, '<rt></rt><rp></rp>').type).toBe('UNEXPECTED_EXTRA_NODE');
+	expect(c(models, '<rt></rt><rp></rp>').query).toBe('rt');
+});