roc/lib/cli/extensions/helpers.js

Build modern web applications easily

'use strict';

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.runPostInits = runPostInits;
exports.getExtensions = getExtensions;

var _chalk = require('chalk');

var _chalk2 = _interopRequireDefault(_chalk);

var _resolve = require('resolve');

var _resolve2 = _interopRequireDefault(_resolve);

var _lodash = require('lodash');

var _semver = require('semver');

var _semver2 = _interopRequireDefault(_semver);

var _hooks = require('../../hooks');

var _actions = require('../../hooks/actions');

var _configuration = require('../../configuration');

var _style = require('../../helpers/style');

var _error = require('./error');

var _error2 = _interopRequireDefault(_error);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function runPostInits(initialState) {
    return initialState.postInits.reduce((state, postInit) => manageRocObject(postInit({
        config: state.config,
        meta: state.meta,
        extensions: state.usedExtensions,
        actions: state.actions,
        hooks: state.hooks
    }), state), initialState);
}

function getExtensions(type) {
    return (extensions, directory) => initialState => {
        return extensions.reduce((state, extensionPath) => {
            // Get the extension
            const roc = getExtension(extensionPath, directory, type);

            if (roc) {
                try {
                    const nextState = getCompleteExtensionTree(roc, extensionPath, state);

                    nextState.projectExtensions.push({
                        name: roc.name,
                        version: roc.version
                    });

                    return nextState;
                } catch (err) {
                    console.log((0, _style.feedbackMessage)((0, _style.warningLabel)('Warning', 'Roc Extension Failed'), `Failed to load Roc ${ type } ${ _chalk2.default.bold(extensionPath) }\n\n` + (state.verbose ? err.stack : err.toString()), err.getPath && err.getPath()));
                }
                // Rest Actions & Hooks
                (0, _actions.setActions)(state.actions);
                (0, _hooks.setHooks)(state.hooks);
            }
            // Use the previous state
            return state;
        }, initialState);
    };
}

function getParents(type) {
    return (roc, state) => {
        let nextState = _extends({}, state);
        for (const parent of roc[type] || []) {
            nextState = getCompleteExtensionTree(require(parent).roc, parent, _extends({}, nextState));
        }

        return nextState;
    };
}

function init(roc, state) {
    if (roc.init) {
        const result = roc.init({
            config: state.config,
            meta: state.meta,
            extensions: state.usedExtensions,
            actions: state.actions,
            hooks: state.hooks
        });

        if (!result || (0, _lodash.isString)(result)) {
            if ((0, _lodash.isString)(result)) {
                throw new _error2.default('There was a problem when running init. ' + result, roc.name, roc.version);
            } else {
                throw new _error2.default('There was a problem when running init.', roc.name, roc.version);
            }
        }

        return manageRocObject(result, state);
    }

    return manageRocObject(roc, state);
}

function checkDependencies(roc, state) {
    if (roc.dependencies && state.checkDependencies) {
        for (const dependency of Object.keys(roc.dependencies)) {
            const required = state.usedExtensions.find(used => used.name === dependency);
            if (!required) {
                throw new _error2.default('Could not find required dependency.' + `Needs ${ dependency }@${ roc.dependencies[dependency] }`, roc.name, roc.version);
            }

            if (required.version && !_semver2.default.satisfies(required.version, roc.dependencies[dependency])) {
                throw new _error2.default('Current dependency version does not satisfy required version.\n' + `Needs ${ dependency }@${ roc.dependencies[dependency] }`, roc.name, roc.version);
            }
        }
    }

    return state;
}

function addPostInit(roc, state) {
    if (roc.postInit) {
        state.postInits.push(roc.postInit);
    }

    return state;
}

function registerExtension(roc, state) {
    const fromBefore = state.usedExtensions.find(extension => extension.name === roc.name);
    if (fromBefore) {
        if (fromBefore.version !== roc.version) {
            console.log((0, _style.feedbackMessage)((0, _style.warningLabel)('Warning', 'Multiple versions'), `Multiple versions for ${ roc.name } was detected. (${ roc.version } & ${ fromBefore.version })\n` + `This might be an error.`));
        }
    } else {
        state.usedExtensions.push({ name: roc.name, version: roc.version });
    }

    return state;
}

function getCompleteExtensionTree(roc, path, initialState) {
    return [validRocExtension(path), getParents('packages'), getParents('plugins'), checkDependencies, init, addPostInit, registerExtension].reduce((state, process) => process(roc, state), initialState);
}

function manageRocObject(roc, state) {
    if (roc) {
        // Get possible hooks
        if (roc.hooks) {
            (0, _hooks.registerHooks)(roc.hooks, roc.name);
            state.hooks = (0, _hooks.getHooks)();
        }

        // Get potential actions
        if (roc.actions) {
            (0, _actions.registerActions)(roc.actions, roc.name);
            state.actions = (0, _actions.getActions)();
        }

        // Build the config object
        if (roc.buildConfig) {
            var _roc$buildConfig = roc.buildConfig(state.config, state.meta);

            const config = _roc$buildConfig.config;
            const meta = _roc$buildConfig.meta;

            state.config = config;
            state.meta = meta;
        } else {
            // If not buildConfig use config
            if (roc.config) {
                state.config = (0, _configuration.merge)(state.config, roc.config);
            }

            // If not buildConfig use meta
            if (roc.meta) {
                state.meta = (0, _configuration.merge)(state.meta, roc.meta);
            }
        }
    }

    return state;
}

function getExtension(extensionName, directory, type) {
    try {
        return require(_resolve2.default.sync(extensionName, { basedir: directory })).roc;
    } catch (err) {
        if (!/^Cannot find module/.test(err.message)) {
            throw err;
        }

        console.log((0, _style.feedbackMessage)((0, _style.warningLabel)('Warning', 'Roc Extension Loading Failed'), `Failed to load Roc ${ type } named ${ _chalk2.default.bold(extensionName) }.
Make sure you have it installed. Try running: ${ _chalk2.default.underline('npm install --save ' + extensionName) }`));
    }
}

function validRocExtension(path) {
    return (roc, state) => {
        if (!roc.name) {
            throw new _error2.default(`Will ignore extension. Expected it to have a ${ _chalk2.default.underline('name') }.`, roc.name, roc.version, path);
        }

        if (!roc.packages && !roc.plugins && !roc.hooks && !roc.actions && !roc.buildConfig && !roc.config && !roc.meta && !roc.init && !roc.postInit) {
            throw new _error2.default(`Will ignore extension. Expected it to have at least one of the following:\n` + ['- config', '- meta', '- buildConfig', '- actions', '- hooks', '- packages', '- plugins', '- init', '- postInit'].join('\n'), roc.name, roc.version, path);
        }

        return state;
    };
}
//# sourceMappingURL=helpers.js.map