back to first implementation to fix event leak

spec/suites/core/EventsSpec.js

@@ -247,7 +247,7 @@ describe('Events', function() {
 	});
 
 	describe('#once', function() {
-		it('removes event listeners after first fire', function() {
+		it('removes event listeners after first trigger', function() {
 			var obj = new Klass(),
 				spy = new sinon.spy();
 
@@ -261,7 +261,7 @@ describe('Events', function() {
 			expect(spy.callCount).to.be.lessThan(2);
 		});
 
-		it('works with object hash', function() {
+		it('works with an object hash', function() {
 			var obj = new Klass(),
 				spy = new sinon.spy(),
 				otherSpy = new sinon.spy();
@@ -284,88 +284,16 @@ describe('Events', function() {
 			expect(otherSpy.callCount).to.be.lessThan(2);
 		});
 
-		it('only removes the fired event handler', function() {
+		it("doesn't call listeners to events that have been removed", function () {
-			var obj = new Klass(),
+		    var obj = new Klass(),
-				spy = new sinon.spy(),
+                spy = new sinon.spy();
-				otherSpy = new sinon.spy();
 
-			obj.once({
+		    obj.once('test', spy, obj);
-				test: spy,
+		    obj.off('test', spy, obj);
-				otherTest: otherSpy
-			});
 
-			obj.fire('test');
+		    obj.fire('test');
 
-			expect(spy.called).to.be(true);
+		    expect(spy.called).to.be(false);
-			expect(otherSpy.called).to.be(false);
-
-			obj.fire('otherTest');
-
-			expect(otherSpy.called).to.be(true);
-
-			expect(spy.callCount).to.be.lessThan(2);
-			expect(otherSpy.callCount).to.be.lessThan(2);
-		});
-
-		it('can be passed multiple types', function() {
-			var obj = new Klass(),
-				spy = new sinon.spy(),
-				otherSpy = new sinon.spy();
-
-			obj.once('test otherTest', spy, obj);
-			obj.fire('otherTest');
-
-			expect(spy.called).to.be(true);
-
-			obj.fire('test');
-
-			expect(spy.callCount).to.be.lessThan(2);
-		});
-
-		it('provides event object to listeners and executes with the correct context', function() {
-			var obj = new Klass(),
-				obj2 = new Klass(),
-				obj3 = new Klass(),
-				obj4 = new Klass(),
-				foo = new Klass();
-
-			function listener1(e) {
-				expect(e.type).to.eql('test');
-				expect(e.target).to.eql(obj);
-				expect(this).to.eql(obj);
-				expect(e.baz).to.eql(1);
-			}
-
-			function listener2(e) {
-				expect(e.type).to.eql('test');
-				expect(e.target).to.eql(obj2);
-				expect(this).to.eql(foo);
-				expect(e.baz).to.eql(2);
-			}
-
-			function listener3(e) {
-				expect(e.type).to.eql('test');
-				expect(e.target).to.eql(obj3);
-				expect(this).to.eql(obj3);
-				expect(e.baz).to.eql(3);
-			}
-
-			function listener4(e) {
-				expect(e.type).to.eql('test');
-				expect(e.target).to.eql(obj4);
-				expect(this).to.eql(foo);
-				expect(e.baz).to.eql(4);
-			}
-
-			obj.once('test', listener1);
-			obj2.once('test', listener2, foo);
-			obj3.once({ test: listener3 });
-			obj4.once({ test: listener4 }, foo);
-
-			obj.fireEvent('test', {baz: 1});
-			obj2.fireEvent('test', {baz: 2});
-			obj3.fireEvent('test', {baz: 3});
-			obj4.fireEvent('test', {baz: 4});
 		});
 	});
 });

src/core/Events.js

@@ -148,34 +148,26 @@ L.Mixin.Events = {
 	},
 
 	once: function(types, fn, context) {
-		var once = function(fn) {
+	    handlerFor = function (fn, type, context) {
-			var done = false;
+	        var handler = function () {
-			return function() {
+	            this.removeEventListener(type, fn, context);
-				if (done) return;
+	            this.removeEventListener(type, handler, context);
-				fn.apply(this, arguments);
+	        }
-				fn = null;
+	        return handler;
-				done = true;
+	    }
-			}
-		}
 
-		var handlerFor = L.bind(function(type, fn, context) {
+	    if (typeof types === 'object') {
-			var handler = once(function() {
+	        for (type in types) {
-				this.removeEventListener(types, handler);
+	            if (types.hasOwnProperty(type)) {
-				fn.apply(context || this, arguments);
+	                this.addEventListener(type, types[type], fn);
-			});
+	                this.addEventListener(type, handlerFor(types[type], type, fn), fn);
-			return handler;
+	            }
-		}, this);
+	        }
+	        return this;
+	    }
 
-		if (typeof types === 'object') {
+	    this.addEventListener(types, fn, context);
-			for (type in types) {
+	    return this.addEventListener(types, handlerFor(fn, types, context), context);
-				if (types.hasOwnProperty(type)) {
-					this.addEventListener(type, handlerFor(type, types[type], fn), fn);
-				}
-			}
-			return this;
-		}
-
-		return this.addEventListener(types, handlerFor(types,fn,context), context);
 	}
 };