leaflet-js 0.6.beta4

data/lib/leaflet/spec/suites/LeafletSpec.js

@@ -0,0 +1,13 @@
+describe('L#noConflict', function() {
+	it('restores the previous L value and returns Leaflet namespace', function(){
+
+		expect(L.version).to.be.ok();
+
+		var L2 = L.noConflict();
+
+		expect(L).to.eql('test');
+		expect(L2.version).to.be.ok();
+
+		window.L = L2;
+	});
+});

data/lib/leaflet/spec/suites/SpecHelper.js

@@ -0,0 +1,26 @@
+function noSpecs() {
+	xit('has no specs');
+}
+
+if (!Array.prototype.map) {
+  Array.prototype.map = function(fun /*, thisp */) {
+    "use strict";
+
+    if (this === void 0 || this === null)
+      throw new TypeError();
+
+    var t = Object(this);
+    var len = t.length >>> 0;
+    if (typeof fun !== "function")
+      throw new TypeError();
+
+    var res = new Array(len);
+    var thisp = arguments[1];
+    for (var i = 0; i < len; i++) {
+      if (i in t)
+        res[i] = fun.call(thisp, t[i], i, t);
+    }
+
+    return res;
+  };
+}

data/lib/leaflet/spec/suites/control/Control.AttributionSpec.js

@@ -0,0 +1,68 @@
+describe("Control.Attribution", function () {
+
+	var map, control, container;
+
+	beforeEach(function () {
+		map = L.map(document.createElement('div'));
+		control = new L.Control.Attribution({
+			prefix: 'prefix'
+		}).addTo(map);
+		container = control.getContainer();
+	});
+
+	it("contains just prefix if no attributions added", function () {
+		expect(container.innerHTML).to.eql('prefix');
+	});
+
+	describe('#addAttribution', function () {
+		it('adds one attribution correctly', function () {
+			control.addAttribution('foo');
+			expect(container.innerHTML).to.eql('prefix | foo');
+		});
+
+		it('adds no duplicate attributions', function () {
+			control.addAttribution('foo');
+			control.addAttribution('foo');
+			expect(container.innerHTML).to.eql('prefix | foo');
+		});
+
+		it('adds several attributions listed with comma', function () {
+			control.addAttribution('foo');
+			control.addAttribution('bar');
+			expect(container.innerHTML).to.eql('prefix | foo, bar');
+		});
+	});
+
+	describe('#removeAttribution', function () {
+		it('removes attribution correctly', function () {
+			control.addAttribution('foo');
+			control.addAttribution('bar');
+			control.removeAttribution('foo');
+			expect(container.innerHTML).to.eql('prefix | bar');
+		});
+		it('does nothing if removing attribution that was not present', function () {
+			control.addAttribution('foo');
+			control.addAttribution('baz');
+			control.removeAttribution('bar');
+			control.removeAttribution('baz');
+			control.removeAttribution('baz');
+			control.removeAttribution('');
+			expect(container.innerHTML).to.eql('prefix | foo');
+		});
+	});
+
+	describe('#setPrefix', function () {
+		it('changes prefix', function () {
+			control.setPrefix('bla');
+			expect(container.innerHTML).to.eql('bla');
+		});
+	});
+
+	describe('control.attribution factory', function () {
+		it('creates Control.Attribution instance', function () {
+			var options = {prefix: 'prefix'};
+			expect(L.control.attribution(options)).to.eql(new L.Control.Attribution(options));
+		});
+	});
+
+});

data/lib/leaflet/spec/suites/control/Control.LayersSpec.js

