typhonjs-escomplex-module/dist/Plugins.js

Provides module / individual file oriented AST processing for typhonjs-escomplex complexity reports.

'use strict';

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

var _freeze = require('babel-runtime/core-js/object/freeze');

var _freeze2 = _interopRequireDefault(_freeze);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require('babel-runtime/helpers/createClass');

var _createClass3 = _interopRequireDefault(_createClass2);

var _PluginMetricsModule = require('escomplex-plugin-metrics-module/dist/PluginMetricsModule');

var _PluginMetricsModule2 = _interopRequireDefault(_PluginMetricsModule);

var _PluginSyntaxBabylon = require('escomplex-plugin-syntax-babylon/dist/PluginSyntaxBabylon');

var _PluginSyntaxBabylon2 = _interopRequireDefault(_PluginSyntaxBabylon);

var _ModuleReport = require('typhonjs-escomplex-commons/dist/module/report/ModuleReport');

var _ModuleReport2 = _interopRequireDefault(_ModuleReport);

var _PluginManager = require('typhonjs-plugin-manager/dist/PluginManager');

var _PluginManager2 = _interopRequireDefault(_PluginManager);

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

/**
 * Provides a wrapper around PluginManager for ESComplexModule. Several convenience methods for the plugin callbacks
 * properly manage and or create initial data that are processed by the plugins.
 *
 * The default plugins loaded include:
 * @see https://www.npmjs.com/package/escomplex-plugin-metrics-module
 * @see https://www.npmjs.com/package/escomplex-plugin-syntax-babylon
 */
