Merge branch 'event-emitter' into v1

Author: benpickles

src/collection.js

@@ -57,7 +57,7 @@
   Collection.prototype.add = function(model) {
     if (!~this.indexOf(model)) {
       var length = this.push(model)
-      this.trigger("add", [model])
+      this.emit("add", model)
       return length
     }
   }
@@ -90,6 +90,12 @@
     return this.at(this.length - 1)
   }
 
+  Collection.prototype.listenTo = function(emitter) {
+    emitter
+      .on("save",    this.add,    this)
+      .on("destroy", this.remove, this)
+  }
+
   Collection.prototype.pluck = function(attribute) {
     return this.map(function(model) {
       return model.attr(attribute)
@@ -101,7 +107,7 @@
 
     if (~index) {
       this.splice(index, 1)
-      this.trigger("remove", [model])
+      this.emit("remove", model)
       return this.length
     }
   }
@@ -136,5 +142,7 @@
     })
   }
 
-  Model.Utils.extend(Model.Collection.prototype, Model.Callbacks)
+  Collection.prototype.on   = Model.EventEmitter.prototype.on
+  Collection.prototype.off  = Model.EventEmitter.prototype.off
+  Collection.prototype.emit = Model.EventEmitter.prototype.emit
 })(Model);

src/event_emitter.js

@@ -0,0 +1,46 @@
+;(function(Model) {
+  var EventEmitter = Model.EventEmitter = function() {}
+
+  function prepareEvent(name) {
+    if (!this._events) this._events = {}
+    if (!this._events[name]) this._events[name] = []
+    return this._events[name]
+  }
+
+  EventEmitter.prototype.off = function(name, callback, scope) {
+    var events = prepareEvent.call(this, name)
+
+    if (callback) {
+      for (var i = events.length - 1; i >= 0; i--) {
+        var cb = events[i].callback
+        var scp = events[i].scope
+
+        if (cb === callback && scp === scope) {
+          events.splice(i, 1)
+        }
+      }
+    } else {
+      delete this._events[name]
+    }
+
+    return this
+  }
+
+  EventEmitter.prototype.on = function(name, callback, scope) {
+    prepareEvent.call(this, name).push({ callback: callback, scope: scope })
+    return this
+  }
+
+  EventEmitter.prototype.emit = function(name) {
+    var args = Array.prototype.slice.call(arguments, 1)
+    var events = prepareEvent.call(this, name)
+
+    for (var i = 0, length = events.length; i < length; i++) {
+      var callback = events[i].callback
+      var scope = events[i].scope || this
+      callback.apply(scope, args)
+    }
+
+    return this
+  }
+})(Model);

src/model.js

@@ -6,19 +6,23 @@ var Model = function(name, func) {
     this.errors = new Model.Errors(this);
     this.uid = [name, Model.UID.generate()].join("-")
     if (Model.Utils.isFunction(this.initialize)) this.initialize()
+    this.emit("initialize", this)
   };
 
   // Use module functionality to extend itself onto the constructor. Meta!
   Model.Module.extend.call(model, Model.Module)
 
   model._name = name
+  model.anyInstance = new Model.EventEmitter()
   model.collection = new Model.Collection()
   model.persistence = Model.NullPersistence
   model.unique_key = "id"
   model
     .extend(Model.Callbacks)
     .extend(Model.ClassMethods)
 
+  model.collection.listenTo(model.anyInstance)
+
   model.prototype = new Model.Model
   model.prototype.constructor = model
 

src/model_callbacks.js

@@ -33,8 +33,7 @@ Model.Model.prototype = {
 
     this.constructor.persistence.destroy(this, function(success) {
       if (success) {
-        self.constructor.collection.remove(self)
-        self.trigger("destroy")
+        self.emit("destroy", self)
       }
 
       if (callback) callback.apply(this, arguments)
@@ -43,6 +42,12 @@ Model.Model.prototype = {
     return this;
   },
 
+  emit: function() {
+    var anyInstance = this.constructor.anyInstance
+    anyInstance.emit.apply(anyInstance, arguments)
+    Model.EventEmitter.prototype.emit.apply(this, arguments)
+  },
+
   id: function() {
     return this.attributes[this.constructor.unique_key];
   },
@@ -51,6 +56,9 @@ Model.Model.prototype = {
     return this.constructor.persistence.newRecord(this)
   },
 
+  off: Model.EventEmitter.prototype.off,
+  on: Model.EventEmitter.prototype.on,
+
   reset: function() {
     this.errors.clear();
     this.changes = {};
@@ -65,8 +73,7 @@ Model.Model.prototype = {
         if (success) {
           Model.Utils.extend(self.attributes, self.changes)
           self.reset()
-          self.constructor.collection.add(self)
-          self.trigger("save")
+          self.emit("save", self)
         }
 
         if (callback) callback.apply(self, arguments)
@@ -92,5 +99,3 @@ Model.Model.prototype = {
     return this;
   }
 };
-
-Model.Utils.extend(Model.Model.prototype, Model.Callbacks)

src/model_model.js

@@ -12,8 +12,8 @@
 
 <!-- js-model -->
 <script src="../src/model.js"></script>
+<script src="../src/event_emitter.js"></script>
 <script src="../src/model_utils.js"></script>
-<script src="../src/model_callbacks.js"></script>
 <script src="../src/model_class_methods.js"></script>
 <script src="../src/collection.js"></script>
 <script src="../src/model_errors.js"></script>
@@ -32,8 +32,8 @@
 <!-- Tests -->
 <script src="tests/model_test.js"></script>
 <script src="tests/collection_test.js"></script>
+<script src="tests/event_emitter_test.js"></script>
 <script src="tests/model_id_test.js"></script>
-<script src="tests/model_callbacks_test.js"></script>
 <script src="tests/model_class_methods_test.js"></script>
 <script src="tests/model_errors_test.js"></script>
 <script src="tests/model_module_test.js"></script>

test/index.html

@@ -0,0 +1,52 @@
+module("EventEmitter")
+
+test("binding with a scope and emitting with arguments", 3, function() {
+  var ee = new Model.EventEmitter()
+  var obj = {}
+
+  ee.on("a", function(b, c) {
+    equals(b, "b")
+    equals(c, "c")
+    ok(this === obj)
+  }, obj)
+
+  ee.emit("a", "b", "c")
+
+  ee.off("a")
+
+  ee.emit("a", "b", "c")
+})
+
+test("unbinding by callback", 2, function() {
+  var ee = new Model.EventEmitter()
+  var obj = {}
+  var func1 = function(b, c) {
+    ok(false)
+  }
+  var func2 = function(b, c) {
+    equals(b, "b")
+    equals(c, "c")
+  }
+
+  ee.on("a", func1)
+  ee.on("a", func2)
+
+  ee.off("a", func1)
+
+  ee.emit("a", "b", "c")
+})
+
+test("unbinding by callback and scope", 1, function() {
+  var ee = new Model.EventEmitter()
+  var obj = {}
+  var func = function() {
+    ok(this !== obj)
+  }
+
+  ee.on("a", func)
+  ee.on("a", func, obj)
+
+  ee.off("a", func, obj)
+
+  ee.emit("a")
+})