classy-yourPlugin.js

/*
 * To create a plugin you need to include the `classy-core` module and then pass
 * your plugin object into the `class.plugin.controller function`
 */
angular.module('classy-yourPlugin', ['classy-core']).classy.plugin.controller({
  name: 'yourPlugin',

  /*
   * Dependencies placed in the localInject array will be available on `@` (`this`)
   * in the plugins init and postInit methods.
   * They will not be visible/injected to the controller
   */
  localInject: ['$timeout'],

  /*
   * Configurable options are placed here.
   * Classy will check if the user has over-rided any options and make them available
   * on `@` (`this`)
   */
  options: {
    enabled: true,
    foo: 'bar',
    noOfSecondsToWait: 5
  },
  preInit: function(classConstructor, classObj, module) {

    /*
     *  * `classConstructor` is the Classy Controller constructor function, this
     *     is the function that will be initialised by ngController, it is
     *     available in the init and postInit functions using `klass.constructor`
     *  * `classObj` is the raw object that is passed into the app.classy.controller()
     *  * `module` is a reference to the app module
     */
    console.log(classConstructor.name, classObj.name, this.name);

    /* -> 'classyController', 'TodoCtrl', 'yourPlugin' */

    /*
     * `@` or (`this`) provides access to local functions, it also provides access
     *  to the compiled options object (i.e. it will include any setting overrides
     *  that the user does).
     */
    this.doSomething(this.options.foo);

    /*
     * Dependencies from the `localInject` array are not available on `@` (`this`)
     * in `preInit` but they are available in `init` and `postInit`
     */
    return console.log(this.$timeout);

    /* -> undefined */
  },
  doSomething: function(input) {
    if (input === 'bar') {
      return alert('Hello World!');
    }
  },
  init: function(klass, deps, module) {

    /*
     * This function will be called after the class has been initialised by Angular
     * but before the controller's `init` (klass.init) method is called.
     *
     *  * `klass` is the controller class and all of it's properties, you can also
     *     access the dependencies from here but it's best to use `deps` instead
     *     because if named dependencies are used then they may have an unexpected name
     *  * `deps` is an object map containing all of the controller's dependencies
     *  * `module` is a reference to the app module
     */

    /*
     * If you want to check that the controller has injected the `$scope` then do
     * something like the following:
     */
    if (!deps.$scope) {
      throw new Error("You need to inject `$scope` to use this plugin");
    }

    /*
     * Return values are ignored in init *except* when it's a promise.
     *
     * If a promise is returned then Classy will wait for it to be resolved before
     * the klass.init function is called.
     */
    return waitNoOfSeconds(this.options.noOfSecondsToWait);
  },
  waitNoOfSeconds: function(noOfSeconds) {
    var noOfMs;
    noOfMs = noOfSeconds * 1000;

    /*
     * @$timeout is available because it was defined in the `localInject` Array
     * and this function was called during the `init` phase
     */
    return this.$timeout(function() {
      return true;
    }, noOfMs);
  },
  postInit: function(klass, deps, module) {

    /*
     * This function is exectuted immediately after klass.init()
     *
     * Params are the same as @init, return value is ignored.
     */
  }
});