markuplint 2.0.0-rc.6 → 2.1.1

package/lib/cli/bootstrap.mjs

@@ -0,0 +1,81 @@
+import meow from 'meow';
+export const help = `
+Usage
+	$ markuplint <HTML file pathes (glob format)>
+	$ <stdout> | markuplint
+
+Options
+	--config,                -c FILE_PATH  A configuration file path.
+	--fix,                                 Fix HTML.
+	--format,                -f FORMAT     Output format. Support "JSON", "Simple" and "Standard". Default: "Standard".
+	--no-search-config                     No search a configure file automatically.
+	--ignore-ext                           Evaluate files that are received even though the type of extension.
+	--no-import-preset-rules               No import preset rules.
+	--locale                               Locale of the message of violation. Default is an OS setting.
+	--no-color,                            Output no color.
+	--problem-only,          -p            Output only problems, without passeds.
+	--verbose                              Output with detailed information.
+
+	--init                                 Initialize settings interactively.
+	--create-rule                          Add the scaffold of a custom rule.
+
+	--help,                  -h            Show help.
+	--version,               -v            Show version.
+
+Examples
+	$ markuplint verifyee.html --config path/to/.markuplintrc
+	$ cat verifyee.html | markuplint
+`;
+export const cli = meow(help, {
+    importMeta: import.meta,
+    flags: {
+        config: {
+            type: 'string',
+            alias: 'c',
+        },
+        fix: {
+            type: 'boolean',
+            default: false,
+        },
+        format: {
+            type: 'string',
+            alias: 'f',
+        },
+        searchConfig: {
+            type: 'boolean',
+            default: true,
+        },
+        ignoreExt: {
+            type: 'boolean',
+            default: false,
+        },
+        importPresetRules: {
+            type: 'boolean',
+            default: true,
+        },
+        locale: {
+            type: 'string',
+        },
+        color: {
+            type: 'boolean',
+            default: true,
+        },
+        problemOnly: {
+            type: 'boolean',
+            alias: 'p',
+            default: false,
+        },
+        verbose: {
+            type: 'boolean',
+            default: false,
+        },
+        init: {
+            type: 'boolean',
+            default: false,
+        },
+        createRule: {
+            type: 'boolean',
+            default: false,
+        },
+    },
+});

package/lib/cli/command.d.mts

@@ -0,0 +1,3 @@
+import type { CLIOptions } from './bootstrap.mjs';
+import type { Target } from '@markuplint/file-resolver';
+export declare function command(files: Target[], options: CLIOptions): Promise<boolean>;

package/lib/cli/command.mjs

@@ -0,0 +1,50 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import { resolveFiles } from '@markuplint/file-resolver';
+import { MLEngine } from '../api/index.mjs';
+import { log } from '../debug.mjs';
+import { output } from './output.mjs';
+export async function command(files, options) {
+    const fix = options.fix;
+    const configFile = options.config && path.join(process.cwd(), options.config);
+    const locale = options.locale;
+    const searchConfig = options.searchConfig;
+    const ignoreExt = options.ignoreExt;
+    const importPresetRules = options.importPresetRules;
+    const verbose = options.verbose;
+    const fileList = await resolveFiles(files);
+    if (log.enabled) {
+        log('File list: %O', fileList.map(f => f.path));
+        log('Config: %s', configFile || 'N/A');
+        log('Fix option: %s', fix);
+    }
+    let hasError = false;
+    for (const file of fileList) {
+        const engine = new MLEngine(file, {
+            configFile,
+            fix,
+            locale,
+            noSearchConfig: !searchConfig,
+            ignoreExt,
+            importPresetRules,
+            debug: verbose,
+        });
+        const result = await engine.exec();
+        if (!result) {
+            continue;
+        }
+        if (!hasError && result.violations.length) {
+            hasError = true;
+        }
+        if (fix) {
+            log('Overwrite file: %s', result.filePath);
+            await fs.writeFile(result.filePath, result.fixedCode, { encoding: 'utf8' });
+            process.stdout.write(`markuplint: Fix "${result.filePath}"\n`);
+        }
+        else {
+            log('Output reports');
+            await output(result, options);
+        }
+    }
+    return hasError;
+}

package/lib/cli/create-rule/index.d.mts

@@ -0,0 +1 @@
+export declare function createRule(): Promise<void>;

package/lib/cli/create-rule/index.mjs

