stylelint-find-new-rules 3.0.2 → 4.0.0

package/lib/cli.js

@@ -1,18 +1,18 @@
 'use strict';
 
-const chalk      = require('chalk');
-const yargs      = require('yargs');
+const colors = require('picocolors');
+const yargs = require('yargs');
 const standalone = require('./index');
 const { print, printRules } = require('./utils/print');
 
 const pkg = require('../package.json');
 
 const DEFAULT_OPTIONS = {
-    unused     : true,
-    deprecated : true,
-    invalid    : true,
-    current    : false,
-    available  : false
+    unused: true,
+    deprecated: true,
+    invalid: true,
+    current: false,
+    available: false,
 };
 
 const handleError = (err) => {
@@ -21,7 +21,7 @@ const handleError = (err) => {
         errMsg = err.message || err.error || JSON.stringify(err);
     }
 
-    print(chalk.red(`Error: ${errMsg}`));
+    print(colors.red(`Error: ${errMsg}`));
     process.exit(1);
 };
 
@@ -33,43 +33,43 @@ const { argv } = yargs
     .example('stylelint-find-new-rules --no-d --no-i')
     .example('stylelint-find-new-rules path/to/custom.config.js')
     .option('u', {
-        type     : 'boolean',
-        alias    : 'unused',
-        describe : (
+        type: 'boolean',
+        alias: 'unused',
+        describe: (
             `Find available rules that are not configured.\n` +
-            `To disable, set to ${chalk.blue('false')} or use ${chalk.blue('--no-u')}`
+            `To disable, set to ${colors.blue('false')} or use ${colors.blue('--no-u')}`
         ),
-        default: DEFAULT_OPTIONS.unused
+        default: DEFAULT_OPTIONS.unused,
     })
     .option('d', {
-        type     : 'boolean',
-        alias    : 'deprecated',
-        describe : (
+        type: 'boolean',
+        alias: 'deprecated',
+        describe: (
             `Find deprecated configured rules.\n` +
-            `To disable, set to ${chalk.blue('false')} or use ${chalk.blue('--no-d')}`
+            `To disable, set to ${colors.blue('false')} or use ${colors.blue('--no-d')}`
         ),
-        default: DEFAULT_OPTIONS.deprecated
+        default: DEFAULT_OPTIONS.deprecated,
     })
     .option('i', {
-        type     : 'boolean',
-        alias    : 'invalid',
-        describe : (
+        type: 'boolean',
+        alias: 'invalid',
+        describe: (
             `Find configured rules that are no longer available.\n` +
-            `To disable, set to ${chalk.blue('false')} or use ${chalk.blue('--no-i')}`
+            `To disable, set to ${colors.blue('false')} or use ${colors.blue('--no-i')}`
         ),
-        default: DEFAULT_OPTIONS.invalid
+        default: DEFAULT_OPTIONS.invalid,
     })
     .option('c', {
-        type     : 'boolean',
-        alias    : 'current',
-        describe : 'Find all currently configured rules.',
-        default  : DEFAULT_OPTIONS.current
+        type: 'boolean',
+        alias: 'current',
+        describe: 'Find all currently configured rules.',
+        default: DEFAULT_OPTIONS.current,
     })
     .option('a', {
-        type     : 'boolean',
-        alias    : 'available',
-        describe : 'Find all available stylelint rules.',
-        default  : DEFAULT_OPTIONS.available
+        type: 'boolean',
+        alias: 'available',
+        describe: 'Find all available stylelint rules.',
+        default: DEFAULT_OPTIONS.available,
     })
     .help('h')
     .alias('h', 'help')
@@ -81,11 +81,11 @@ const options = Object.entries(DEFAULT_OPTIONS).reduce(
         const value = name in argv ? argv[name] : defaultValue;
         return { ...acc, [name]: value };
     },
-    {}
+    {},
 );
 
 if (!options.unused && !options.deprecated && !options.current && !options.available) {
-    print(chalk.red(`Oops, one of the command line Options must be set...`));
+    print(colors.red(`Oops, one of the command line Options must be set...`));
     yargs.showHelp();
     process.exit(1);
 }
@@ -110,20 +110,20 @@ const printResults = (rules) => {
     if (options.deprecated && rules.deprecated.length) {
         hasOutdatedRules = true;
         printRules(`[DEPRECATED] Configured rules that are deprecated:`, rules.deprecated, {
-            color: 'red'
+            color: 'red',
         });
     }
 
     if (options.invalid && rules.invalid.length) {
         hasOutdatedRules = true;
         printRules(`[INVALID] Configured rules that are no longer available:`, rules.invalid, {
-            color    : 'red',
-            showLink : false
+            color: 'red',
+            showLink: false,
         });
     }
 
     if (!hasOutdatedRules) {
-        print(chalk.green(`All rules are up-to-date!`));
+        print(colors.green(`All rules are up-to-date!`));
     }
     process.exit(hasOutdatedRules ? 1 : 0);
 };

package/lib/index.js

@@ -1,42 +1,24 @@
 'use strict';
 
-const { cosmiconfig } = require('cosmiconfig');
+const { resolveConfig } = require('stylelint');
 const { getAllRules, getUsedRules } = require('./utils/rules');
 
-const getConfig = async function (configFile = null) {
-    const explorer = cosmiconfig('stylelint');
+module.exports = async (configFile = null) => {
+    const config = await resolveConfig(process.cwd(), { configFile });
 
-    let _cosmiConfig;
-    if (configFile) {
-        _cosmiConfig = await explorer.load(configFile);
-    } else {
-        _cosmiConfig = await explorer.search();
-    }
-
-    if (!_cosmiConfig) {
-        throw new Error(`No stylelint configuration found.`);
-    }
-
-    return _cosmiConfig.config;
-};
-
-module.exports = async function (file = null) {
-    const userConfig = await getConfig(file);
-
-    const all        = getAllRules(userConfig);
-    const used       = getUsedRules(userConfig, all);
+    const all = getAllRules(config);
+    const used = getUsedRules(config, all);
     const deprecated = used.filter(({ isDeprecated }) => isDeprecated);
 
     const unused = all.filter(
         ({ name, isDeprecated }) => (
-            !isDeprecated && !used.find(_rule => _rule.name === name)
-        )
+            !isDeprecated && !used.find((_rule) => _rule.name === name)
+        ),
     );
 
     const invalid = used.filter(
-        ({ name }) => !all.find(_rule => _rule.name === name)
+        ({ name }) => !all.find((_rule) => _rule.name === name),
     );
 
-    // eslint-disable-next-line object-curly-newline
     return { all, used, unused, invalid, deprecated };
 };

package/lib/utils/extractRuleMeta.js

@@ -0,0 +1,57 @@
+'use strict';
+
+const PLUGINS_URL_RESOLVER = {
+    'stylelint': (rule) => (
+        `https://stylelint.io/user-guide/rules/list/${rule}`
+    ),
+    'stylelint-scss': (rule) => (
+        `https://github.com/kristerkari/stylelint-scss/blob/master/src/rules/${rule}/README.md`
+    ),
+    'stylelint-order': (rule) => (
+        `https://github.com/hudochenkov/stylelint-order/blob/master/rules/${rule}/README.md`
+    ),
+    'stylelint-declaration-block-no-ignored-properties': () => (
+        'https://github.com/kristerkari/stylelint-declaration-block-no-ignored-properties'
+    ),
+    'stylelint-prettier': () => 'https://github.com/prettier/stylelint-prettier',
+};
+
+// @see https://regex101.com/r/4d3Jpl/2
+const DEPRECATED_REGEX = /result\.warn\(\s*.+,\s*{\s*.*\s*['"]?stylelintType['"]?\s*:\s*['"]deprecation['"],/i;
+
+const extractRuleMeta = (name, rule, isPlugin) => {
+    const meta = rule.meta || {};
+
+    const deprecated = meta.deprecated === 'undefined'
+        // - Hacky solution to find if the rule is deprecated since
+        //   stylelint do not provide metadata for rules.
+        // @see https://github.com/stylelint/stylelint/issues/2622
+        ? DEPRECATED_REGEX.test(rule().toString())
+        : !!meta.deprecated;
+
+    const url = (() => {
+        if (typeof meta.url === 'string') {
+            return meta.url;
+        }
+
+        if (!isPlugin) {
+            return PLUGINS_URL_RESOLVER.stylelint(name);
+        }
+
+        if (!name.includes('/')) {
+            return null;
+        }
+
+        // @see https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Global_Objects/String/split#description
+        // eslint-disable-next-line prefer-named-capture-group -- See above (about capturing groups in split's regex).
+        const [plugin, baseName] = name.split(/\/(.+)/);
+
+        return `stylelint-${plugin}` in PLUGINS_URL_RESOLVER
+            ? PLUGINS_URL_RESOLVER[`stylelint-${plugin}`](baseName)
+            : null;
+    })();
+
+    return { name, isDeprecated: deprecated, url };
+};
+
+module.exports = extractRuleMeta;

package/lib/utils/print.js

@@ -1,8 +1,8 @@
 'use strict';
 
 const columnify = require('columnify');
-const chalk     = require('chalk');
-const os        = require('os');
+const colors = require('picocolors');
+const os = require('os');
 
 const print = (output) => {
     process.stdout.write(output);
@@ -11,7 +11,7 @@ const print = (output) => {
 
 const printRules = (heading, rules, options = {}) => {
     const defaults = { color: null, showLink: true };
-    const { color, showLink } = Object.assign({}, defaults, options);
+    const { color, showLink } = { ...defaults, ...options };
 
     const rulesToPrint = [...rules]
         .sort((a, b) => a.name.localeCompare(b.name))
@@ -20,18 +20,18 @@ const printRules = (heading, rules, options = {}) => {
                 const outRule = { rule: name };
 
                 if (color) {
-                    outRule.rule = chalk[`${color}Bright`](outRule.rule);
+                    outRule.rule = colors.bold(colors[color](outRule.rule));
                 }
 
                 if (showLink) {
-                    outRule.url = url ? chalk.cyan(url) : null;
+                    outRule.url = url ? colors.cyan(url) : null;
                 }
 
                 return outRule;
-            }
+            },
         );
 
-    print(chalk[color || 'blue'].underline(heading));
+    print(colors.underline(colors[color || 'blue'](heading)));
     print(columnify(rulesToPrint, {}));
 };
 

package/lib/utils/rules.js

@@ -1,73 +1,30 @@
 'use strict';
 
-const path            = require('path');
-const requireRelative = require('require-relative');
-const ruleBuilder     = require('./ruleBuilder');
-
-const requireResolveRelative = (moduleName, relativePath = null) => (
-    path.dirname(requireRelative.resolve(moduleName, relativePath))
-);
-
-const getStylelintRules = () => {
-    const stylelint  = requireRelative('stylelint');
-    const _buildRule = ruleBuilder('stylelint');
-
-    // @see https://regex101.com/r/4d3Jpl/2
-    const DEPRECATED_REGEX = /result\.warn\(\s*.+,\s*{\s*.*\s*['"]?stylelintType['"]?\s*:\s*['"]deprecation['"],/i;
-
-    return Object.entries(stylelint.rules).map(([name, rule]) => {
-        let { meta } = rule;
-
-        // - Hacky solution to find if the rule is deprecated since
-        //   stylelint do not provide metadata for rules.
-        // @see https://github.com/stylelint/stylelint/issues/2622
-        if (!meta) {
-            const deprecated = DEPRECATED_REGEX.test(rule().toString());
-            meta = { deprecated };
-        }
-
-        return _buildRule(name, { meta });
-    });
-};
+const coreRules = require('stylelint').rules;
+const extractRuleMeta = require('./extractRuleMeta');
 
 const getAllRules = (config) => {
-    const _gatherPluginsRules = (_config, relativePath = null) => {
-        const _rules = [];
-
-        if (_config.plugins) {
-            const _plugins = Array.isArray(_config.plugins) ? _config.plugins : [_config.plugins];
-            _plugins.forEach((plugin) => {
-                const isPathPlugin = path.isAbsolute(plugin) || plugin.startsWith('.');
-                const _buildRule = ruleBuilder(isPathPlugin ? '[UNKNOWN]' : plugin);
-
-                let pluginRules;
-                pluginRules = requireRelative(plugin, relativePath);
-                pluginRules = pluginRules.default || pluginRules; // - ES6 or CommonJS modules
-                pluginRules = Array.isArray(pluginRules) ? pluginRules : [pluginRules];
-
-                pluginRules.forEach(({ ruleName: name, rule }) => {
-                    if (!name || !name.includes('/')) {
-                        return;
-                    }
-                    _rules.push(_buildRule(name, rule));
-                });
+    const rules = Object.entries(coreRules).map(([name, rule]) => (
+        extractRuleMeta(name, rule, false)
+    ));
+
+    if (config.plugins) {
+        [config.plugins].flat().forEach((plugin) => {
+            let pluginRules;
+            pluginRules = require(plugin); // eslint-disable-line import/no-dynamic-require, global-require
+            pluginRules = pluginRules.default || pluginRules; // - ES6 or CommonJS modules
+            pluginRules = [pluginRules].flat();
+
+            pluginRules.forEach(({ ruleName: name, rule }) => {
+                if (!name || !name.includes('/')) {
+                    return;
+                }
+                rules.push(extractRuleMeta(name, rule, true));
             });
-        }
-
-        if (_config.extends) {
-            const _extends = Array.isArray(_config.extends) ? _config.extends : [_config.extends];
-            _extends.forEach((extendName) => {
-                const extendedConfigPath = requireResolveRelative(extendName, relativePath);
-                const extendedConfig = requireRelative(extendName, relativePath);
-                _rules.push(..._gatherPluginsRules(extendedConfig, extendedConfigPath));
-            });
-        }
-
-        return _rules;
-    };
+        });
+    }
 
-    const pluginsRules = _gatherPluginsRules(config);
-    return getStylelintRules().concat(pluginsRules);
+    return rules;
 };
 
 const getUsedRules = (config, allRules = null) => {
@@ -75,31 +32,14 @@ const getUsedRules = (config, allRules = null) => {
         allRules = getAllRules(config);
     }
 
-    const _gatherRules = (_config, relativePath = null) => {
-        const rulesNames = Object.keys(_config.rules || {});
-
-        // - Extends
-        if (_config.extends) {
-            const _extends = Array.isArray(_config.extends) ? _config.extends : [_config.extends];
-
-            _extends.forEach((extendName) => {
-                const extendedConfigPath = requireResolveRelative(extendName, relativePath);
-                const extendedConfig = requireRelative(extendName, relativePath);
-                rulesNames.push(..._gatherRules(extendedConfig, extendedConfigPath));
-            });
-        }
-
-        return rulesNames;
-    };
-
-    const rules = _gatherRules(config)
+    const rules = Object.keys(config.rules || {})
         .filter((value, index, self) => self.indexOf(value) === index)
         .map((name) => {
-            const rule = allRules.find(_rule => _rule.name === name);
+            const rule = allRules.find((_rule) => _rule.name === name);
             return rule || { name, url: null };
         });
 
     return rules;
 };
 
-module.exports = { getUsedRules, getAllRules, getStylelintRules };
+module.exports = { getUsedRules, getAllRules };

package/package.json

@@ -1,33 +1,33 @@
 {
-    "name"         : "stylelint-find-new-rules",
-    "version"      : "3.0.2",
-    "description"  : "Find stylelint rules that you don't have in your config",
-    "homepage"     : "https://github.com/Donov4n/stylelint-find-new-rules",
-    "license"      : "MIT",
-    "repository"   : "Donov4n/stylelint-find-new-rules",
-    "author"       : "Donovan Lambert <d.lambert@cirize.com>",
-    "contributors" : ["Alex Ilyaev"],
-    "main"         : "lib/index.js",
-    "bin"          : {
+    "name": "stylelint-find-new-rules",
+    "version": "4.0.0",
+    "description": "Find stylelint rules that you don't have in your config",
+    "homepage": "https://github.com/Donov4n/stylelint-find-new-rules",
+    "license": "MIT",
+    "repository": "Donov4n/stylelint-find-new-rules",
+    "author": "Donovan Lambert <d.lambert@cirize.com>",
+    "contributors": [
+        "Alex Ilyaev"
+    ],
+    "main": "lib/index.js",
+    "bin": {
         "stylelint-find-new-rules": "bin/stylelint-find-new-rules.js"
     },
     "scripts": {
         "lint": "eslint --ext .js lib"
     },
     "dependencies": {
-        "chalk": "~4.1.2",
-        "columnify": "~1.5.4",
-        "cosmiconfig": "~7.0.0",
-        "require-relative": "~0.8.7",
-        "yargs": "~17.1.1"
+        "columnify": "~1.6.0",
+        "picocolors": "^1.0.0",
+        "yargs": "~17.3.1"
     },
     "devDependencies": {
-        "eslint": "^7.32.0",
-        "eslint-config-airbnb-base": "^14.2.1",
-        "eslint-plugin-import": "^2.24.0"
+        "@pulsanova/eslint-config-base": "~2.1.2",
+        "eslint": "^8.11.0",
+        "stylelint": "^14"
     },
     "peerDependencies": {
-        "stylelint": "^13"
+        "stylelint": "^14"
     },
     "engines": {
         "node": ">=10"

package/lib/utils/ruleBuilder.js

@@ -1,39 +0,0 @@
-'use strict';
-
-const PLUGINS_URL_RESOLVER = {
-    'stylelint': rule => (
-        `https://stylelint.io/user-guide/rules/${rule}/`
-    ),
-    'stylelint-scss': rule => (
-        `https://github.com/kristerkari/stylelint-scss/blob/master/src/rules/${rule}/README.md`
-    ),
-    'stylelint-order': rule => (
-        `https://github.com/hudochenkov/stylelint-order/blob/master/rules/${rule}/README.md`
-    ),
-    'stylelint-declaration-block-no-ignored-properties': () => (
-        'https://github.com/kristerkari/stylelint-declaration-block-no-ignored-properties'
-    ),
-    'stylelint-prettier': () => 'https://github.com/prettier/stylelint-prettier'
-};
-
-const ruleBuilder = (resolverName) => {
-    const resolver = PLUGINS_URL_RESOLVER[resolverName];
-
-    return (name, rule) => {
-        const meta         = rule.meta || {};
-        const isDeprecated = meta.deprecated || false;
-
-        let baseName = name;
-        if (resolverName !== 'stylelint') {
-            const namespacePos = name.indexOf('/');
-            if (namespacePos !== -1) {
-                baseName = name.substr(namespacePos + 1);
-            }
-        }
-
-        const url = resolver ? resolver(baseName) : null;
-        return { name, isDeprecated, url };
-    };
-};
-
-module.exports = ruleBuilder;