@@ -0,0 +1,67 @@
+describe("Control.Layers", function () {
+	var map;
+
+	beforeEach(function () {
+		map = L.map(document.createElement('div'));
+	});
+
+	describe("baselayerchange event", function () {
+		it("is fired on input that changes the base layer", function () {
+			var baseLayers = {"Layer 1": L.tileLayer(), "Layer 2": L.tileLayer()},
+				layers = L.control.layers(baseLayers).addTo(map),
+				spy = sinon.spy();
+
+			map.on('baselayerchange', spy)
+				.whenReady(function() {
+					happen.click(layers._baseLayersList.getElementsByTagName("input")[0]);
+
+					expect(spy.called).to.be.ok();
+					expect(spy.mostRecentCall.args[0].layer).to.be(baseLayers["Layer 1"]);
+				});
+		});
+
+		it("is not fired on input that doesn't change the base layer", function () {
+			var overlays = {"Marker 1": L.marker([0, 0]), "Marker 2": L.marker([0, 0])},
+				layers = L.control.layers({}, overlays).addTo(map),
+				spy = sinon.spy();
+
+			map.on('baselayerchange', spy);
+			happen.click(layers._overlaysList.getElementsByTagName("input")[0]);
+
+			expect(spy.called).to.not.be.ok();
+		});
+	});
+
+	describe("updates", function () {
+		beforeEach(function () {
+			map.setView([0, 0], 14);
+		});
+
+		it("when an included layer is addded or removed", function () {
+			var baseLayer = L.tileLayer(),
+				overlay = L.marker([0, 0]),
+				layers = L.control.layers({"Base": baseLayer}, {"Overlay": overlay}).addTo(map);
+
+			var spy = sinon.spy(layers, '_update');
+
+			map.addLayer(overlay);
+			map.removeLayer(overlay);
+
+			expect(spy.called).to.be.ok();
+			expect(spy.callCount).to.eql(2);
+		});
+
+		it("not when a non-included layer is added or removed", function () {
+			var baseLayer = L.tileLayer(),
+				overlay = L.marker([0, 0]),
+				layers = L.control.layers({"Base": baseLayer}).addTo(map);
+
+			var spy = sinon.spy(layers, '_update');
+
+			map.addLayer(overlay);
+			map.removeLayer(overlay);
+
+			expect(spy.called).to.not.be.ok();
+		});
+	});
+});

data/lib/leaflet/spec/suites/control/Control.ScaleSpec.js

@@ -0,0 +1,6 @@
+describe("Control.Scale", function () {
+	it("can be added to an unloaded map", function () {
+		var map = L.map(document.createElement('div'));
+		new L.Control.Scale().addTo(map);
+	});
+});

data/lib/leaflet/spec/suites/core/ClassSpec.js

