@markuplint/rules 3.0.0-alpha.66 → 3.0.0-dev.176

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

@@ -0,0 +1,159 @@
+const { mlRuleTest } = require('markuplint');
+
+const rule = require('../../lib/attr-duplication').default;
+
+test('is test 1', async () => {
+	const { violations } = await mlRuleTest(
+		rule,
+		`
+		<div data-attr="value" data-Attr='db' data-attR=tr>
+			lorem
+			<p>ipsam</p>
+		</div>
+		`,
+	);
+
+	expect(violations).toStrictEqual([
+		{
+			severity: 'error',
+			message: 'The attribute name is duplicated',
+			line: 2,
+			col: 26,
+			raw: 'data-Attr',
+		},
+		{
+			severity: 'error',
+			message: 'The attribute name is duplicated',
+			line: 2,
+			col: 41,
+			raw: 'data-attR',
+		},
+	]);
+});
+
+test('is test 2', async () => {
+	const { violations } = await mlRuleTest(
+		rule,
+		`
+		<div
+			data-attr="value"
+			data-Attr='db'
+			data-attR=tr>
+			lorem
+			<p>ipsam</p>
+		</div>
+		`,
+	);
+
+	expect(violations).toStrictEqual([
+		{
+			severity: 'error',
+			message: 'The attribute name is duplicated',
+			line: 4,
+			col: 4,
+			raw: 'data-Attr',
+		},
+		{
+			severity: 'error',
+			message: 'The attribute name is duplicated',
+			line: 5,
+			col: 4,
+			raw: 'data-attR',
+		},
+	]);
+});
+
+test('is test 3', async () => {
+	const { violations } = await mlRuleTest(rule, '<img src="/" SRC="/" >', undefined, false, 'ja');
+
+	expect(violations.map(_ => _.message)).toStrictEqual(['属性名が重複しています']);
+});
+
+test('nodeRules disable', async () => {
+	const { violations } = await mlRuleTest(rule, '<div><span attr attr></span></div>', {
+		nodeRule: [
+			{
+				selector: 'span',
+				rule: false,
+			},
+		],
+	});
+
+	expect(violations.length).toStrictEqual(0);
+});
+
+test('Vue', async () => {
+	const { violations } = await mlRuleTest(rule, '<template><div attr v-bind:attr /></template>', {
+		parser: {
+			'.*': '@markuplint/vue-parser',
+		},
+	});
+
+	expect(violations).toStrictEqual([
+		{
+			severity: 'error',
+			line: 1,
+			col: 21,
+			message: 'The attribute name is duplicated',
+			raw: 'v-bind:attr',
+		},
+	]);
+});
+
+test('Vue (exception)', async () => {
+	const { violations } = await mlRuleTest(
+		rule,
+		'<template><div class="foo" v-bind:class="bar" style="a: b;" :style="{c: d}" /></template>',
+		{
+			parser: {
+				'.*': '@markuplint/vue-parser',
+			},
+		},
+	);
+
+	expect(violations.length).toBe(0);
+});
+
+test('React', async () => {
+	const { violations } = await mlRuleTest(rule, '<div tabindex tabIndex />', {
+		parser: {
+			'.*': '@markuplint/vue-parser',
+		},
+	});
+
+	expect(violations).toStrictEqual([]);
+});
+
+test('Pug', async () => {
+	const { violations } = await mlRuleTest(rule, '.hoge(class="hoge2")&attributes({class: "hoge3"})', {
+		parser: {
+			'.*': '@markuplint/pug-parser',
+		},
+	});
+
+	expect(violations.length).toBe(0);
+});
+
+test('Svelte', async () => {
+	const { violations } = await mlRuleTest(
+		rule,
+		'<div class:selected="{isSelected}" class:focused="{isFocused}"></div>',
+		{
+			parser: {
+				'.*': '@markuplint/svelte-parser',
+			},
+		},
+	);
+
+	expect(violations.length).toBe(0);
+});
+
+test('Astro', async () => {
+	const { violations } = await mlRuleTest(rule, '<div class:list="a" class="b"></div>', {
+		parser: {
+			'.*': '@markuplint/astro-parser',
+		},
+	});
+
+	expect(violations.length).toBe(1);
+});

package/test/attr-value-quotes/index.spec.js

