@putout/engine-loader 11.3.0 → 11.5.0

package/lib/check/index.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const isString = (a) => typeof a === 'string';
+
+module.exports.check = (options) => {
+    if (!options || typeof options !== 'object')
+        throw Error('options should be an object!');
+};
+
+module.exports.checkRule = (rule) => {
+    if (!isString(rule))
+        throw Error(`☝️ Looks like plugin name type is not 'string', but: '${typeof rule}'`);
+};

package/lib/index.js

@@ -2,18 +2,23 @@
 
 const {nanomemoize} = require('nano-memoize');
 
-const isEnabled = require('./is-enabled');
-const {loadPlugin} = require('./load');
-const {createAsyncLoader} = require('./async-loader');
-const parsePluginNames = require('./parse-plugin-names');
-const parseProcessorNames = require('./parse-processor-names');
-const parseRules = require('./parse-rules');
-const validateRules = require('./validate-rules');
-const validatePlugin = require('./validate-plugin');
-const {mergeRules} = require('./merge-rules');
-const {loadPluginsAsync} = require('./load-plugins-async');
+const {loadPlugin} = require('./load/load');
+const {createAsyncLoader} = require('./load/async-loader');
+const {parsePluginNames} = require('./plugins/parse-plugin-names');
+const parseProcessorNames = require('./processors/parse-processor-names');
+const validatePlugin = require('./plugins/validate-plugin');
+const {loadPluginsAsync} = require('./plugins/load-plugins-async');
 
-const isString = (a) => typeof a === 'string';
+const {
+    parseRules,
+    validateRules,
+    isEnabled,
+    getLoadedRules,
+} = require('./rules');
+
+const {filterEnabledPlugins} = require('./plugins/filter-enabled-plugins');
+
+const {check, checkRule} = require('./check');
 
 module.exports.loadPluginsAsync = loadPluginsAsync;
 module.exports.loadProcessorsAsync = nanomemoize(async (options, load) => {
@@ -59,41 +64,12 @@ module.exports.loadPlugins = (options) => {
         items,
     });
     
-    const result = [];
-    
-    // Would be great to have ability to filter
-    // disabled plugins and prevent them from loading
-    // but we can't because of a way multi-rule plugins
-    // works. We can't determine count and names of all
-    // rules of a plugin before load.
-    for (const [name, plugin] of plugins) {
-        if (!isEnabled(name, cookedRules))
-            continue;
-        
-        result.push(mergeRules(
-            [name, plugin],
-            cookedRules,
-        ));
-    }
-    
-    return result;
+    return filterEnabledPlugins({
+        plugins,
+        cookedRules,
+    });
 };
 
-function getLoadedRules(rules) {
-    const loadedRules = [];
-    
-    for (const item of rules) {
-        const {rule} = item;
-        
-        if (rule.includes('/'))
-            continue;
-        
-        loadedRules.push(item);
-    }
-    
-    return loadedRules;
-}
-
 function splitRule(rule) {
     return [rule, 'putout'];
 }
@@ -141,13 +117,3 @@ function extendRules(rule, plugin) {
     
     return result;
 }
-
-function check(options) {
-    if (!options || typeof options !== 'object')
-        throw Error('options should be an object!');
-}
-
-function checkRule(rule) {
-    if (!isString(rule))
-        throw Error(`☝️ Looks like plugin name type is not 'string', but: '${typeof rule}'`);
-}

package/lib/plugins/filter-enabled-plugins.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const {isEnabled, mergeRules} = require('../rules');
+
+// Would be great to have ability to filter
+// disabled plugins and prevent them from loading
+// but we can't because of a way multi-rule plugins
+// works. We can't determine count and names of all
+// rules of a plugin before load.
+module.exports.filterEnabledPlugins = ({plugins, cookedRules}) => {
+    const result = [];
+    
+    for (const [name, plugin] of plugins) {
+        if (!isEnabled(name, cookedRules))
+            continue;
+        
+        result.push(mergeRules(
+            [name, plugin],
+            cookedRules,
+        ));
+    }
+    
+    return result;
+};

package/lib/{load-plugins-async.js → plugins/load-plugins-async.js}

@@ -1,15 +1,22 @@
 'use strict';
 
-const isEnabled = require('./is-enabled');
-const parseRules = require('./parse-rules');
-const {createAsyncLoader} = require('./async-loader');
-const parsePluginNames = require('./parse-plugin-names');
-const validateRules = require('./validate-rules');
+const {basename} = require('path');
+
+const {
+    parseRules,
+    validateRules,
+    isEnabled,
+    getLoadedRules,
+} = require('../rules');
+
+const {createAsyncLoader} = require('../load/async-loader');
+const {parsePluginNames} = require('./parse-plugin-names');
 const validatePlugin = require('./validate-plugin');
-const {mergeRules} = require('./merge-rules');
+const {filterEnabledPlugins} = require('./filter-enabled-plugins');
+
+const {check, checkRule} = require('../check');
 
 const loadPluginAsync = createAsyncLoader('plugin');
