@oroinc/oro-webpack-config-builder 5.1.0-alpha8 → 5.1.0-lts001

package/README.md

@@ -2,4 +2,4 @@
 
 An integration of OroPlatform based applications with the Webpack.
 
-For more details see [the documentation](https://doc.oroinc.com/backend/bundles/platform/AssetBundle/).
+For more details see [the documentation](https://doc.oroinc.com/bundles/platform/AssetBundle/).

package/error-handler.js

@@ -0,0 +1,95 @@
+const BaseError = require('./validation/errors/base-error');
+const {isVerboseMode} = require('./utils');
+const {red, yellow, green, bgRed} = require('colorette');
+
+const emptyLine = length => new Array(length).fill(' ').join('');
+const multiline = (color, msg) => {
+    msg = ` ${msg}`;
+    msg = msg + emptyLine(120 - msg.length);
+
+    return `\n${color(emptyLine(msg.length))}\n${color(msg)}\n${color(emptyLine(msg.length))}`;
+};
+
+class ErrorHandler {
+    constructor() {
+        this.failedThemes = [];
+
+        process.on('beforeExit', code => {
+            this.onProcess();
+        });
+    }
+
+    /**
+     * Show a message about failed themes
+     */
+    onProcess() {
+        if (this.failedThemes.length) {
+            let msg = '[ERROR] Assets build';
+
+            if (this.failedThemes.length === 1) {
+                msg = `${msg} for "${this.failedThemes[0]}" theme failed.`;
+            } else {
+                msg = `${msg} for "${this.failedThemes.join(', ')}" themes failed.`;
+            }
+            console.error(multiline(bgRed, msg));
+            process.exit(1);
+        }
+    }
+
+    /**
+     * Executes when the Webpack Compiler will complete a compilation
+     * In case of empty Webpack Config this method will not run
+     *
+     * @param {Object} stats
+     */
+    onBuildComplete(stats) {
+        const failed = stats?.compilation?.errors.length !== 0;
+
+        if (failed) {
+            console.error(multiline(bgRed, '[ERROR] Assets build failed.'));
+            process.exit(1);
+        }
+    }
+
+    /**
+     * @param {Array|string} errors
+     * @param {string} [failedTheme]
+     */
+    displayError(errors, failedTheme) {
+        if (typeof failedTheme === 'string') {
+            this.failedThemes.push(failedTheme);
+        }
+
+        if (typeof errors === 'string') {
+            errors = [errors];
+        }
+
+        const errorMessage = errors.map(err => {
+            const highlightPrefix = str => {
+                const prefix = str.substring(0, str.search(':'));
+                return red(prefix) + str.substring(str.search(':'));
+            };
+
+            if (err instanceof BaseError) {
+                err.message = `${err.message}\n${green(err.extra)}`;
+            }
+
+            let msg = err.message;
+
+            if (isVerboseMode()) {
+                msg = highlightPrefix(err.stack);
+            } else {
+                const command = yellow('php bin/console oro:assets:build --env=dev --verbose');
+                const info = `${green(`Run the command ${command} to see more information`)}`;
+
+                msg = highlightPrefix(`${err.name}: ${msg}\n${info}`);
+            }
+
+            return `${msg}\n`;
+        });
+
+        console.error(errorMessage.join('\n'));
+    }
+}
+
+module.exports = ErrorHandler;

package/loader/config-loader.js

@@ -1,9 +1,8 @@
 const path = require('path');
-const _loaderUtils = require('loader-utils');
 
 module.exports = function(source) {
     this.cacheable && this.cacheable();
-    const {resolver, relativeTo = ''} = _loaderUtils.getOptions(this) || {};
+    const {resolver, relativeTo = ''} = this.getOptions() || {};
 
     if (typeof resolver !== 'function') {
         return source;

package/loader/inject-loader/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Justin Morris
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/loader/inject-loader/README.md

@@ -0,0 +1,54 @@
+<div align="center">
+  <h3>💉📦<br><br><code>inject-loader</code></h3>
+  <h4>A Webpack loader for injecting code into modules via their dependencies</h4>
+  <a href="https://travis-ci.org/plasticine/inject-loader"><img src="https://img.shields.io/travis/plasticine/inject-loader/master.svg?style=flat-square" alt="build status" /></a> <a href="https://www.npmjs.com/package/inject-loader"><img src="https://img.shields.io/npm/v/inject-loader.svg?style=flat-square" alt="npm version" /></a> <a href="https://www.npmjs.com/package/inject-loader"><img src="https://img.shields.io/npm/dm/inject-loader.svg?style=flat-square" alt="npm downloads" /></a>
+</div>
+
+***
+
+### Why
+
+This is particularly useful for writing tests where mocking things inside your module-under-test is sometimes necessary before execution.
+
+`inject-loader` was inspired by, and builds upon ideas introduced in [jauco/webpack-injectable](https://github.com/jauco/webpack-injectable).
+
+### Usage
+
+[Documentation: Using loaders](http://webpack.github.io/docs/using-loaders.html)
+
+Use the inject loader by adding the `inject-loader!` [inline loader](https://webpack.js.org/concepts/loaders/#inline) when you use `require`, this will return a function that can used in test code to modify the injected module.
+
+By default all `require` statements in an injected module will be altered to be replaced with an injector, though if a replacement it not specified the default values will be used.
+
+### Examples
+
+Given some code in a module like this:
+
+```javascript
+// MyStore.js
+
+var Dispatcher = require('lib/dispatcher');
+var EventEmitter = require('events').EventEmitter;
+var handleAction = require('lib/handle_action');
+
+Dispatcher.register(handleAction, 'MyStore');
+```
+
+You can manipulate it’s dependencies when you come to write tests as follows:
+
+```javascript
+// If no flags are provided when using the loader then
+// all require statements will be wrapped in an injector
+MyModuleInjector = require('inject-loader!MyStore')
+MyModule = MyModuleInjector({
+  'lib/dispatcher': DispatcherMock,
+  'events': EventsMock,
+  'lib/handle_action': HandleActionMock
+})
+```
+
+There are a few examples of complete test setups for both Webpack 1, 2, 3 & 4 in the [`example`](./example) folder.
+
+## License
+
+MIT (http://www.opensource.org/licenses/mit-license.php)

package/loader/inject-loader/index.js

@@ -0,0 +1,10 @@
+const injectify = require('./injectify.js');
+
+module.exports = function injectifyLoader(source, inputSourceMap) {
+    if (this.cacheable) {
+        this.cacheable();
+    }
+
+    const {code, map} = injectify(this, source, inputSourceMap);
+    this.callback(null, code, map);
+}

package/loader/inject-loader/injectify.js

@@ -0,0 +1,66 @@
+const {transform, traverse, types: t, transformFromAst} = require('@babel/core');
+const wrapperTemplate = require('./wrapper_template.js');
+
+function processRequireCall(path) {
+    const dependencyString = path.node.arguments[0].value;
+    path.replaceWith(
+        t.expressionStatement(
+            t.conditionalExpression(
+                t.callExpression(
+                    t.memberExpression(t.identifier('__injections'), t.identifier('hasOwnProperty'), false),
+                    [t.stringLiteral(dependencyString)]
+                ),
+                t.memberExpression(t.identifier('__injections'), t.stringLiteral(dependencyString), true),
+                path.node
+            )
+        )
+    );
+
+    return dependencyString;
+}
+
+module.exports = function injectify(context, source, inputSourceMap) {
+    const {ast} = transform(source, {
+        babelrc: false,
+        code: false,
+        compact: false,
+        ast: true,
+        filename: context.resourcePath,
+    });
+
+    const dependencies = [];
+    traverse(ast, {
+        CallExpression(path) {
+            if (t.isIdentifier(path.node.callee, {name: 'require'})) {
+                dependencies.push(processRequireCall(path));
+                path.skip();
+            }
+        },
+    });
+
+    if (dependencies.length === 0) {
+        context.emitWarning(
+            "The module you are trying to inject into doesn't have any dependencies. " +
+            'Are you sure you want to do this?'
+        );
+    }
+
+    const wrapperModuleAst = t.file(
+        t.program([
+            wrapperTemplate({
+                SOURCE: t.blockStatement(ast.program.body),
+                SOURCE_PATH: t.stringLiteral(context.resourcePath),
+                DEPENDENCIES: t.arrayExpression(dependencies.map(d => t.stringLiteral(d))),
+            }),
+        ])
+    );
+
+    return transformFromAst(wrapperModuleAst, source, {
+        sourceMaps: context.sourceMap,
+        sourceFileName: context.resourcePath,
+        inputSourceMap,
+        babelrc: false,
+        compact: false,
+        filename: context.resourcePath,
+    });
+}

package/loader/inject-loader/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "inject-loader",
+  "version": "4.0.1",
+  "description": "A Webpack loader for injecting code into modules via their dependencies",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "webpack --config config/webpack.config.js",
+    "build:test": "webpack --config config/webpack.test.config.js",
+    "build:release": "yarn run build && mkdir -p ./dist && cp -f ./tmp/index.js ./dist/index.js && cp -f ./tmp/index.js.map ./dist/index.js.map",
+    "pretest:unit": "yarn build && yarn build:test",
+    "test:unit": "mocha tmp/testBundle.js --require source-map-support/register",
+    "test:integration": "./script/integration_test",
+    "test": "flow && yarn test:unit && yarn test:integration",
+    "precommit": "pretty-quick --staged"
+  },
+  "files": [
+    "*.md",
+    "dist"
+  ],
+  "author": "Justin Morris <desk@pixelbloom.com> (http://pixelbloom.com)",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:plasticine/inject-loader.git"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "babel-core": "~6"
+  },
+  "devDependencies": {
+    "babel-loader": "^7.1.4",
+    "babel-plugin-add-module-exports": "^0.2.1",
+    "babel-plugin-transform-flow-strip-types": "^6.22.0",
+    "babel-preset-es2015": "^6.22.0",
+    "flow-bin": "^0.69.0",
+    "husky": "^0.14.3",
+    "mocha": "^5.0.5",
+    "prettier": "^1.11.1",
+    "pretty-quick": "^1.4.1",
+    "source-map-support": "^0.5.4",
+    "webpack": "^4.35.0",
+    "webpack-cli": "^3.3.5"
+  },
+  "peerDependencies": {
+    "webpack": "^1 || ^2 || ^3 || ^4"
+  },
+  "keywords": [
+    "webpack",
+    "testing",
+    "loader",
+    "webpack-loader",
+    "inject",
+    "mock",
+    "mocking"
+  ]
+}

package/loader/inject-loader/wrapper_template.js

@@ -0,0 +1,32 @@
+const {template} = require('@babel/core');
+
+module.exports = template(`
+    module.exports = function __injector(__injections) {
+        __injections = __injections || {};
+        (function __validateInjection() {
+            var validDependencies = DEPENDENCIES;
+            var injectedDependencies = Object.keys(__injections);
+            var invalidInjectedDependencies = injectedDependencies.filter(function (dependency) {
+                return validDependencies.indexOf(dependency) === -1;
+            });
+            if (invalidInjectedDependencies.length > 0) {
+                var validDependenciesString = ' - ' + validDependencies.join('\\n - ');
+                var injectedDependenciesString = ' - ' + injectedDependencies.join('\\n - ');
+                var invalidDependenciesString = ' - ' + invalidInjectedDependencies.join('\\n - ');
+                throw new Error('Injection Error in ' + SOURCE_PATH + '\\n\\n' +
+                    'The following injections are invalid:\\n' + invalidDependenciesString + '\\n\\n' +
+                    'The following injections were passed in:\\n' + injectedDependenciesString + '\\n\\n' +
+                    'Valid injection targets for this module are:\\n' + validDependenciesString + '\\n'
+                );
+            }
+        })();
+        __injector.sourcePath = SOURCE_PATH;
+        __injector.validDependencies = DEPENDENCIES;
+        var module = { exports: {} };
+        var exports = module.exports;
+        (function () {
+            SOURCE
+        })();
+        return module.exports;
+    }
+`);

package/modules-config/layout-modules-config-loader.js

@@ -4,19 +4,83 @@ const ModulesConfigLoader = require('./modules-config-loader');
 
 class LayoutModulesConfigLoader extends ModulesConfigLoader {
     /**
-     * {@inheritdoc}
+     * @inheritdoc
      */
     loadConfig(theme, filePath) {
         let themeConfig = super.loadConfig(theme, path.join('Resources/views/layouts/', theme, filePath));
+        themeConfig = merge(themeConfig, super.loadConfig(theme, path.join('templates/layouts/', theme, filePath)));
         // recursive process parent theme
         const {parent: parentTheme} = this.themes[theme];
         if (typeof parentTheme === 'string') {
+            const processedFiles = this.processedFiles;
             const parentThemeConfig = this.loadConfig(parentTheme, filePath);
+
             themeConfig = merge(parentThemeConfig, themeConfig);
+            // processedFiles from parent theme is added to processedFiles of current theme
+            this._processedFiles = [...processedFiles, ...this.processedFiles];
         }
-
         return themeConfig;
     }
+
+    /**
+     * All build names:
+     *  - based on theme names
+     *  - and theme's extra js builds
+     *
+     * @return {string[]}
+     */
+    get buildNames() {
+        const buildNames = super.buildNames;
+        this.themeNames.forEach(theme => {
+            buildNames.push(...this.extraJSBuildNames(theme));
+        });
+        return buildNames;
+    }
+
+    /**
+     * Collect extra js-build names for a theme
+     *
+     * @param {string} theme name on the theme
+     * @return {string[]}
+     */
+    extraJSBuildNames(theme) {
+        const {extra_js_builds: extraJSBuilds = []} = this._themes[theme] || {};
+        return [...extraJSBuilds.map(suffix => `${theme}-${suffix}`)];
+    }
+
+    /**
+     * Check if buildName is an extra js build of layout theme
+     *
+     * @param {string} buildName name of the build
+     * @return {boolean}
+     */
+    isExtraJSBuild(buildName) {
+        const [, suffix] = this.splitBuildName(buildName);
+        return suffix !== void 0;
+    }
+
+    /**
+     * Splits build name on parts theme name and suffix (name of extra js build)
+     * @param {string} buildName
+     * @return {[string]|[string, string]}
+     */
+    splitBuildName(buildName) {
+        // suffix can not contain '-'
+        const marches = buildName.match(/(.+)-([^\-]+)?/);
+        const result = [];
+        if (marches) {
+            const [, theme, suffix] = marches;
+            const {extra_js_builds: extraJSBuilds = []} = this._themes[theme] || {};
+            if (extraJSBuilds.includes(suffix)) {
+                result.push(marches[1], marches[2]);
+            } else {
+                result.push(buildName);
+            }
+        } else {
+            result.push(buildName);
+        }
+        return result;
+    }
 }
 
 module.exports = LayoutModulesConfigLoader;

package/modules-config/modules-config-loader.js

@@ -2,6 +2,10 @@ const path = require('path');
 const fs = require('fs');
 const merge = require('deepmerge');
 const yaml = require('js-yaml');
+const validation = require('../validation');
+
+// merge only unique items
+const arrayMerge = (target, source) => target.concat(source.filter(item => !target.includes(item)));
 
 class ModulesConfigLoader {
     /**
@@ -18,60 +22,83 @@ class ModulesConfigLoader {
         return Object.keys(this._themes);
     }
 
+    /**
+     * @returns {Array}
+     */
+    get buildNames() {
+        return this.themeNames;
+    }
+
+    /**
+     * @returns {Array}
+     */
+    get processedFiles() {
+        return [...this._processedFiles];
+    }
+
     /**
      * @param {Array} bundles Array of ordered symfony bundle paths
-     * @param {string} themesLocation Path inside the bundle, where to find the theme
-     * @param {string} themeInfoFileName Yml File name with theme info
+     * @param {string|Array} themesLocation Path inside the bundle, where to find the theme
+     * @param {string} themeInfoFileName Yaml File name with theme info
      */
     constructor(bundles, themesLocation, themeInfoFileName) {
         this._bundles = bundles;
-        this._themes = this._getThemes(themesLocation, themeInfoFileName);
+        if (!Array.isArray(themesLocation)) {
+            themesLocation = [themesLocation];
+        }
+
+        const themes = {};
+        const self = this;
+        themesLocation.forEach(themesLocation => {
+            self._collectThemes(themes, themesLocation, themeInfoFileName);
+        });
+
+        this._themes = themes;
+        this._processedFiles = [];
     }
 
     /**
-     * Return list of themes with their parents
+     * Collects list of themes with their parents into given storage(themes param)
+     *
+     * @param {Object} themes
      * @param {string} themesLocation
      * @param {string} themeInfoFileName
-     * @returns {Object.<string|null>}
      * @private
      */
-    _getThemes(themesLocation, themeInfoFileName) {
-        const themes = {};
+    _collectThemes(themes, themesLocation, themeInfoFileName) {
         this._bundles.forEach(bundle => {
             const source = bundle + themesLocation;
 
             if (!fs.existsSync(source)) return;
 
             fs.readdirSync(source).forEach(name => {
-                const theme = path.resolve(source, name);
-                if (!fs.lstatSync(theme).isDirectory()) {
+                const themePath = path.resolve(source, name);
+                if (!fs.lstatSync(themePath).isDirectory()) {
                     return;
                 }
-                const themeFile = path.resolve(theme, themeInfoFileName);
+                const themeFile = path.resolve(themePath, themeInfoFileName);
                 if (!fs.existsSync(themeFile)) return;
 
-                if (!(name in themes)) {
-                    themes[name] = null;
-                }
-                themes[name] = yaml.load(fs.readFileSync(themeFile, 'utf8'));
+                const theme = yaml.load(fs.readFileSync(themeFile, 'utf8'));
+                themes[name] = merge(themes[name] || {}, theme, {arrayMerge});
             });
         });
-
-        return themes;
     }
 
     /**
      * @param {string} theme Theme name
      * @param {string|string[]} filePath Path (or paths with fallback) to the file inside bundle directory where to find the configs
-     * @return {Object} Merged Configs loaded from all the bundles Yml files matched by filePath
+     * @return {Object} Merged Configs loaded from all the bundles Yaml files matched by filePath
      */
     loadConfig(theme, filePath) {
         let configs = {};
         const filePaths = [].concat(filePath);
+
+        this._processedFiles = [];
         this._bundles.forEach(bundle => {
             let absolutePath;
 
-            for (let file of filePaths) {
+            for (const file of filePaths) {
                 absolutePath = path.resolve(bundle, file);
                 if (fs.existsSync(absolutePath)) {
                     break;
@@ -80,10 +107,16 @@ class ModulesConfigLoader {
             }
 
             if (absolutePath) {
-                const doc = yaml.load(fs.readFileSync(absolutePath, 'utf8'));
+                const rawDoc = fs.readFileSync(absolutePath, 'utf8');
+                const doc = yaml.load(rawDoc);
+
+                this._processedFiles.push(absolutePath);
+
+                validation.checkSchema(absolutePath, doc, theme);
                 configs = merge(configs, doc);
             }
         });
+
         return configs;
     }
 }