@@ -0,0 +1,51 @@
+import * as createRuleHelper from '@markuplint/create-rule-helper';
+import c from 'cli-color';
+import { write, head } from '../../util.mjs';
+import { installModule } from '../init/install-module.mjs';
+import { input, select, confirm } from '../prompt.mjs';
+export async function createRule() {
+    write(head('Create a rule'));
+    write.break();
+    const purpose = await select({
+        message: 'What purpose do you create the rule for?',
+        choices: [
+            { name: 'Add the rule to this project', value: 'ADD_TO_PROJECT' },
+            { name: 'Create the rule and publish it as a package', value: 'PUBLISH_AS_PACKAGE' },
+            { name: 'Contribute the new rule to markuplint core rules', value: 'CONTRIBUTE_TO_CORE' },
+        ],
+    });
+    const name = await input('What is the name?', /^[a-z][a-z0-9]*(?:-[a-z][a-z0-9]*)*$/i);
+    const lang = purpose === 'CONTRIBUTE_TO_CORE'
+        ? 'TYPESCRIPT'
+        : await select({
+            message: 'Which language will you implement?',
+            choices: [
+                { name: 'TypeScript', value: 'TYPESCRIPT' },
+                { name: 'JavaScript', value: 'JAVASCRIPT' },
+            ],
+        });
+    const needTest = purpose === 'CONTRIBUTE_TO_CORE' ? true : await confirm('Do you need the test?', { initial: true });
+    const result = await createRuleHelper.createRuleHelper({ purpose, name, lang, needTest });
+    output(name, '📝', 'README.md', result.readme);
+    output(name, '📜', 'index', result.main);
+    if (result.test) {
+        output(name, '🖍 ', 'index.spec', result.test);
+    }
+    if (result.schemaJson) {
+        output(name, '⚙️ ', 'schema.json', result.schemaJson);
+    }
+    if (result.packageJson) {
+        output(name, '🎁 ', 'package.json', result.packageJson);
+        if (result.tsConfig) {
+            output(name, '💎 ', 'tsconfig.json', result.tsConfig);
+        }
+        await installModule(result.dependencies);
+        await installModule(result.devDependencies, true);
+    }
+}
+function output(name, icon, title, path) {
+    const _marker = c.xterm(39)('✔') + ' ';
+    const _title = (icon, title) => `${icon} ` + c.bold(`${name}/${title}`);
+    const _file = (path) => ' ' + c.cyanBright(path);
+    write(_marker + _title(icon, title) + _file(path));
+}

package/lib/cli/index.d.mts

@@ -0,0 +1 @@
+export {};

package/lib/cli/index.mjs

@@ -0,0 +1,64 @@
+import getStdin from 'get-stdin';
+import { verbosely } from '../debug.mjs';
+import { cli } from './bootstrap.mjs';
+import { command } from './command.mjs';
+import { createRule } from './create-rule/index.mjs';
+import { initialize } from './init/index.mjs';
+(async () => {
+    if (cli.flags.v) {
+        cli.showVersion(); // And exit successfully.
+    }
+    if (cli.flags.h) {
+        cli.showHelp(0); // And exit successfully.
+    }
+    if (cli.flags.verbose) {
+        verbosely();
+    }
+    if (cli.flags.init) {
+        await initialize().catch(err => {
+            process.stderr.write(err + '\n');
+            process.exit(1);
+        });
+        return;
+    }
+    if (cli.flags.createRule) {
+        await createRule().catch(err => {
+            process.stderr.write(err + '\n');
+            process.exit(1);
+        });
+        return;
+    }
+    const files = cli.input;
+    if (files.length) {
+        const hasError = await command(files, cli.flags).catch(err => {
+            throw err;
+            // process.exit(1);
+        });
+        process.exit(hasError ? 1 : 0);
+    }
+    if (usePipe()) {
+        getStdin()
+            .then(async (stdin) => {
+            if (stdin) {
+                const hasError = await command([{ sourceCode: stdin }], cli.flags).catch(err => {
+                    process.stderr.write(err + '\n');
+                    process.exit(1);
+                });
+                process.exit(hasError ? 1 : 0);
+            }
+            // result is empty
+            cli.showHelp(1);
+        })
+            .catch(reason => {
+            // eslint-disable-next-line no-console
+            console.warn(reason);
+            process.exit(1);
+        });
+    }
+    else {
+        cli.showHelp(1);
+    }
+})();
+function usePipe() {
+    return !process.stdin.isTTY && process.stdout.isTTY;
+}

package/lib/cli/index.spec.d.mts