-const isString = (a) => typeof a === 'string';
 
 module.exports.loadPluginsAsync = async (options) => {
     check(options);
@@ -31,24 +38,10 @@ module.exports.loadPluginsAsync = async (options) => {
         items,
     });
     
-    const result = [];
-    
-    // Would be great to have ability to filter
-    // disabled plugins and prevent them from loading
-    // but we can't because of a way multi-rule plugins
-    // works. We can't determine count and names of all
-    // rules of a plugin before load.
-    for (const [name, plugin] of plugins) {
-        if (!isEnabled(name, cookedRules))
-            continue;
-        
-        result.push(mergeRules(
-            [name, plugin],
-            cookedRules,
-        ));
-    }
-    
-    return result;
+    return filterEnabledPlugins({
+        plugins,
+        cookedRules,
+    });
 };
 
 function splitRule(rule) {
@@ -68,7 +61,7 @@ async function loadPlugins({items, loadedRules}) {
         const [name] = splitRule(rule);
         const plugin = itemPlugin || loadPluginAsync(name);
         
-        enabledRules.push(rule);
+        enabledRules.push(parseRuleName(rule));
         promises.push(plugin);
     }
     
@@ -96,21 +89,6 @@ async function loadPlugins({items, loadedRules}) {
     return plugins;
 }
 
-function getLoadedRules(rules) {
-    const loadedRules = [];
-    
-    for (const item of rules) {
-        const {rule} = item;
-        
-        if (rule.includes('/'))
-            continue;
-        
-        loadedRules.push(item);
-    }
-    
-    return loadedRules;
-}
-
 function extendRules(rule, plugin) {
     const result = [];
     const entries = Object.entries(plugin);
@@ -122,12 +100,12 @@ function extendRules(rule, plugin) {
     return result;
 }
 
-function check(options) {
-    if (!options || typeof options !== 'object')
-        throw Error('options should be an object!');
-}
-
-function checkRule(rule) {
-    if (!isString(rule))
-        throw Error(`☝️ Looks like plugin name type is not 'string', but: '${typeof rule}'`);
+function parseRuleName(rule) {
+    if (rule.startsWith('import:')) {
+        const shortName = basename(rule.replace('import:', ''));
+        
+        return shortName.replace('plugin-', '');
+    }
+    
+    return rule;
 }

package/lib/{parse-plugin-names.js → plugins/parse-plugin-names.js}

@@ -4,7 +4,7 @@ const isStr = (a) => typeof a === 'string';
 const {isArray} = Array;
 const {entries} = Object;
 
-module.exports = (plugins) => {
+module.exports.parsePluginNames = (plugins) => {
     const result = [];
     
     for (const plugin of plugins) {

package/lib/rules/get-loaded-rules.js

@@ -0,0 +1,16 @@
+'use strict';
+
+module.exports.getLoadedRules = (rules) => {
+    const loadedRules = [];
+    
+    for (const item of rules) {
+        const {rule} = item;
+        
+        if (rule.includes('/'))
+            continue;
+        
+        loadedRules.push(item);
+    }
+    
+    return loadedRules;
+};

package/lib/rules/index.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const {parseRules} = require('./parse-rules');
+const {mergeRules} = require('./merge-rules');
+const {validateRules} = require('./validate-rules');
+const {isEnabled} = require('./is-enabled');
+const {getLoadedRules} = require('./get-loaded-rules');
+
+module.exports = {
+    parseRules,
+    mergeRules,
+    validateRules,
+    isEnabled,
+    getLoadedRules,
+};

package/lib/{is-enabled.js → rules/is-enabled.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-module.exports = (name, rules) => {
+module.exports.isEnabled = (name, rules) => {
     for (const {rule, state} of rules) {
         if (rule === name)
             return state;

package/lib/{parse-rules.js → rules/parse-rules.js}

@@ -13,7 +13,7 @@ const stateOptionError = ({rule, value}) => Error(`☝️ ${rule}: state option
 const defaultOptions = () => Object.create(null);
 const parseState = (rule, value) => validateState(rule, value) && value === 'on' || value !== 'off';
 
-module.exports = (rules) => {
+module.exports.parseRules = (rules) => {
     rules = parseSubrules(rules);
     
     const result = [];

package/lib/{validate-rules.js → rules/validate-rules.js}

@@ -9,7 +9,7 @@ const parse = (rule) => {
     return rule;
 };
 
-module.exports = ({items, rules}) => {
+module.exports.validateRules = ({items, rules}) => {
     const ruleItems = Object.keys(rules);
     
     for (const rule of ruleItems) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/engine-loader",
-  "version": "11.3.0",
+  "version": "11.5.0",
   "type": "commonjs",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "load plugins and prepare them to run",

package/lib/build-paths.js

@@ -1,20 +0,0 @@
-'use strict';
-
-const addNodeModules = (a) => `${a}/node_modules`;
-
-module.exports = (path) => {
-    const names = path
-        .split('/')
-        .slice(1);
-    
-    const result = [''];
-    
-    let current = '';
-    
-    for (const name of names) {
-        current += `/${name}`;
-        result.push(current);
-    }
-    
-    return result.map(addNodeModules);
-};