@@ -0,0 +1,156 @@
+describe("Class", function() {
+
+	describe("#extend", function() {
+		var Klass,
+			constructor,
+			method;
+
+		beforeEach(function() {
+			constructor = sinon.spy();
+			method = sinon.spy();
+
+			Klass = L.Class.extend({
+				statics: {bla: 1},
+				includes: {mixin: true},
+
+				initialize: constructor,
+				foo: 5,
+				bar: method
+			});
+		});
+
+		it("creates a class with the given constructor & properties", function() {
+			var a = new Klass();
+
+			expect(constructor.called).to.be.ok();
+			expect(a.foo).to.eql(5);
+
+			a.bar();
+
+			expect(method.called).to.be.ok();
+		});
+
+		it("inherits parent classes' constructor & properties", function() {
+			var Klass2 = Klass.extend({baz: 2});
+
+			var b = new Klass2();
+
+			expect(b instanceof Klass).to.be.ok();
+			expect(b instanceof Klass2).to.be.ok();
+
+			expect(constructor.called).to.be.ok();
+			expect(b.baz).to.eql(2);
+
+			b.bar();
+
+			expect(method.called).to.be.ok();
+		});
+
+		it("supports static properties", function() {
+			expect(Klass.bla).to.eql(1);
+		});
+
+		it("inherits parent static properties", function() {
+			var Klass2 = Klass.extend({});
+
+			expect(Klass2.bla).to.eql(1);
+		});
+
+		it("overrides parent static properties", function() {
+			var Klass2 = Klass.extend({statics: {bla: 2}});
+
+			expect(Klass2.bla).to.eql(2);
+		});
+
+		it("includes the given mixin", function() {
+			var a = new Klass();
+			expect(a.mixin).to.be.ok();
+		});
+
+		it("includes multiple mixins", function() {
+			var Klass2 = L.Class.extend({
+				includes: [{mixin: true}, {mixin2: true}]
+			});
+			var a = new Klass2();
+
+			expect(a.mixin).to.be.ok();
+			expect(a.mixin2).to.be.ok();
+		});
+
+		it("grants the ability to include the given mixin", function() {
+			Klass.include({mixin2: true});
+
+			var a = new Klass();
+			expect(a.mixin2).to.be.ok();
+		});
+
+		it("merges options instead of replacing them", function() {
+			var KlassWithOptions1 = L.Class.extend({
+				options: {
+					foo1: 1,
+					foo2: 2
+				}
+			});
+			var KlassWithOptions2 = KlassWithOptions1.extend({
+				options: {
+					foo2: 3,
+					foo3: 4
+				}
+			});
+
+			var a = new KlassWithOptions2();
+
+			expect(a.options).to.eql({
+				foo1: 1,
+				foo2: 3,
+				foo3: 4
+			});
+		});
+
+		it("adds constructor hooks correctly", function () {
+			var spy1 = sinon.spy();
+
+			Klass.addInitHook(spy1);
+			Klass.addInitHook('bar', 1, 2, 3);
+
+			var a = new Klass();
+
+			expect(spy1.called).to.be.ok();
+			expect(method.calledWith(1, 2, 3));
+		});
+
+		it("inherits constructor hooks", function () {
+			var spy1 = sinon.spy(),
+				spy2 = sinon.spy();
+
+			var Klass2 = Klass.extend({});
+
+			Klass.addInitHook(spy1);
+			Klass2.addInitHook(spy2);
+
+			var a = new Klass2();
+
+			expect(spy1.called).to.be.ok();
+			expect(spy2.called).to.be.ok();
+		});
+
+		it("does not call child constructor hooks", function () {
+			var spy1 = sinon.spy(),
+				spy2 = sinon.spy();
+
+			var Klass2 = Klass.extend({});
+
+			Klass.addInitHook(spy1);
+			Klass2.addInitHook(spy2);
+
+			var a = new Klass();
+
+			expect(spy1.called).to.be.ok();
+			expect(spy2.called).to.eql(false);
+		});
+	});
+
+	// TODO Class.include
+
+	// TODO Class.mergeOptions
+});

data/lib/leaflet/spec/suites/core/EventsSpec.js

