class-o-mat/src/plugins/plugin.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

import Bunyan from 'bunyan';
const  log = Bunyan.createLogger({name: "Plugin"});

import mixin from 'mixin-decorator';

import { 
        NONE,
        FIELD_O_MAT,
        PLUGIN,
        PLUGIN_APPENDER,
        PLUGIN_PREPENDER
         } from '../constants/types';
import FieldOMat from '../class-o-mat/field-o-mat';
import ChildOMatOMat from '../class-o-mat/child-o-mat-adder';
import RadioOMat from '../class-o-mat/radio-o-mat';

import buildClassMethods from '../methods/build-class';
import {
        appendMethod,
        prependMethod,
        appendConstructor,
        prependConstructor
        } from './plugin-methods';

import ClassOMat from '../class-o-mat/class-o-mat';

const appenderOMat = new ClassOMat('appender');
appenderOMat.field('toConstructor').validate().method().$().onSet(appendConstructor);

const prependerOMat = new ClassOMat('prepender');
prependerOMat.field('toConstructor').validate().method().$().onSet(prependConstructor);

const buildClassMethodKeys = Object.keys(buildClassMethods);

buildClassMethodKeys.forEach((key)=>{
  appenderOMat.field(key).validate().method().$().onSet(appendMethod);
  prependerOMat.field(key).validate().method().$().onSet(prependMethod);
});

const fieldOMat = new ClassOMat('fieldOMat').BaseClass(FieldOMat);
const fieldOMatInitializer =(fieldOMat, plugin, key)=>fieldOMat.init(plugin, key);

// const childOMatOMat = new ClassOMat('childOMatOMat').BaseClass(ChildOMatOMat);
// const childOMatOMatInitializer =(childOMatOMat, plugin, key)=>childOMatOMat.init(plugin, key);

const pluginOMat = new ClassOMat('plugin');
pluginOMat.cacheOMats(true);

pluginOMat.field('controller').validate().object().$()
          .field('FieldOMatMixins').default({}).validate().object().$()
          .field('key').default('plugin that needs a name').validate().string().$()
          .field('buildMethods').default(buildClassMethods).validate().object().$()
          .field('mixins').default({}).validate().object().$()
          .field('addMixins').default({}).internalKey('mixins').validate().object().$()
          .field('onGet').stack().validate().method().$()
          .again('onSet');

pluginOMat.addChild(fieldOMat)
           .initializer(fieldOMatInitializer)
           .accessChildAs('fieldOMats').as$('field')
          .addChild(appenderOMat).singleton().as$('append')
          .addChild(prependerOMat).singleton().as$('prepend')

class BasePlugin {

  static VERSION = '0.6.0';
  VERSION = '0.6.0';

  static TYPE = PLUGIN;
  TYPE = PLUGIN;

  init(key) { 
    this._params.key = key;
    return this;
  }

  connect(classOMat) { 
    const {key, buildMethods, FieldOMatMixins, mixins} = this._params;
    const onGet = this.onGet().values();
    const onSet = this.onSet().values();

    const comParams = classOMat._params;
    const {FieldOMat} = comParams;

    @mixin(FieldOMatMixins)
    class NewFieldOMat extends FieldOMat { };

    comParams.buildMethods = { ...buildMethods, ...this.buildMethods}
    comParams.mixins = {...mixins, ...comParams.mixins};
    comParams.FieldOMat = NewFieldOMat;
    classOMat.params(comParams);

    onGet.forEach((onGetFunk)=>classOMat.onGet(onGetFunk));
    onSet.forEach((onGetFunk)=>classOMat.onSet(onGetFunk));

    const fieldOMats = this.fieldOMats();
    if (Array.isArray(fieldOMats) === false) { 
      fieldOMats.init(classOMat, fieldOMats._params.key);
      classOMat._acceptFieldOMat(fieldOMats)
      return 
    }
    fieldOMats.forEach((fieldOMat)=>{ 
        classOMat._acceptFieldOMat(fieldOMat);
        fieldOMat.init(classOMat, fieldOMat._params.key);
      }
    );
  }
}
pluginOMat.BaseClass(BasePlugin);
const Plugin = pluginOMat.$();

export { Plugin as default, pluginOMat }