@@ -0,0 +1 @@
+export {};

package/lib/cli/index.spec.mjs

@@ -0,0 +1,48 @@
+import path from 'path';
+import { execa } from 'execa';
+import { cli } from './bootstrap.mjs';
+const entryFilePath = path.resolve(__dirname, '../../bin/markuplint');
+describe('STDOUT Test', () => {
+    it('empty', async () => {
+        const resultPromise = execa(entryFilePath, []);
+        await expect(resultPromise).rejects.toThrow(cli.help);
+    });
+    it('version', async () => {
+        const { stdout } = await execa(entryFilePath, ['--version']);
+        expect(stdout).toBe(cli.pkg.version);
+    });
+    it('version', async () => {
+        const { stdout } = await execa(entryFilePath, ['-v']);
+        expect(stdout).toBe(cli.pkg.version);
+    });
+    it('version', async () => {
+        const { stdout } = await execa(entryFilePath, ['--help']);
+        const { stdout: stdoutShort } = await execa(entryFilePath, ['-h']);
+        expect(stdout).toBe(stdoutShort);
+    });
+    it('verify', async () => {
+        const targetFilePath = path.resolve(__dirname, '../../../../test/fixture/001.html');
+        const { stdout, exitCode } = await execa(entryFilePath, ['--no-color', targetFilePath]);
+        expect(stdout).toBe(`<markuplint> passed ${targetFilePath}`);
+        expect(exitCode).toBe(0);
+    });
+    it('verify --problem-only', async () => {
+        const targetFilePath = path.resolve(__dirname, '../../../../test/fixture/001.html');
+        const { stdout } = await execa(entryFilePath, ['--problem-only', targetFilePath]);
+        expect(stdout).toBe('');
+    });
+    it('verify and feilure', async () => {
+        const targetFilePath = path.resolve(__dirname, '../../../../test/fixture/002.html');
+        const { stdout, stderr, exitCode } = await execa(entryFilePath, ['--no-color', targetFilePath], {
+            reject: false,
+        });
+        expect(stdout).toBe('');
+        expect(stderr.split('\n').length).toBe(34);
+        expect(exitCode).toBe(1);
+    });
+    it('format', async () => {
+        const targetFilePath = path.resolve(__dirname, '../../../../test/fixture/001.html');
+        const { stdout } = await execa(entryFilePath, ['--format', 'JSON', targetFilePath]);
+        expect(stdout).toBe('[]');
+    });
+});

package/lib/cli/init/index.d.mts

@@ -0,0 +1 @@
+export declare function initialize(): Promise<void>;

package/lib/cli/init/index.mjs