@@ -0,0 +1,336 @@
+describe('Events', function() {
+	var Klass;
+
+	beforeEach(function() {
+		Klass = L.Class.extend({
+			includes: L.Mixin.Events
+		});
+	});
+
+	describe('#fireEvent', function() {
+
+		it('fires all listeners added through #addEventListener', function() {
+			var obj = new Klass(),
+				spy1 = sinon.spy(),
+				spy2 = sinon.spy(),
+				spy3 = sinon.spy(),
+				spy4 = sinon.spy(),
+				spy5 = sinon.spy();
+				spy6 = sinon.spy();
+
+			obj.addEventListener('test', spy1);
+			obj.addEventListener('test', spy2);
+			obj.addEventListener('other', spy3);
+			obj.addEventListener({ test: spy4, other: spy5 });
+			obj.addEventListener({'test other': spy6 });
+
+			expect(spy1.called).to.be(false);
+			expect(spy2.called).to.be(false);
+			expect(spy3.called).to.be(false);
+			expect(spy4.called).to.be(false);
+			expect(spy5.called).to.be(false);
+			expect(spy6.called).to.be(false);
+
+			obj.fireEvent('test');
+
+			expect(spy1.called).to.be(true);
+			expect(spy2.called).to.be(true);
+			expect(spy3.called).to.be(false);
+			expect(spy4.called).to.be(true);
+			expect(spy5.called).to.be(false);
+			expect(spy6.called).to.be(true);
+			expect(spy6.callCount).to.be(1);
+		});
+
+		it('provides event object to listeners and executes them in the right context', function() {
+			var obj = new Klass(),
+				obj2 = new Klass(),
+				obj3 = new Klass(),
+				obj4 = new Klass(),
+				foo = {};
+
+			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.addEventListener('test', listener1);
+			obj2.addEventListener('test', listener2, foo);
+			obj3.addEventListener({ test: listener3 });
+			obj4.addEventListener({ test: listener4 }, foo);
+
+			obj.fireEvent('test', {baz: 1});
+			obj2.fireEvent('test', {baz: 2});
+			obj3.fireEvent('test', {baz: 3});
+			obj4.fireEvent('test', {baz: 4});
+		});
+
+		it('calls no listeners removed through #removeEventListener', function() {
+			var obj = new Klass(),
+				spy = sinon.spy(),
+				spy2 = sinon.spy(),
+				spy3 = sinon.spy(),
+				spy4 = sinon.spy(),
+				spy5 = sinon.spy();
+
+			obj.addEventListener('test', spy);
+			obj.removeEventListener('test', spy);
+
+			obj.fireEvent('test');
+
+			expect(spy.called).to.be(false);
+
+			obj.addEventListener('test2', spy2);
+			obj.addEventListener('test2', spy3);
+			obj.removeEventListener('test2');
+
+			obj.fireEvent('test2');
+
+			expect(spy2.called).to.be(false);
+			expect(spy3.called).to.be(false);
+
+			obj.addEventListener('test3', spy4);
+			obj.addEventListener('test4', spy5);
+			obj.removeEventListener({
+				test3: spy4,
+				test4: spy5
+			});
+
+			obj.fireEvent('test3');
+			obj.fireEvent('test4');
+
+			expect(spy4.called).to.be(false);
+			expect(spy5.called).to.be(false);
+		});
+
+		it('can handle calls to #removeEventListener on objects with no registered event listeners', function () {
+			var obj = new Klass();
+			var removeNonExistentListener = function () {
+				obj.removeEventListener('test');
+			};
+			expect(removeNonExistentListener).to.not.throwException();
+		});
+
+		// added due to context-sensitive removeListener optimization
+		it('fires multiple listeners with the same context with id', function () {
+			var obj = new Klass(),
+				spy1 = sinon.spy(),
+				spy2 = sinon.spy(),
+				foo = {};
+
+			L.Util.stamp(foo);
+
+			obj.addEventListener('test', spy1, foo);
+			obj.addEventListener('test', spy2, foo);
+
+			obj.fireEvent('test');
+
+			expect(spy1.called).to.be(true);
+			expect(spy2.called).to.be(true);
+		});
+
+		it('removes listeners with stamped contexts', function () {
+			var obj = new Klass(),
+				spy1 = sinon.spy(),
+				spy2 = sinon.spy(),
+				foo = {};
+
+			L.Util.stamp(foo);
+
+			obj.addEventListener('test', spy1, foo);
+			obj.addEventListener('test', spy2, foo);
+
+			obj.removeEventListener('test', spy1, foo);
+
+			obj.fireEvent('test');
+
+			expect(spy1.called).to.be(false);
+			expect(spy2.called).to.be(true);
+		});
+
+		it('removes listeners with a stamp originally added without one', function() {
+			var obj = new Klass(),
+				spy1 = sinon.spy(),
+				spy2 = sinon.spy(),
+				foo = {};
+
+			obj.addEventListener('test', spy1, foo);
+			L.Util.stamp(foo);
+			obj.addEventListener('test', spy2, foo);
+
+			obj.removeEventListener('test', spy1, foo);
+			obj.removeEventListener('test', spy2, foo);
+
+			obj.fireEvent('test');
+
+			expect(spy1.called).to.be(false);
+			expect(spy2.called).to.be(false);
+		});
+		it('doesnt lose track of listeners when removing non existent ones', function () {
+			var obj = new Klass(),
+			    spy = sinon.spy(),
+			    spy2 = sinon.spy(),
+			    foo = {},
+			    foo2 = {};
+
+			L.Util.stamp(foo);
+			L.Util.stamp(foo2);
+
+			obj.addEventListener('test', spy, foo2);
+
+			obj.removeEventListener('test', spy, foo); // Decrements test_idx to 0, even though event listener isn't registered with foo's _leaflet_id
+			obj.removeEventListener('test', spy, foo2);  // Doesn't get removed
+
+			obj.addEventListener('test', spy2, foo);
+
+			obj.fireEvent('test');
+
+			expect(spy.called).to.be(false);
+		});
+	});
+
+	describe('#on, #off & #fire', function() {
+
+		it('works like #addEventListener && #removeEventListener', function() {
+			var obj = new Klass(),
+				spy = sinon.spy();
+
+			obj.on('test', spy);
+			obj.fire('test');
+
+			expect(spy.called).to.be(true);
+
+			obj.off('test', spy);
+			obj.fireEvent('test');
+
+			expect(spy.callCount).to.be.lessThan(2);
+		});
+
+		it('does not override existing methods with the same name', function() {
+			var spy1 = sinon.spy(),
+				spy2 = sinon.spy(),
+				spy3 = sinon.spy();
+
+			var Klass2 = L.Class.extend({
+				includes: L.Mixin.Events,
+				on: spy1,
+				off: spy2,
+				fire: spy3
+			});
+
+			var obj = new Klass2();
+
+			obj.on();
+			expect(spy1.called).to.be(true);
+
+			obj.off();
+			expect(spy2.called).to.be(true);
+
+			obj.fire();
+			expect(spy3.called).to.be(true);
+		});
+	});
+
+	describe("#clearEventListeners", function() {
+		it("clears all registered listeners on an object", function() {
+			var spy = sinon.spy(),
+				obj = new Klass()
+				otherObj = new Klass();
+
+			obj.on('test', spy, obj);
+			obj.on('testTwo', spy);
+			obj.on('test', spy, otherObj);
+			obj.off();
+
+			obj.fire('test');
+
+			expect(spy.called).to.be(false);
+		});
+	});
+
+	describe('#once', function() {
+		it('removes event listeners after first trigger', function() {
+			var obj = new Klass(),
+				spy = sinon.spy();
+
+			obj.once('test', spy, obj);
+			obj.fire('test');
+
+			expect(spy.called).to.be(true);
+
+			obj.fire('test');
+
+			expect(spy.callCount).to.be.lessThan(2);
+		});
+
+		it('works with an object hash', function() {
+			var obj = new Klass(),
+				spy = sinon.spy(),
+				otherSpy = sinon.spy();
+
+			obj.once({
+				'test': spy,
+				otherTest: otherSpy
+			}, obj);
+
+			obj.fire('test');
+			obj.fire('otherTest');
+
+			expect(spy.called).to.be(true);
+			expect(otherSpy.called).to.be(true);
+
+			obj.fire('test');
+			obj.fire('otherTest');
+
+			expect(spy.callCount).to.be.lessThan(2);
+			expect(otherSpy.callCount).to.be.lessThan(2);
+		});
+
+		it("doesn't call listeners to events that have been removed", function () {
+		    var obj = new Klass(),
+                spy = sinon.spy();
+
+		    obj.once('test', spy, obj);
+		    obj.off('test', spy, obj);
+
+		    obj.fire('test');
+
+		    expect(spy.called).to.be(false);
+		});
+
+		it('works if called from a context that doesnt implement #Events', function() {
+			var obj = new Klass(),
+				spy = sinon.spy(),
+				foo = {};
+
+			obj.once('test', spy, foo);
+
+			obj.fire('test');
+
+			expect(spy.called).to.be(true);
+		});
+	});
+});