Events fixes, Events spec

spec/runner.html

@@ -13,6 +13,7 @@
 		<!-- /core -->
 		<script type="text/javascript" src="../src/core/Util.js"></script>
 		<script type="text/javascript" src="../src/core/Class.js"></script>
+		<script type="text/javascript" src="../src/core/Events.js"></script>
 
 		<!-- /geometry -->
 		<script type="text/javascript" src="../src/geometry/Point.js"></script>
@@ -23,6 +24,7 @@
 		<!-- /core -->
 		<script type="text/javascript" src="suites/core/UtilSpec.js"></script>
 		<script type="text/javascript" src="suites/core/ClassSpec.js"></script>
+		<script type="text/javascript" src="suites/core/EventsSpec.js"></script>
 
 		<!-- /geometry -->
 		<script type="text/javascript" src="suites/geometry/PointSpec.js"></script>

spec/suites/core/EventsSpec.js

@@ -0,0 +1,105 @@
+describe('Events', function() {
+	var Klass;
+	
+	beforeEach(function() {
+		Klass = L.Class.extend({
+			includes: L.Mixin.Events
+		});
+	});
+	
+	describe('#fireEvent', function() {
+		
+		it('should fire all listeners added through #addEventListener', function() {
+			var obj = new Klass(),
+				spy = jasmine.createSpy(),
+				spy2 = jasmine.createSpy(),
+				spy3 = jasmine.createSpy();
+			
+			obj.addEventListener('test', spy);
+			obj.addEventListener('test', spy2);
+			obj.addEventListener('other', spy3);
+			
+			expect(spy).not.toHaveBeenCalled();
+			expect(spy2).not.toHaveBeenCalled();
+			expect(spy3).not.toHaveBeenCalled();
+			
+			obj.fireEvent('test');
+			
+			expect(spy).toHaveBeenCalled();
+			expect(spy2).toHaveBeenCalled();
+			expect(spy3).not.toHaveBeenCalled();
+		});
+
+		it('should provide event object to listeners and execute them in the right context', function() {
+			var obj = new Klass(),
+				obj2 = new Klass(),
+				foo = {};
+			
+			function listener1(e) {
+				expect(e.type).toEqual('test');
+				expect(e.target).toEqual(obj);
+				expect(this).toEqual(obj);
+				expect(e.bar).toEqual(3);
+			};
+			
+			function listener2(e) {
+				expect(e.target).toEqual(obj2);
+				expect(this).toEqual(foo);
+			};
+			
+			obj.addEventListener('test', listener1);
+			obj2.addEventListener('test', listener2, foo);
+			
+			obj.fireEvent('test', {bar: 3});
+		});
+		
+		it('should not call listeners removed through #removeEventListener', function() {
+			var obj = new Klass(),
+				spy = jasmine.createSpy();
+			
+			obj.addEventListener('test', spy);
+			obj.removeEventListener('test', spy);
+			
+			obj.fireEvent('test');
+			
+			expect(spy).not.toHaveBeenCalled();
+		});
+	});
+	
+	describe('#on & #off', function() {
+		
+		it('should work like #addEventListener && #removeEventListener', function() {
+			var obj = new Klass(),
+				spy = jasmine.createSpy();
+			
+			obj.on('test', spy);
+			obj.fireEvent('test');
+			
+			expect(spy).toHaveBeenCalled();
+			
+			obj.off('test', spy);
+			obj.fireEvent('test');
+			
+			expect(spy.callCount).toBeLessThan(2);
+		});
+		
+		it('should not override existing methods with the same name', function() {
+			var spy1 = jasmine.createSpy(),
+				spy2 = jasmine.createSpy();
+			
+			var Klass2 = L.Class.extend({
+				includes: L.Mixin.Events,
+				on: spy1,
+				off: spy2
+			});
+			
+			var obj = new Klass2();
+			
+			obj.on();
+			expect(spy1).toHaveBeenCalled();
+			
+			obj.off();
+			expect(spy2).toHaveBeenCalled();
+		});
+	});
+});

src/core/Events.js

@@ -1,7 +1,7 @@
 L.Mixin = {};
 
 L.Mixin.Events = {
-	addListener: function(type, fn, context) {
+	addEventListener: function(type, fn, context) {
 		this._events = this._events || {};
 		this._events[type] = this._events[type] || [];
 		this._events[type].push({
@@ -10,24 +10,38 @@ L.Mixin.Events = {
 		});
 	},
 	
-	hasListeners: function(type) {
-		return (_events in this) && (type in obj._events) && (obj._events[type].length > 0);
+	hasEventListeners: function(type) {
+		return ('_events' in this) && (type in this._events) && (this._events[type].length > 0);
 	},
 	
-	removeListener: function(type, fn, context) {
-		if (!this.hasListeners(type)) { return; }
+	removeEventListener: function(type, fn, context) {
+		if (!this.hasEventListeners(type)) { return; }
 		
 		for (var i = 0, len = this._events[type].length; i < len; i++) {
 			if (
 				(this._events[type][i].action === fn) && 
-				(!context || (obj._events[type][i].context === context))
+				(!context || (this._events[type][i].context === context))
 			) {
-				obj._events[type].splice(i, 1);
+				this._events[type].splice(i, 1);
 				return;
 			}
 		}
 	},
 	
-	on: this.addListener,
-	off: this.removeListener
-};
+	fireEvent: function(type, data) {
+		if (!this.hasEventListeners(type)) { return; }
+		
+		var event = data || {};
+		event.type = type;
+		event.target = this;
+		
+		var listeners = this._events[type].slice();
+		
+		for (var i = 0, len = listeners.length; i < len; i++) {
+			listeners[i].action.call(listeners[i].context || this, event);
+		}
+	}
+};
+
+L.Mixin.Events.on = L.Mixin.Events.addEventListener;
+L.Mixin.Events.off = L.Mixin.Events.removeEventListener;