@@ -0,0 +1,266 @@
+import fs from 'fs';
+import path from 'path';
+import util from 'util';
+import { mergeConfig } from '@markuplint/ml-config';
+import { head, write, error } from '../../util.mjs';
+import { confirm, confirmSequence, multiSelect } from '../prompt.mjs';
+import { installModule } from './install-module.mjs';
+const writeFile = util.promisify(fs.writeFile);
+const ruleCategories = {
+    validation: {
+        message: 'Are you going to conformance check according to HTML standard?',
+    },
+    a11y: {
+        message: 'Are you going to do with accessibility better practices?',
+    },
+    'naming-convention': {
+        message: 'Are you going to set the convention about naming?',
+    },
+    style: {
+        message: 'Are you going to check for the code styles?',
+    },
+};
+const defaultRules = {
+    'attr-duplication': {
+        category: 'validation',
+        default: true,
+    },
+    'attr-equal-space-after': {
+        category: 'style',
+        default: true,
+    },
+    'attr-equal-space-before': {
+        category: 'style',
+        default: true,
+    },
+    'attr-spacing': {
+        category: 'style',
+        default: true,
+    },
+    'attr-value-quotes': {
+        category: 'style',
+        default: true,
+    },
+    'case-sensitive-attr-name': {
+        category: 'style',
+        default: true,
+    },
+    'case-sensitive-attr-value': {
+        category: 'style',
+        default: true,
+    },
+    'case-sensitive-tag-name': {
+        category: 'style',
+        default: true,
+    },
+    'character-reference': {
+        category: 'validation',
+        default: true,
+    },
+    'class-naming': {
+        category: 'naming-convention',
+        default: false,
+        recommendedValue: '/.+/',
+    },
+    'deprecated-attr': {
+        category: 'validation',
+        default: true,
+    },
+    'deprecated-element': {
+        category: 'validation',
+        default: true,
+    },
+    'disallowed-element': {
+        category: 'validation',
+        default: false,
+    },
+    doctype: {
+        category: 'validation',
+        default: true,
+    },
+    'end-tag': {
+        category: 'style',
+        default: true,
+    },
+    'id-duplication': {
+        category: 'validation',
+        default: true,
+    },
+    indentation: {
+        category: 'style',
+        default: false,
+        recommendedValue: 2,
+    },
+    'ineffective-attr': {
+        category: 'validation',
+        default: true,
+    },
+    'invalid-attr': {
+        category: 'validation',
+        default: true,
+    },
+    'landmark-roles': {
+        category: 'a11y',
+        default: true,
+    },
+    'no-boolean-attr-value': {
+        category: 'style',
+        default: true,
+    },
+    'no-default-value': {
+        category: 'style',
+        default: true,
+    },
+    'no-hard-code-id': {
+        category: 'style',
+        default: true,
+    },
+    'no-refer-to-non-existent-id': {
+        category: 'a11y',
+        default: true,
+    },
+    'no-use-event-handler-attr': {
+        category: 'style',
+        default: true,
+    },
+    'permitted-contents': {
+        category: 'validation',
+        default: true,
+    },
+    'required-attr': {
+        category: 'validation',
+        default: true,
+    },
+    'required-element': {
+        category: 'validation',
+        default: true,
+    },
+    'required-h1': {
+        category: 'a11y',
+        default: true,
+    },
+    'wai-aria': {
+        category: 'a11y',
+        default: true,
+    },
+};
+const extRExp = {
+    jsx: '\\.[jt]sx?$',
+    vue: '\\.vue$',
+    svelte: '\\.svelte$',
+    astro: '\\.astro',
+    pug: '\\.pug$',
+    php: '\\.php$',
+    erb: '\\.erb$',
+    ejs: '\\.ejs$',
+    mustache: '\\.(mustache|handlebars)$',
+    nunjucks: '\\.nunjucks$',
+    liquid: '\\.liquid$',
+};
+export async function initialize() {
+    let config = {};
+    write(head('Initialization'));
+    write.break();
+    const langs = await multiSelect({
+        message: 'Which do you use template engines?',
+        choices: [
+            { name: 'React (JSX)', value: 'jsx' },
+            { name: 'Vue', value: 'vue' },
+            { name: 'Svelte', value: 'svelte' },
+            { name: 'Astro', value: 'astro' },
+            { name: 'Pug', value: 'pug' },
+            { name: 'PHP', value: 'php' },
+            { name: 'eRuby', value: 'erb' },
+            { name: 'EJS', value: 'ejs' },
+            { name: 'Mustache/Handlebars', value: 'mustache' },
+            { name: 'Nunjucks', value: 'nunjucks' },
+            { name: 'liquid (Shopify)', value: 'liquid' },
+        ],
+    });
+    const autoInstall = await confirm('May I install them automatically?');
+    const customize = await confirm('Do you customize rules?');
+    for (const lang of langs) {
+        config.parser = config.parser || {};
+        // @ts-ignore
+        const ext = extRExp[lang];
+        if (!ext) {
+            continue;
+        }
+        config.parser[ext] = `@markuplint/${lang}-parser`;
+        if (lang === 'vue') {
+            config = mergeConfig(config, {
+                specs: {
+                    '\\.vue$': '@markuplint/vue-spec',
+                },
+            });
+        }
+        if (lang === 'jsx') {
+            config = mergeConfig(config, {
+                specs: {
+                    '\\.[jt]sx?$': '@markuplint/react-spec',
+                },
+            });
+        }
+    }
+    if (customize) {
+        const ruleNames = Object.keys(defaultRules);
+        const categories = Object.keys(ruleCategories);
+        const res = await confirmSequence(categories.map(catName => {
+            const cat = ruleCategories[catName];
+            return {
+                message: cat.message,
+                name: catName,
+            };
+        }));
+        for (const ruleName of ruleNames) {
+            const rule = defaultRules[ruleName];
+            if (!rule) {
+                continue;
+            }
+            if (res[rule.category]) {
+                if (!config.rules) {
+                    config.rules = {};
+                }
+                config.rules[ruleName] = rule.recommendedValue || true;
+            }
+        }
+    }
+    else {
+        const recommended = await confirm('Does it import the recommended config?');
+        if (recommended) {
+            config.extends = [...(config.extends || []), 'markuplint:recommended'];
+        }
+        else {
+            config.rules = {};
+            const ruleNames = Object.keys(defaultRules);
+            for (const ruleName of ruleNames) {
+                const rule = defaultRules[ruleName];
+                config.rules[ruleName] = rule.default;
+            }
+        }
+    }
+    const filePath = path.resolve(process.cwd(), '.markuplintrc');
+    await writeFile(filePath, JSON.stringify(config, null, 2), { encoding: 'utf-8' });
+    write(`✨Created: ${filePath}`);
+    if (autoInstall) {
+        write('Install automatically');
+        const modules = ['markuplint', ...langs.map(lang => `@markuplint/${lang}-parser`)];
+        if (langs.includes('vue')) {
+            modules.push('@markuplint/vue-spec');
+        }
+        if (langs.includes('jsx')) {
+            modules.push('@markuplint/react-spec');
+        }
+        const result = await installModule(modules, true).catch(e => new Error(e));
+        if (result instanceof Error) {
+            error.exit();
+            return;
+        }
+        if (result.alreadyExists) {
+            write('Modules are installed already.');
+        }
+        else {
+            write('✨ Success');
+        }
+    }
+}