@@ -0,0 +1,133 @@
+const { mlRuleTest } = require('markuplint');
+
+const rule = require('../../lib/attr-value-quotes').default;
+
+describe('verify', () => {
+	test('default', async () => {
+		const { violations } = await mlRuleTest(
+			rule,
+			`
+		<div data-attr="value" data-Attr='db' data-attR=tr>
+			lorem
+			<p>ipsam</p>
+		</div>
+		`,
+		);
+		expect(violations).toStrictEqual([
+			{
+				severity: 'warning',
+				message: 'Attribute value is must quote on double quotation mark',
+				line: 2,
+				col: 26,
+				raw: "data-Attr='db'",
+			},
+			{
+				severity: 'warning',
+				message: 'Attribute value is must quote on double quotation mark',
+				line: 2,
+				col: 41,
+				raw: 'data-attR=tr',
+			},
+		]);
+	});
+
+	test('double', async () => {
+		const { violations } = await mlRuleTest(
+			rule,
+			`
+		<div data-attr="value" data-Attr='db' data-attR=tr>
+			lorem
+			<p>ipsam</p>
+		</div>
+		`,
+			{
+				rule: {
+					severity: 'error',
+					value: 'double',
+					options: null,
+				},
+			},
+		);
+		expect(violations).toStrictEqual([
+			{
+				severity: 'error',
+				message: 'Attribute value is must quote on double quotation mark',
+				line: 2,
+				col: 26,
+				raw: "data-Attr='db'",
+			},
+			{
+				severity: 'error',
+				message: 'Attribute value is must quote on double quotation mark',
+				line: 2,
+				col: 41,
+				raw: 'data-attR=tr',
+			},
+		]);
+	});
+
+	test('single', async () => {
+		const { violations } = await mlRuleTest(
+			rule,
+			`
+		<div data-attr="value" data-Attr='db' data-attR=tr>
+			lorem
+			<p>ipsam</p>
+		</div>
+		`,
+			{
+				rule: {
+					severity: 'error',
+					value: 'single',
+					options: null,
+				},
+			},
+		);
+		expect(violations).toStrictEqual([
+			{
+				severity: 'error',
+				message: 'Attribute value is must quote on single quotation mark',
+				line: 2,
+				col: 8,
+				raw: 'data-attr="value"',
+			},
+			{
+				severity: 'error',
+				message: 'Attribute value is must quote on single quotation mark',
+				line: 2,
+				col: 41,
+				raw: 'data-attR=tr',
+			},
+		]);
+	});
+
+	test('empty', async () => {
+		const { violations } = await mlRuleTest(
+			rule,
+			`
+		<div data-attr>
+			lorem
+			<p>ipsam</p>
+		</div>
+		`,
+		);
+		expect(violations.length).toBe(0);
+	});
+});
+
+// describe('fix', () => {
+// 	test('empty', async () => {
+// 		const { fixedCode } = await mlRuleTest(rule, '<div attr noop=noop foo="bar" hoge=\'fuga\'>', undefined, true);
+// 		expect(fixedCode).toEqual('<div attr noop="noop" foo="bar" hoge="fuga">');
+// 	});
+
+// 	test('empty', async () => {
+// 		const { fixedCode } = await mlRuleTest(
+// 			rule,
+// 			'<div attr noop=noop foo="bar" hoge=\'fuga\'>',
+// 			{ rule: 'single' },
+// 			true,
+// 		);
+// 		expect(fixedCode).toEqual("<div attr noop='noop' foo='bar' hoge='fuga'>");
+// 	});
+// });

package/test/case-sensitive-attr-name/index.spec.js

@@ -0,0 +1,65 @@
+const { mlRuleTest } = require('markuplint');
+
+const rule = require('../../lib/case-sensitive-attr-name').default;
+
+describe('verify', () => {
+	test('lower case', async () => {
+		const { violations } = await mlRuleTest(rule, '<div data-lowercase></div>');
+		expect(violations).toStrictEqual([]);
+	});
+
+	test('upper case', async () => {
+		const { violations } = await mlRuleTest(rule, '<div data-UPPERCASE="value"></div>');
+		expect(violations[0].severity).toBe('warning');
+		expect(violations[0].message).toBe('Attribute names of HTML elements should be lowercase');
+		expect(violations[0].raw).toBe('data-UPPERCASE');
+	});
+
+	test('upper case', async () => {
+		const { violations } = await mlRuleTest(rule, '<div data-UPPERCASE="value"></div>', {
+			rule: {
+				severity: 'error',
+				value: 'upper',
+				options: null,
+			},
+		});
+		expect(violations[0].severity).toBe('error');
+		expect(violations[0].message).toBe('Attribute names of HTML elements must be uppercase');
+	});
+
+	test('upper case', async () => {
+		const { violations } = await mlRuleTest(rule, '<div data-uppercase="value"></div>', {
+			rule: {
+				severity: 'error',
+				value: 'upper',
+				options: null,
+			},
+		});
+		expect(violations[0].severity).toBe('error');
+		expect(violations[0].message).toBe('Attribute names of HTML elements must be uppercase');
+	});
+
+	test('upper case', async () => {
+		const { violations } = await mlRuleTest(rule, '<div DATA-UPPERCASE="value"></div>', {
+			rule: { severity: 'error', value: 'upper' },
+		});
+		expect(violations.length).toBe(0);
+	});
+
+	test('svg', async () => {
+		const { violations } = await mlRuleTest(rule, '<svg viewBox="0 0 100 100"></svg>');
+		expect(violations.length).toBe(0);
+	});
+});
+
+// describe('fix', () => {
+// 	test('upper case', async () => {
+// 		const { fixedCode } = await mlRuleTest(rule, '<DIV DATA-LOWERCASE></DIV>', undefined, true);
+// 		expect(fixedCode).toBe('<DIV data-lowercase></DIV>');
+// 	});
+
+// 	test('upper case', async () => {
+// 		const { fixedCode } = await mlRuleTest(rule, '<DIV data-lowercase></DIV>', { rule: 'upper' }, true);
+// 		expect(fixedCode).toBe('<DIV DATA-LOWERCASE></DIV>');
+// 	});
+// });

