controller-context.common.js

/*
 * Copyright (c) 2011-2012, Yahoo! Inc.  All rights reserved.
 * Copyrights licensed under the New BSD License.
 * See the accompanying LICENSE file for terms.
 */


// << RIC + This is not used anymore

/*jslint anon:true, sloppy:true, nomen:true*/
/*global YUI*/


YUI.add('mojito-controller-context', function(Y, NAME) {

    return;

//  /**
//   * @class ControllerContext
//   * @constructor
//   * @param {Object} opts contains instance, Y, store, appShareYUIInstance,
//   *   dispatch
//   */
//  function ControllerContext(opts) {
//      this.instance = opts.instance;
//      this.dispatch = opts.dispatch;
//      this.store = opts.store;
//      this.Y = opts.Y;
//      this.shareYUIInstance = false;
//      Y.mojito.util.shouldShareYUIInstance(opts.appShareYUIInstance, this.instance);
//      this.init();
//  }


//  ControllerContext.prototype = {

//      init: function() {

//          var c = this.Y.mojito.controllers[this.instance['controller-module']],
//              controller;

//          controller = this.controller = Y.mojito.util.heir(c);

//          if (Y.Lang.isFunction(controller.init)) {
//              controller.init(this.instance.config);
//          }

//          return; // << RIC

//          /*
//          var error,
//              // Not really an instance...more like constructor options...see
//              // controller.init() call below.
//              instance = this.instance,
//              controller,
//              shareYUIInstance = this.shareYUIInstance,

//              // do a shallow merge of app-level and mojit-level configs
//              // mojit config properties take precedence
//              configApp = this.store.getAppConfig({}).config,
//              configCombo = Y.merge(configApp, instance.config),

//              // Y.mojito.controller for legacy, multi-instance.
//              // Y.mojito.controllers for shared instance
//              c = this.Y.mojito.controller ||
//                  this.Y.mojito.controllers[instance['controller-module']];

//          // If sharing YUI and controller clobbers, log an error.
//          if (shareYUIInstance && this.Y.mojito.controller) {
//              this.Y.log(instance['controller-module'] + ' mojit' +
//                  ' clobbers Y.mojito.controller namespace. Please use' +
//                  ' `Y.namespace(\'mojito.controllers\')[NAME]` when ' +
//                  ' declaring controllers.', 'error', NAME);
//          }

//          if (!Y.Lang.isObject(c)) {
//              error = new Error('Mojit controller prototype is not an' +
//                  ' object! (mojit id: \'' + instance.id + '\')');

//              error.code = 500;
//              throw error;
//          }

//          // we make a controller instance by using the heir() function, this
//          // gives us proper function scope within the controller actions
//          controller = this.controller = Y.mojito.util.heir(c);

//          if (Y.Lang.isFunction(controller.init)) {
//              // Use the instance data which isn't really an instance to
//              // provide construction parameters for the controller init().
//              controller.init(configCombo);
//          }

//          // mix in any (new) actions (the actions namespace here would be
//          // populated by the resource store...but currently unused? Could
//          // this be replaced by light inheritance to the controllers here).
//          Y.Object.each(this.Y.mojito.actions, function(action, actionName) {
//              this.Y.log('mixing action \'' + actionName +
//                  '\' into controller...', 'debug', NAME);
//              controller[actionName] = function() {
//                  action.apply(controller, arguments);
//              };
//          });

//          // stash the models this controller has available to be later
//          // attached to the ActionContext
//          this.models = {};

//          Y.Object.each(this.Y.mojito.models, function(model, modelName) {

//              if (!shareYUIInstance || (instance.models &&
//                      instance.models[modelName])) {

//                  // TODO: Why? There's no particular reason to inherit here.
//                  var modelInstance = Y.mojito.util.heir(model);

//                  if (Y.Lang.isFunction(modelInstance.init)) {
//                      // NOTE that we use the same config here that we use to
//                      // config the controller
//                      modelInstance.init(configCombo);
//                  }
//                  this.models[modelName] = modelInstance;
//              }
//          }, this);
//          */
//      },


//      invoke: function(command, adapter) {

//          var ac;

//          try {
//              ac = new this.Y.mojito.ActionContext({
//                  command: command,
//                  controller: this.controller,
//                  models: this.models,
//                  dispatch: this.dispatch,
//                  adapter: adapter,
//                  store: this.store
//              });
//          } catch (err) {
//              console.log(err);
//              this.Y.log('WARNING!! Uncaught error from dispatch on' +
//                  ' instance \'' + (command.instance.id || '@' + command.instance.type) +
//                  '\'', 'error', NAME);
//              this.Y.log(err.message, 'error', NAME);
//              this.Y.log(err.stack, 'error', NAME);
//          }

//          return; // << RIC

//          /*
//          var instance = this.instance,
//              config = command.instance.config,
//              // this is the action that will be executed
//              action = command.action,
//              ac,
//              perfID,
//              perf;

//          // replace the non-expanded command instance with the proper
//          // instance, that was already expanded when the controller context
//          // was created

//          // TODO: This may not be necessary...we did this in dispatch().
//          // command.instance = instance;

//          // however! we want to use the most recent config, not the cached
//          // config, because that can change between action executions!
//          // command.instance.config = config;

//          // if there is no action, make 'index' the default
//          // TODO: This may not be necessary...we did this in dispatch().
//          if (!command.action) {
//              // use instance config for default action or 'index'
//              command.action = instance.action || 'index';
//          }

//          perfID = Y.mojito.perf.idFromCommand(command);
//          perf = Y.mojito.perf.timeline('mojito', 'ac:ctor',
//                  'create ac (which also invokes the action)', perfID);

//          try {
//              // Note: ac var is here to appease jslint.
//              ac = new this.Y.mojito.ActionContext({
//                  command: command,
//                  controller: this.controller,
//                  models: this.models,
//                  dispatch: this.dispatch,
//                  adapter: adapter,
//                  store: this.store
//              });

//              // TODO: uncomment once above issue is repaired.
//              // ac.invoke(command, adapter);  // do it this way ;)
//          } catch (err) {
//              if (adapter.error) {
//                  adapter.error(err);
//              } else {
//                  this.Y.log('WARNING!! Uncaught error from dispatch on' +
//                      ' instance \'' + (instance.id || '@' + instance.type) +
//                      '\'', 'error', NAME);
//                  this.Y.log(err.message, 'error', NAME);
//                  this.Y.log(err.stack, 'error', NAME);
//              }
//              // TODO: should we be rethrowing the error here? We log but we
//              // don't ensure callers know...but then again dispatch() may
//              // need this level of isolation.
//          } finally {
//              perf.done();
//          }

//          this.Y.mojito.perf.mark('mojito', 'core_dispatch_end', 'invoked action', perfID);
//          */
//      }
//  };

//  Y.namespace('mojito').ControllerContext = ControllerContext;

}, '0.1.0', {requires: [
    'mojito-action-context',
    'mojito-util'
]});