feature(@putout/engine-loader) loadProcessors -> loadProcessorsAsync

Author: coderaiser

packages/engine-loader/README.md

@@ -61,19 +61,31 @@ const plugins = loadPlugins({
 });
 ```
 
-### loadProcessors
+### loadProcessorsAsync
 
 ```js
 const {loadProcessors} = require('@putout/engine-loader');
 
-const plugins = loadProcessors({
+const plugins = await loadProcessorsAsync({
     processors: [
         ['javascript', 'on'],
         ['markdown', 'off'],
     ],
 });
 ```
 
+### createAsyncLoader
+
+Gives ability to create loader for `processor` or `formatter`.
+
+```js
+const {createAsyncLoader} = require('@putout/engine-loader');
+const {loadProcessor} = createAsyncLoader('processor');
+
+await loadProcessors('markdown');
+// loads @putout/processor-markdown
+```
+
 ## License
 
 MIT

packages/engine-loader/lib/async-loader.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const tryToCatch = require('try-to-catch');
+const {simpleImportDefault} = require('./simple-import');
+
+const {assign} = Object;
+const stub = () => () => {};
+
+module.exports.createAsyncLoader = (type) => async (name) => {
+    if (name === 'none')
+        return stub();
+    
+    const [e, reporter] = await cleverLoad([
+        `@putout/${type}-${name}`,
+        `putout-${type}-${name}`,
+    ]);
+    
+    if (e)
+        throw e;
+    
+    return reporter;
+};
+
+async function cleverLoad(names) {
+    let e;
+    let reporter;
+    
+    for (const name of names) {
+        [e, reporter] = await tryToCatch(simpleImportDefault, name);
+        
+        if (!e)
+            return [null, reporter];
+        
+        if (e.code === 'ERR_MODULE_NOT_FOUND')
+            continue;
+        
+        assign(e, {
+            message: `${name}: ${e.message}`,
+        });
+        
+        return [e];
+    }
+    
+    assign(e, {
+        message: e.message.replace(/\simported.*/, ''),
+    });
+    
+    return [e];
+}

packages/engine-loader/lib/async-loader.spec.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const tryToCatch = require('try-to-catch');
+
+const test = require('supertape');
+const stub = require('@cloudcmd/stub');
+const mockRequire = require('mock-require');
+
+const {reRequire, stopAll} = mockRequire;
+const {assign} = Object;
+
+test('putout: loader: async-loader: none', async (t) => {
+    const {createAsyncLoader} = reRequire('./async-loader');
+    const loadAsync = createAsyncLoader('formatter');
+    
+    const result = await loadAsync('none');
+    
+    t.equal(typeof result, 'function');
+    t.end();
+});
+
+test('putout: loader: async-loader: calls', async (t) => {
+    const simpleImportDefault = stub()
+        .rejects(assign(Error('not found'), {
+            code: 'ERR_MODULE_NOT_FOUND',
+        }));
+    
+    mockRequire('./simple-import', {
+        simpleImportDefault,
+    });
+    
+    const {createAsyncLoader} = reRequire('./async-loader');
+    const loadAsync = createAsyncLoader('formatter');
+    
+    await tryToCatch(loadAsync, 'xxx');
+    const expected = [
+        ['@putout/formatter-xxx'],
+        ['putout-formatter-xxx'],
+    ];
+    
+    stopAll();
+    reRequire('./async-loader');
+    
+    t.deepEqual(simpleImportDefault.args, expected);
+    t.end();
+});
+
+test('putout: loader: async-loader: rejects', async (t) => {
+    const simpleImportDefault = stub()
+        .rejects(assign(Error('not found'), {
+            code: 'Syntax Error',
+        }));
+    
+    mockRequire('./simple-import', {
+        simpleImportDefault,
+    });
+    
+    const {createAsyncLoader} = reRequire('./async-loader');
+    const loadAsync = createAsyncLoader('formatter');
+    
+    const [error] = await tryToCatch(loadAsync, 'xxx');
+    const expected = Error('@putout/formatter-xxx: not found');
+    
+    stopAll();
+    reRequire('./async-loader');
+    
+    t.deepEqual(error, expected);
+    t.end();
+});

packages/engine-loader/lib/index.js

@@ -3,10 +3,8 @@
 const memo = require('nano-memoize');
 
 const isEnabled = require('./is-enabled');
-const {
-    loadPlugin,
-    loadProcessor,
-} = require('./load');
+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');
@@ -40,30 +38,32 @@ const mergeRules = ([rule, plugin], rules) => {
     };
 };
 
-module.exports.loadProcessors = memo((options) => {
+module.exports.loadProcessorsAsync = memo(async (options) => {
     check(options);
 
     const {
         processors = [],
     } = options;
 
     const parsedProcessors = parseProcessorNames(processors);
+    const loadProcessor = createAsyncLoader('processor');
 
     const list = [];
-    const namespace = 'putout';
 
     for (const [name, fn] of parsedProcessors) {
         if (fn) {
             list.push(fn);
             continue;
         }
 
-        list.push(loadProcessor({name, namespace}));
+        list.push(loadProcessor(name));
     }
 
-    return list;
+    return await Promise.all(list);
 });
 
+module.exports.createAsyncLoader = createAsyncLoader;
+
 module.exports.loadPlugins = (options) => {
     check(options);
 

packages/engine-loader/lib/load.spec.js

@@ -1,9 +1,7 @@
 'use strict';
 
 const tryCatch = require('try-catch');
-
 const mockRequire = require('mock-require');
-
 const {test, stub} = require('supertape');
 
 const {

packages/engine-loader/lib/simple-import.js

@@ -0,0 +1,5 @@
+'use strict';
+
+// How in other way to mock import using mock require in CommonJS?
+module.exports.simpleImportDefault = async (url) => (await import(url)).default;
+

packages/engine-loader/package.json

@@ -29,7 +29,8 @@
     "diff-match-patch": "^1.0.4",
     "nano-memoize": "^1.1.8",
     "once": "^1.4.0",
-    "try-catch": "^3.0.0"
+    "try-catch": "^3.0.0",
+    "try-to-catch": "^3.0.1"
   },
   "keywords": [
     "putout",
@@ -39,6 +40,7 @@
   "devDependencies": {
     "@babel/plugin-codemod-object-assign-to-object-spread": "^7.7.4",
     "@cloudcmd/stub": "^3.0.0",
+    "@putout/formatter-progress": "*",
     "@putout/plugin-convert-commonjs-to-esm": "*",
     "@putout/plugin-remove-unused-variables": "*",
     "@putout/processor-javascript": "*",

…es/engine-loader/test/load-processors.js …ine-loader/test/load-processors-async.jspackages/engine-loader/test/load-processors.js renamed to packages/engine-loader/test/load-processors-async.js packages/engine-loader/test/load-processors.js renamed to packages/engine-loader/test/load-processors-async.js

@@ -3,12 +3,12 @@
 const test = require('supertape');
 
 const markdown = require('@putout/processor-markdown');
-const {loadProcessors} = require('..');
+const {loadProcessorsAsync} = require('..');
 
-test('putout: engine-loader: load processors', (t) => {
+test('putout: engine-loader: load processors', async (t) => {
     const processorJavascript = require('@putout/processor-javascript');
 
-    const list = loadProcessors({
+    const list = await loadProcessorsAsync({
         processors: [
             'javascript',
         ],
@@ -22,21 +22,21 @@ test('putout: engine-loader: load processors', (t) => {
     t.end();
 });
 
-test('putout: engine-loader: load processors: no processors', (t) => {
-    const list = loadProcessors({});
+test('putout: engine-loader: load processors: no processors', async (t) => {
+    const list = await loadProcessorsAsync({});
 
     t.deepEqual(list, []);
     t.end();
 });
 
-test('putout: engine-loader: load processors: function', (t) => {
+test('putout: engine-loader: load processors: function', async (t) => {
     const throwProcessor = {
         preProcess() {
             throw'Preprocess error';
         },
     };
 
-    const list = loadProcessors({
+    const list = await loadProcessorsAsync({
         processors: [
             ['throwProcessor', throwProcessor],
         ],
@@ -50,8 +50,8 @@ test('putout: engine-loader: load processors: function', (t) => {
     t.end();
 });
 
-test('putout: engine-loader: load processors: off', (t) => {
-    const list = loadProcessors({
+test('putout: engine-loader: load processors: off', async (t) => {
+    const list = await loadProcessorsAsync({
         processors: [
             ['markdown', 'off'],
         ],
@@ -64,8 +64,8 @@ test('putout: engine-loader: load processors: off', (t) => {
     t.end();
 });
 
-test('putout: engine-loader: load processors: on', (t) => {
-    const list = loadProcessors({
+test('putout: engine-loader: load processors: on', async (t) => {
+    const list = await loadProcessorsAsync({
         processors: [
             ['markdown', 'on'],
         ],