package/lib/cli/init/install-module.d.mts

@@ -0,0 +1,5 @@
+export declare type InstallModuleResult = {
+    success: boolean;
+    alreadyExists: boolean;
+};
+export declare function installModule(module: string[], dev?: boolean): Promise<InstallModuleResult>;

package/lib/cli/init/install-module.mjs

@@ -0,0 +1,61 @@
+import { spawnSync } from 'child_process';
+import c from 'cli-color';
+// @ts-ignore
+import detectInstalled from 'detect-installed';
+import hasYarn from 'has-yarn';
+export async function installModule(module, dev = false) {
+    module = module.map(m => m.trim());
+    const uninstallMods = [];
+    try {
+        for (const mod of module) {
+            const installed = await isInstalled(mod);
+            if (!installed) {
+                uninstallMods.push(mod);
+            }
+        }
+    }
+    catch (_) {
+        // void
+    }
+    if (!uninstallMods.length) {
+        return {
+            success: true,
+            alreadyExists: true,
+        };
+    }
+    const mod = hasYarn() ? 'yarn' : 'npm';
+    const installOpt = hasYarn() ? 'add' : 'install';
+    const opt = [installOpt];
+    if (dev) {
+        opt.push('-D');
+    }
+    opt.push(...uninstallMods);
+    return new Promise((resolve, reject) => {
+        process.stdout.write(c.blackBright(`${mod} ${opt.join(' ')}\n`));
+        const result = spawnSync(mod, opt, { stdio: 'inherit' });
+        if (result.error || result.status !== 0) {
+            const message = 'Error running command.';
+            const error = new Error(message);
+            error.stack = message;
+            reject(error);
+        }
+        resolve({
+            success: true,
+            alreadyExists: false,
+        });
+    });
+}
+async function isInstalled(module) {
+    return new Promise((resolve, reject) => {
+        try {
+            detectInstalled(module, {
+                local: true,
+            }).then((exists) => {
+                resolve(exists);
+            });
+        }
+        catch (err) {
+            reject(err);
+        }
+    });
+}

package/lib/cli/output.d.mts

@@ -0,0 +1,3 @@
+import type { MLResultInfo } from '../types.mjs';
+import type { CLIOptions } from './bootstrap.mjs';
+export declare function output(results: MLResultInfo, options: CLIOptions): Promise<void>;

package/lib/cli/output.mjs

@@ -0,0 +1,31 @@
+import stripAnsi from 'strip-ansi';
+import { simpleReporter, standardReporter } from '../reporter/index.mjs';
+export async function output(results, options) {
+    const format = options.format ?? 'Standard';
+    let out;
+    switch (format.toLowerCase()) {
+        case 'json': {
+            process.stdout.write(JSON.stringify(results.violations, null, 2));
+            return;
+        }
+        case 'simple': {
+            out = simpleReporter(results, options);
+            break;
+        }
+        default: {
+            out = standardReporter(results, options);
+        }
+    }
+    if (!out.length) {
+        return;
+    }
+    let msg = `${out.join('\n')}\n`;
+    msg = options.color ? msg : stripAnsi(msg);
+    // If it has errors, Write to `stderr` and failure and exit.
+    if (results.violations.length) {
+        process.stderr.write(msg);
+        process.exitCode = 1;
+        return;
+    }
+    process.stdout.write(msg);
+}