class-o-mat/lib/plugins/plugin-methods.js

ALPHA VERSION ONLY: class-o-mats will help to create getter-setter functionality with validations that can be attached to a container class for easier coding. Some basic validations are included. class-o-mats also has the ability to store params as bloc

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.appendMethod = exports.prependMethod = exports.appendConstructor = exports.prependConstructor = undefined;

var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

var _bunyan = require('bunyan');

var _bunyan2 = _interopRequireDefault(_bunyan);

var _types = require('../constants/types');

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

var log = _bunyan2.default.createLogger({ name: "PluginMethods" });

var prependConstructor = exports.prependConstructor = function prependConstructor(self, key, newConstructor) {
  var plugin = self.___parent();
  var prepender = function prepender(_ref, buildMethods) {
    var classOMat = _ref.classOMat,
        mixins = _ref.mixins,
        defaults = _ref.defaults,
        params = _ref.params;

    var oldConstructor = mixins.constructor;
    var thisConstructor = function thisConstructor() {
      for (var _len = arguments.length, p = Array(_len), _key = 0; _key < _len; _key++) {
        p[_key] = arguments[_key];
      }

      newConstructor.call.apply(newConstructor, [this].concat(p));
      oldConstructor.call.apply(oldConstructor, [this].concat(p));
    };

    mixins.constructor = thisConstructor;
    return [{ classOMat: classOMat, mixins: mixins, defaults: defaults, params: params }, buildMethods];
  };
  plugin.append().buildConstructor(prepender);
};

var appendConstructor = exports.appendConstructor = function appendConstructor(self, key, newConstructor) {
  var plugin = self.___parent();
  var appender = function appender(_ref2, buildMethods) {
    var classOMat = _ref2.classOMat,
        mixins = _ref2.mixins,
        defaults = _ref2.defaults,
        params = _ref2.params;

    var oldConstructor = mixins.constructor;
    var thisConstructor = function thisConstructor() {
      for (var _len2 = arguments.length, p = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
        p[_key2] = arguments[_key2];
      }

      oldConstructor.call.apply(oldConstructor, [this].concat(p));
      newConstructor.call.apply(newConstructor, [this].concat(p));
    };

    mixins.constructor = thisConstructor;
    return [{ classOMat: classOMat, mixins: mixins, defaults: defaults, params: params }, buildMethods];
  };
  plugin.append().buildConstructor(appender);
};

var prependMethod = exports.prependMethod = function prependMethod(self, key, newFunktion) {
  var parent = self.___parent();
  var buildMethods = parent.buildMethods();
  var funktion = buildMethods[key];
  buildMethods[key] = function (_ref3, buildMethods) {
    var classOMat = _ref3.classOMat,
        mixins = _ref3.mixins,
        defaults = _ref3.defaults,
        params = _ref3.params;

    var workingArguments = void 0;

    var _newFunktion = newFunktion({ classOMat: classOMat, mixins: mixins, defaults: defaults, params: params }, buildMethods);

    var _newFunktion2 = _slicedToArray(_newFunktion, 2);

    workingArguments = _newFunktion2[0];
    buildMethods = _newFunktion2[1];

    return funktion({ classOMat: classOMat, mixins: mixins, defaults: defaults, params: params }, buildMethods);
  };
  parent.buildMethods(buildMethods);
};

var appendMethod = exports.appendMethod = function appendMethod(self, key, newFunktion) {
  var parent = self.___parent();
  var buildMethods = parent.buildMethods();
  var funktion = buildMethods[key];

  buildMethods[key] = function (_ref4, buildMethods) {
    var classOMat = _ref4.classOMat,
        mixins = _ref4.mixins,
        defaults = _ref4.defaults,
        params = _ref4.params;

    var workingArguments = void 0;

    var _funktion = funktion({ classOMat: classOMat, mixins: mixins, defaults: defaults, params: params }, buildMethods);

    var _funktion2 = _slicedToArray(_funktion, 2);

    workingArguments = _funktion2[0];
    buildMethods = _funktion2[1];

    return newFunktion({ classOMat: classOMat, mixins: mixins, defaults: defaults, params: params }, buildMethods);
  };
  parent.buildMethods(buildMethods);
};
//# sourceMappingURL=plugin-methods.js.map