var Plugins = function () {
  /**
   * Initializes Plugins.
   *
   * @param {object}   options - module options including user plugins to load including:
   * ```
   * (boolean)         loadDefaultPlugins - When false ESComplexModule will not load any default plugins.
   * (Array<Object>)   plugins - A list of ESComplexModule plugins that have already been instantiated.
   * ```
   */
  function Plugins() {
    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    (0, _classCallCheck3.default)(this, Plugins);

    /**
     * Provides a generic plugin manager for dispatching events to module plugins.
     * @type {PluginManager}
     * @private
     */
    this._pluginManager = new _PluginManager2.default();

    if (typeof options.loadDefaultPlugins === 'boolean' && !options.loadDefaultPlugins) {/* nop */} else {
      this._pluginManager.add({ name: 'escomplex-plugin-syntax-babylon', instance: new _PluginSyntaxBabylon2.default() });
      this._pluginManager.add({ name: 'escomplex-plugin-metrics-module', instance: new _PluginMetricsModule2.default() });
    }
  }

  /**
   * Initializes the default `settings` object hash and then invokes the `onConfigure` plugin callback for all loaded
   * plugins.
   *
   * @param {object}   options - (Optional) module processing options.
   *
   * @returns {object}
   */


  (0, _createClass3.default)(Plugins, [{
    key: 'onConfigure',
    value: function onConfigure(options) {
      var settings = {};
      var event = this._pluginManager.invokeSyncEvent('onConfigure', void 0, { options: options, settings: settings });

      settings = event !== null ? event.settings : settings;
      (0, _freeze2.default)(settings);
      return event !== null ? event.settings : settings;
    }

    /**
     * Invokes the `onEnterNode` plugin callback during AST traversal when a node is entered.
     *
     * @param {ModuleReport}         moduleReport - The ModuleReport being processed.
     * @param {ModuleScopeControl}   scopeControl - The associated module report scope control.
     * @param {Array<string>}        ignoreKeys - Any syntax assigned ignore keys for AST traversal.
     * @param {object}               syntaxes - All loaded trait syntaxes for AST nodes.
     * @param {object}               settings - Settings for module processing.
     * @param {object}               node - The node being entered.
     * @param {object}               parent - The parent node of the node being entered.
     *
     * @returns {Array<string>|null} - A directive indicating children keys to be skipped or if null all keys entirely.
     */

  }, {
    key: 'onEnterNode',
    value: function onEnterNode(moduleReport, scopeControl, ignoreKeys, syntaxes, settings, node, parent) {
      var event = this._pluginManager.invokeSyncEvent('onEnterNode', void 0, { moduleReport: moduleReport, scopeControl: scopeControl, ignoreKeys: ignoreKeys, syntaxes: syntaxes, settings: settings, node: node, parent: parent });

      return event !== null ? event.ignoreKeys : [];
    }

    /**
     * Invokes the `onExitNode` plugin callback during AST traversal when a node is exited.
     *
     * @param {ModuleReport}         moduleReport - The ModuleReport being processed.
     * @param {ModuleScopeControl}   scopeControl - The associated module report scope control.
     * @param {object}               syntaxes - All loaded trait syntaxes for AST nodes.
     * @param {object}               settings - Settings for module processing.
     * @param {object}               node - The node being entered.
     * @param {object}               parent - The parent node of the node being entered.
     */

  }, {
    key: 'onExitNode',
    value: function onExitNode(moduleReport, scopeControl, syntaxes, settings, node, parent) {
      this._pluginManager.invokeSyncEvent('onExitNode', void 0, { moduleReport: moduleReport, scopeControl: scopeControl, syntaxes: syntaxes, settings: settings, node: node, parent: parent });
    }

    /**
     * Initializes the trait `syntaxes` object hash and then invokes the `onLoadSyntax` plugin callback for all loaded
     * plugins.
     *
     * @param {object}   settings - Settings for module processing.
     *
     * @returns {object} - Loaded trait `syntaxes` for AST nodes.
     */

  }, {
    key: 'onLoadSyntax',
    value: function onLoadSyntax(settings) {
      var syntaxes = {};
      var event = this._pluginManager.invokeSyncEvent('onLoadSyntax', void 0, { settings: settings, syntaxes: syntaxes });
      return event !== null ? event.syntaxes : syntaxes;
    }

    /**
     * Initializes the default ModuleReport and then invokes the `onModuleStart` plugin callback for all loaded plugins.
     *
     * @param {object}   ast - Settings for module processing.
     * @param {object}   syntaxes - All loaded trait syntaxes for AST nodes.
     * @param {object}   settings - Settings for module processing.
     *
     * @returns {ModuleReport} - The ModuleReport being processed.
     */

  }, {
    key: 'onModuleStart',
    value: function onModuleStart(ast, syntaxes, settings) {
      var moduleReport = new _ModuleReport2.default(ast.loc.start.line, ast.loc.end.line, settings);
      this._pluginManager.invokeSyncEvent('onModuleStart', void 0, { ast: ast, moduleReport: moduleReport, syntaxes: syntaxes, settings: settings });
      return moduleReport;
    }

    /**
     * Invokes the `onModuleAverage` plugin callback for all loaded plugins such they might average any calculated
     * results.
     *
     * @param {ModuleReport}   moduleReport - The ModuleReport being processed.
     * @param {object}         syntaxes - All loaded trait syntaxes for AST nodes.
     * @param {object}         settings - Settings for module processing.
     *
     * @returns {ModuleReport} - The ModuleReport being processed.
     */

  }, {
    key: 'onModuleAverage',
    value: function onModuleAverage(moduleReport, syntaxes, settings) {
      this._pluginManager.invokeSyncEvent('onModuleAverage', void 0, { moduleReport: moduleReport, syntaxes: syntaxes, settings: settings });
      return moduleReport;
    }

    /**
     * Invokes the `onModuleCalculate` plugin callback for all loaded plugins such they might finish calculating results.
     *
     * @param {ModuleReport}   moduleReport - The ModuleReport being processed.
     * @param {object}         syntaxes - All loaded trait syntaxes for AST nodes.
     * @param {object}         settings - Settings for module processing.
     *
     * @returns {ModuleReport} - The ModuleReport being processed.
     */

  }, {
    key: 'onModuleCalculate',
    value: function onModuleCalculate(moduleReport, syntaxes, settings) {
      this._pluginManager.invokeSyncEvent('onModuleCalculate', void 0, { moduleReport: moduleReport, syntaxes: syntaxes, settings: settings });
      return moduleReport;
    }

    /**
     * Invokes the `onModuleEnd` plugin callback for all loaded plugins at the end of module processing.
     *
     * @param {ModuleReport}   moduleReport - The ModuleReport being processed.
     * @param {object}         syntaxes - All loaded trait syntaxes for AST nodes.
     * @param {object}         settings - Settings for module processing.
     *
     * @returns {ModuleReport} - The ModuleReport being processed.
     */

  }, {
    key: 'onModuleEnd',
    value: function onModuleEnd(moduleReport, syntaxes, settings) {
      this._pluginManager.invokeSyncEvent('onModuleEnd', void 0, { moduleReport: moduleReport, syntaxes: syntaxes, settings: settings });
      return moduleReport;
    }

    /**
     * Invokes the `onModulePostAverage` plugin callback for all loaded plugins such they might finish any calculations
     * that involve averaged results.
     *
     * @param {ModuleReport}   moduleReport - The ModuleReport being processed.
     * @param {object}         syntaxes - All loaded trait syntaxes for AST nodes.
     * @param {object}         settings - Settings for module processing.
     *
     * @returns {ModuleReport} - The ModuleReport being processed.
     */

  }, {
    key: 'onModulePostAverage',
    value: function onModulePostAverage(moduleReport, syntaxes, settings) {
      this._pluginManager.invokeSyncEvent('onModulePostAverage', void 0, { moduleReport: moduleReport, syntaxes: syntaxes, settings: settings });
      return moduleReport;
    }

    /**
     * Invokes the `onModulePostScopeCreated` plugin callback during AST traversal after a new module report scope is
     * created.
     *
     * @param {ModuleReport}         moduleReport - The ModuleReport being processed.
     * @param {ModuleScopeControl}   scopeControl - The associated module report scope control.
     * @param {object}               newScope - An object hash defining the new scope including:
     * ```
     * (string) type - Type of report to create.
     * (string) name - Name of the class or method.
     * (number) lineStart - Start line of method.
     * (number) lineEnd - End line of method.
     * (number) paramCount - (For method scopes) Number of parameters for method.
     * ```
     * @param {object}               settings - Settings for module processing.
     * @param {object}               node - The node being entered.
     * @param {object}               parent - The parent node of the node being entered.
     */

  }, {
    key: 'onModulePostScopeCreated',
    value: function onModulePostScopeCreated(moduleReport, scopeControl, newScope, settings, node, parent) {
      this._pluginManager.invokeSyncEvent('onModulePostScopeCreated', void 0, { moduleReport: moduleReport, scopeControl: scopeControl, newScope: newScope, settings: settings, node: node, parent: parent });
    }

    /**
     * Invokes the `onModulePostScopePopped` plugin callback during AST traversal after a module report scope is
     * popped / exited.
     *
     * @param {ModuleReport}         moduleReport - The ModuleReport being processed.
     * @param {ModuleScopeControl}   scopeControl - The associated module report scope control.
     * @param {object}               scope - An object hash defining the new scope including:
     * ```
     * (string) type - Type of report to pop.
     * ```
     * @param {object}               settings - Settings for module processing.
     * @param {object}               node - The node being entered.
     * @param {object}               parent - The parent node of the node being entered.
     */

  }, {
    key: 'onModulePostScopePopped',
    value: function onModulePostScopePopped(moduleReport, scopeControl, scope, settings, node, parent) {
      this._pluginManager.invokeSyncEvent('onModulePostScopePopped', void 0, { moduleReport: moduleReport, scopeControl: scopeControl, scope: scope, settings: settings, node: node, parent: parent });
    }

    /**
     * Invokes the `onModulePreScopeCreated` plugin callback during AST traversal before a new module report scope is
     * created.
     *
     * @param {ModuleReport}         moduleReport - The ModuleReport being processed.
     * @param {ModuleScopeControl}   scopeControl - The associated module report scope control.
     * @param {object}               newScope - An object hash defining the new scope including:
     * ```
     * (string) type - Type of report to create.
     * (string) name - Name of the class or method.
     * (number) lineStart - Start line of method.
     * (number) lineEnd - End line of method.
     * (number) paramCount - (For method scopes) Number of parameters for method.
     * ```
     * @param {object}               settings - Settings for module processing.
     * @param {object}               node - The node being entered.
     * @param {object}               parent - The parent node of the node being entered.
     */

  }, {
    key: 'onModulePreScopeCreated',
    value: function onModulePreScopeCreated(moduleReport, scopeControl, newScope, settings, node, parent) {
      this._pluginManager.invokeSyncEvent('onModulePreScopeCreated', void 0, { moduleReport: moduleReport, scopeControl: scopeControl, newScope: newScope, settings: settings, node: node, parent: parent });
    }

    /**
     * Invokes the `onModulePreScopePopped` plugin callback during AST traversal before a module report scope is
     * popped / exited.
     *
     * @param {ModuleReport}         moduleReport - The ModuleReport being processed.
     * @param {ModuleScopeControl}   scopeControl - The associated module report scope control.
     * @param {object}               scope - An object hash defining the new scope including:
     * ```
     * (string) type - Type of report to pop.
     * ```
     * @param {object}               settings - Settings for module processing.
     * @param {object}               node - The node being entered.
     * @param {object}               parent - The parent node of the node being entered.
     */

  }, {
    key: 'onModulePreScopePopped',
    value: function onModulePreScopePopped(moduleReport, scopeControl, scope, settings, node, parent) {
      this._pluginManager.invokeSyncEvent('onModulePreScopePopped', void 0, { moduleReport: moduleReport, scopeControl: scopeControl, scope: scope, settings: settings, node: node, parent: parent });
    }
  }]);
  return Plugins;
}();

exports.default = Plugins;
module.exports = exports['default'];