package/test/case-sensitive-tag-name/index.spec.js

@@ -0,0 +1,80 @@
+const { mlRuleTest } = require('markuplint');
+
+const rule = require('../../lib/case-sensitive-tag-name').default;
+
+describe('verify', () => {
+	test('lower case', async () => {
+		const { violations } = await mlRuleTest(rule, '<div data-lowercase></div>');
+		expect(violations).toStrictEqual([]);
+	});
+
+	test('upper case', async () => {
+		const { violations } = await mlRuleTest(rule, '<DIV data-lowercase></DIV>');
+		expect(violations[0].severity).toBe('warning');
+		expect(violations[0].message).toBe('Tag names of HTML elements should be lowercase');
+		expect(violations[0].raw).toBe('DIV');
+	});
+
+	test('upper case', async () => {
+		const { violations } = await mlRuleTest(rule, '<div data-UPPERCASE="value"></div>', {
+			rule: {
+				severity: 'error',
+				value: 'upper',
+			},
+		});
+		expect(violations[0].severity).toBe('error');
+		expect(violations[0].message).toBe('Tag names of HTML elements must be uppercase');
+	});
+
+	test('upper case', async () => {
+		const { violations } = await mlRuleTest(rule, '<DIV data-uppercase="value"></DIV>', {
+			rule: {
+				severity: 'error',
+				value: 'upper',
+			},
+		});
+		expect(violations.length).toBe(0);
+	});
+
+	test('upper case', async () => {
+		const { violations } = await mlRuleTest(rule, '<DIV DATA-UPPERCASE="value"></div>', {
+			rule: {
+				severity: 'error',
+				value: 'upper',
+			},
+		});
+		expect(violations.length).toBe(1);
+	});
+
+	test('upper case', async () => {
+		const { violations } = await mlRuleTest(rule, '<div DATA-UPPERCASE="value"></DIV>', {
+			rule: {
+				severity: 'error',
+				value: 'upper',
+			},
+		});
+		expect(violations.length).toBe(1);
+	});
+
+	test('svg', async () => {
+		const { violations } = await mlRuleTest(rule, '<svg viewBox="0 0 100 100"><textPath></textPath></svg>');
+		expect(violations.length).toBe(0);
+	});
+
+	test('custom elements', async () => {
+		const { violations } = await mlRuleTest(rule, '<xxx-hoge>lorem</xxx-hoge>');
+		expect(violations.length).toBe(0);
+	});
+
+	test('custom elements', async () => {
+		const { violations } = await mlRuleTest(rule, '<XXX-hoge>lorem</XXX-hoge>');
+		expect(violations.length).toBe(0);
+	});
+});
+
+// describe('fix', () => {
+// 	test('upper case', async () => {
+// 		const { fixedCode } = await mlRuleTest(rule, '<DIV data-lowercase></DIV>', undefined, true);
+// 		expect(fixedCode).toBe('<div data-lowercase></div>');
+// 	});
+// });

package/test/character-reference/index.spec.js

@@ -0,0 +1,57 @@
+const { mlRuleTest } = require('markuplint');
+
+const rule = require('../../lib/character-reference').default;
+
+test('character-reference', async () => {
+	const { violations } = await mlRuleTest(rule, '<div id="a"> > < & " \' &amp;</div>');
+	expect(violations.length).toBe(4);
+	expect(violations[0]).toStrictEqual({
+		severity: 'error',
+		message: 'Illegal characters must escape in character reference',
+		line: 1,
+		col: 14,
+		raw: '>',
+	});
+	expect(violations[1].col).toBe(16);
+	expect(violations[1].raw).toBe('<');
+	expect(violations[2].col).toBe(18);
+	expect(violations[2].raw).toBe('&');
+	expect(violations[3].col).toBe(20);
+	expect(violations[3].raw).toBe('"');
+});
+
+test('character-reference', async () => {
+	const { violations } = await mlRuleTest(rule, '<img src="path/to?a=b&c=d">');
+	expect(violations).toStrictEqual([
+		{
+			severity: 'error',
+			message: 'Illegal characters must escape in character reference',
+			line: 1,
+			col: 22,
+			raw: '&',
+		},
+	]);
+});
+
+test('character-reference', async () => {
+	const { violations } = await mlRuleTest(rule, '<script>if (i < 0) console.log("<markuplint>");</script>');
+	expect(violations.length).toBe(0);
+});
+
+test('in Vue', async () => {
+	const { violations } = await mlRuleTest(rule, '<template><div v-if="a < b"></div></template>', {
+		parser: {
+			'.*': '@markuplint/vue-parser',
+		},
+	});
+	expect(violations.length).toBe(0);
+});
+
+test('in EJS', async () => {
+	const { violations } = await mlRuleTest(rule, '<title><%- "title" _%></title>', {
+		parser: {
+			'.*': '@markuplint/ejs-parser',
+		},
+	});
+	expect(violations.length).toBe(0);
+});