cop.js

(function() {
  

  var root = this;

  var Cop;
  if (typeof exports !== 'undefined')
    Cop = exports; 
  else
    Cop = root.Cop = {};

  Cop.VERSION = '0.1.2';

  var _ = root._;
  if (!_ && (typeof require !== 'undefined')) 
    _ = require('underscore');
  

  var Backbone = root.Backbone;
  if (!Backbone && (typeof require !== 'undefined'))
    Backbone = require('backbone');

  var Trait = root.Trait;
  if (!Trait && (typeof require !== 'undefined'))
    Trait = require('traits').Trait;

  var Context = Cop.Context = function(options) {
    this._configure(options || {});
  };

  _.extend(Context.prototype, Backbone.Events, {

    initialize: function() {},

    activate: function() {
      if (!this.active) {
        this.active = true;
        this.trigger("activate", this);
      }
    },

    deactivate: function() {
      if (this.active) {
        this.active = false;
        this.trigger("deactivate", this);
      }
    },

    adapt: function(object, trait) {
      if (object === root) throw new Error("Cannot adapt the global object.");
      if (!_.isObject(object)) throw new Error("Only objects can be adapted.");
      if (this.getAdaptation(object)) throw new Error("Object already adapted.");
      this.adaptations.push({object: object, trait: trait});
      this.trigger("adapt", object);
    },

    getAdaptation: function(object) {
      return _.find(this.adaptations, function(adapted) {
        return adapted.object === object;
      });
    },

    _configure: function(options) {      
      if (!options.name || options.name === "") throw new Error("Context object must have a name.");
      this.active      = false;
      this.adaptations = [];
      this.name        = options.name;
      if (options.initialize) this.initialize = options.initialize;
    }

  });

  var ContextManager = Cop.ContextManager = function(options) {
    this._configure(options || {});
  };

  _.extend(ContextManager.prototype, Backbone.Events, {

    start: function() {
      log("Context manager is preparing to start up.");
      var self = this;
      this.contexts.registered.each(function(context) {
        log("Initializing context '" + context.name + "'.");

        if (context.adaptations.length > 0) {
          _.each(context.adaptations, function(adaptation) {
            self._onAdapt(adaptation.object);
          }); 
        }
        context.initialize();
        log("Context '" + context.name + "' is now initialized.");
      });
      this.running = true;
      log("Context manager is now running.");
      if (this.contexts.toActivate.length > 0) this.trigger("recompose:start");
      log("Context manager has started up.");
    },

    resolveConflict: function(object, contexts, getResolvedTrait) {
      var name = getName(contexts, true);
      var records = this.resolvedTraits.lookup(name);
      if (!records) {
        records = [];
        this.resolvedTraits.store(name, records);
      }
      var record = _.find(records, function(record) {
        return record.object === object;
      });
      if (record) throw new Error("Object already has resolved trait for contexts: " + name + ".");
      else
        records.push({
          object:   object,
          contexts: contexts,
          getResolvedTrait: getResolvedTrait
        });
    },

    _onAdapt: function(object) {
      var originalObject = _.find(this.originalObjects, function(original) {
        return original.object === object;
      });
      if (!originalObject) {
        this.originalObjects.push({
          object:   object,
          original: _.clone(object)
        });
      }
    },

    _onContextChange: function(context) {
      log("Context '" + context.name + "' triggered " + (context.active ? "activate, marked for activation." : "deactivate, marked for deactivation."));
      if (context.active) {
        this.contexts.toActivate.push(context);
      } 
      else {
        this.contexts.toDeactivate.push(context);
      }
      if (this.running) this.trigger("recompose:start");
      else log("Context manager not running: context '" + context.name + "' not activated yet.");
    },
  

    _onRecomposeStart: function() {
      var contexts = this.contexts;
      log("Contexts recomposition started:");
      log("Contexts active: [" + getName(contexts.active) + "], to activate: [" + getName(contexts.toActivate) + "], to deactivate: [" + getName(contexts.toDeactivate) + "].");
      this.composer.recompose({
        contexts:  this.contexts,
        relations: this.relations
      });
    },

    _onRecomposeEnd: function(contexts) {
      this.contexts = contexts;
      log("Contexts recompositon ended!");
      log("Contexts active: [" + getName(contexts.active) + "], to activate: [" + getName(contexts.toActivate) + "], to deactivate: [" + getName(contexts.toDeactivate) + "].");
    },

    _configure: function(options) {
      var composer  = new Composer({ contextManager: this });
      var contexts  = new Dictionary();
      var relations = new Dictionary();
      var self = this;

      if (!_.isArray(options.contexts) || options.contexts.length == 0) throw new Error("Cannot create context manager without contexts.");
      _.each(options.contexts, function(context) {
        if (contexts.contains(context.name)) throw new Error("Already registered context: " + context.name + ".");
        else {

          contexts.store(context.name, context);

          context.on("activate",   self._onContextChange, self);
          context.on("deactivate", self._onContextChange, self);
          context.on("adapt",      self._onAdapt,         self);
        }
      });

      if (_.isArray(options.relations) && options.relations.length > 0) {
        log("TODO: initialize context relations.");
      }

      this.on("recompose:start", this._onRecomposeStart, this);
      this.on("recompose:end",   this._onRecomposeEnd,   this);

      this.composer = composer;
      this.contexts = {
        registered:   contexts,
        active:       [],
        toActivate:   [],
        toDeactivate: []
      };
      this.options = options;
      this.originalObjects = [];
      this.relations = relations;
      this.resolvedTraits = new Dictionary();
    }

  });

  var Composer = function(options) {
    this._configure(options || {});
  };

  var superName = '_super';

  _.extend(Composer.prototype, {
    

    recompose: function(options) {
      var adaptations;
      var conflicts;
      var contexts  = options.contexts;
      var relations = options.relations;
      contexts = this._resolveDependencies(contexts, relations);
      log("Contexts with resolved dependencies: ", contexts);
      adaptations = this._getAdaptations(contexts);
      log("Uncomposed adaptations: ", adaptations);
      this._compose(adaptations);
      log("Composed adaptations: ", adaptations);

      conflicts = _.filter(adaptations, function(adaptation) {
        return adaptation.hasConflict;
      });
      if (conflicts.length > 0) {

        _.each(conflicts, function(conflict) {
          var contexts     = getName(conflict.contexts);
          var errorMessage = conflict.errorMessage;
          var object       = conflict.object;
          log("Contexts ", contexts, ", object: ", object, ", conflict: ", errorMessage);
          throw new Error("Contexts " + contexts + " have unresolved conflict for object: " + object + " with error message: " + errorMessage);
        });

        contexts = options.contexts;
      }
      else {          
        log("No conflicts detected.");

        this._install(adaptations);

        contexts = {
          active       : _.difference(_.union(contexts.active, contexts.toActivate), contexts.toDeactivate),
          toActivate   : [],
          toDeactivate : []
        };
      }

      this.contextManager.trigger("recompose:end", contexts);
    },

    _resolveDependencies: function(contexts, relations) {
      log("TODO: resolve context dependencies.");
      contexts.active     = _.difference(contexts.active, contexts.toDeactivate);
      contexts.toActivate = _.difference(contexts.toActivate, contexts.active);
      return contexts;
    },

    _getAdaptations: function(contexts) {
      var results = [];

      function addToResults(context, adaptation, addTraits) {
        addTraits || (addTraits = false);
        var found = false;

        _.each(results, function(result) {
          if (result.object === adaptation.object) {
            found = true;
            if (addTraits) {

              result.traits.push(adaptation.trait);
              result.contexts.push(context);
            }
          }
        });
        if (!found && addTraits) 

          results.push({
            object:   adaptation.object,
            traits:   [adaptation.trait],
            contexts: [context]
          });
        else if (!found)

          results.push({
            object:   adaptation.object,
            traits:   [],
            contexts: []
          });
      }

      _.each(contexts.toActivate, function(context) {
        _.each(context.adaptations, function(adaptation) {
          addToResults(context, adaptation, true);
        });
      });

      _.each(contexts.toDeactivate, function(context) {
        _.each(context.adaptations, function(adaptation) {
          addToResults(context, adaptation);
        });
      });

      var originalObjects = this.contextManager.originalObjects;

      _.each(results, function(record) {

        _.each(contexts.active, function(activeContext) {
          var adaptation = activeContext.getAdaptation(record.object);
          if (adaptation) {
            record.traits.push(adaptation.trait);
            record.contexts.push(activeContext);
          }
        });

        var originalObject = _.find(originalObjects, function(original) {
          return original.object === record.object;
        });
        record.originalObject = _.clone(originalObject.original);
      });
      return results;
    },

    _compose: function(adaptations) {

      var resolvedTraits = this.contextManager.resolvedTraits;

      function bindAllMethods(object, self) {
        _.each(object, function(property, name) {
          if (_.isFunction(property))
            object[name] = _.bind(property, self);
        });
      }

      function checkConflicts(adaptation) {
        try {
          Trait.create({}, adaptation.composedTrait);
        }
        catch (err) {
          adaptation.hasConflict  = true;
          adaptation.errorMessage = err.message;
        }
      }

      function resolve(adaptation) {
        var name    = getName(adaptation.contexts, true);
        var records = resolvedTraits.lookup(name);
        var record  = _.find(records, function(record) {
          return record.object === adaptation.object;
        });
        if (record) {

          var orderedTraits = [];
          _.each(record.contexts, function(context) {
            var index = _.indexOf(adaptation.contexts, context);
            orderedTraits.push(adaptation.traits[index]);
          });

          if (record.getResolvedTrait) {

            var resolvedTrait = record.getResolvedTrait.apply(null, orderedTraits);

            adaptation.composedTrait = resolvedTrait;
          } 

          else {

            var superObject = _.clone(adaptation.originalObject);
            var composedObject = null;

            bindAllMethods(superObject, adaptation.object);

            _.each(orderedTraits.reverse(), function(trait) {
              var _super = {};
              _super[superName] = superObject;
              composedObject = Object.create(superObject, Trait.compose(trait, Trait(_super)));

              _.each(superObject, function(property, name) {
                if (_.isFunction(property) && _.has(superObject, name))
                  superObject[name] = _.bind(property, superObject);
              });
              superObject = composedObject;
            });
            delete adaptation.composedTrait;

            adaptation.composedObject = composedObject;
          }
          delete adaptation.hasConflict;
          delete adaptation.errorMessage;
        }
      }

      _.each(adaptations, function(adaptation) {

        adaptation.composedTrait = Trait.compose.apply(null, adaptation.traits);

        checkConflicts(adaptation);

        if (adaptation.hasConflict) 
          resolve(adaptation);

        if (adaptation.hasConflict) {
          log("No resolved trait provided for object: ", adaptation.object, " and contexts: ", getName(adaptation.contexts));
        }

        else if (adaptation.composedTrait) {
          var _super = {};
          var superObject = _.clone(adaptation.originalObject);

          bindAllMethods(superObject, adaptation.object);
          _super[superName] = superObject;

          var composedTrait = Trait.compose(adaptation.composedTrait, Trait(_super));

          adaptation.composedObject = Object.create(superObject, composedTrait);
        }
      });
    },

    _install: function(adaptations) {
      function restore(object, fromObject) {
        _.each(_.keys(object), function(key) { delete object[key]; });
        _.extend(object, fromObject);
      }
      _.each(adaptations, function(adaptation) {
        restore(adaptation.object, adaptation.composedObject);
      });
    },

    _configure: function(options) {
      if (!options.contextManager) throw new Error("Cannot create composer without a context manager.");
      this.contextManager = options.contextManager;
    }

  });

  function Dictionary(startValues) {
    this.values = _.clone(startValues) || {};
  }

  _.extend(Dictionary.prototype, {

    store: function(name, value) {
      this.values[name] = value;
    },
    

    lookup: function(name) {
      return this.values[name];
    },
    

    contains: function(name) {
      return Object.prototype.hasOwnProperty.call(this.values, name) &&
        Object.prototype.propertyIsEnumerable.call(this.values, name);
    },

    each: function(action) {
      _.each(this.values, action);
    }

  });

  function getName(contexts, ordered) {
    var result = _.pluck(contexts, 'name');
    if (ordered) result.sort();
    return result.join(",");
  }
  

  var history = ContextManager.history = []; 

  var log = function() { history.push(_.toArray(arguments)); };

  ContextManager.showHistory = function() { 
    _.each(history, function(lineArray) { 
      console.log(lineArray); 
    });
  };

}).call(this);